forked from nova/jmonkey-test
41 changed files with 2415 additions and 463 deletions
-
20build.sbt
-
BINlib/jme-jfx-11-1.1.5.jar
-
10src/main/scala/com/jayfella/jme/jfx/package.scala
-
24src/main/scala/com/jme3/animation/package.scala
-
5src/main/scala/com/jme3/app/package.scala
-
6src/main/scala/com/jme3/input/controls/package.scala
-
3src/main/scala/com/jme3/input/package.scala
-
4src/main/scala/com/jme3/scene/package.scala
-
3src/main/scala/org/slf4j/impl/StaticLoggerBuilder.scala
-
88src/main/scala/wow/doge/mygame/Main.scala
-
109src/main/scala/wow/doge/mygame/MainApp.scala
-
142src/main/scala/wow/doge/mygame/game/GameApp.scala
-
38src/main/scala/wow/doge/mygame/game/GameApp2.scala
-
13src/main/scala/wow/doge/mygame/game/GameModule.scala
-
4src/main/scala/wow/doge/mygame/game/GameSystemsInitializer.scala
-
8src/main/scala/wow/doge/mygame/game/nodes/PlayerController.scala
-
4src/main/scala/wow/doge/mygame/game/nodes/PlayerEventListeners.scala
-
33src/main/scala/wow/doge/mygame/game/subsystems/ai/GdxAiTest.scala
-
43src/main/scala/wow/doge/mygame/game/subsystems/ai/gdx/Graph.java
-
371src/main/scala/wow/doge/mygame/game/subsystems/ai/gdx/IndexedAStarPathFinder.java
-
41src/main/scala/wow/doge/mygame/game/subsystems/ai/gdx/MyIndexedGraph.java
-
24src/main/scala/wow/doge/mygame/game/subsystems/input/GameInputHandler.scala
-
6src/main/scala/wow/doge/mygame/game/subsystems/level/DefaultGameLevel.scala
-
12src/main/scala/wow/doge/mygame/game/subsystems/level/GameLevel.scala
-
43src/main/scala/wow/doge/mygame/game/subsystems/ui/JmeJfx.scala
-
88src/main/scala/wow/doge/mygame/implicits/JavaFXMonixObservables.scala
-
43src/main/scala/wow/doge/mygame/implicits/TestEnum.scala
-
18src/main/scala/wow/doge/mygame/implicits/observables/package.scala
-
69src/main/scala/wow/doge/mygame/implicits/package.scala
-
102src/main/scala/wow/doge/mygame/launcher/DefaultUI.scala
-
153src/main/scala/wow/doge/mygame/launcher/Launcher.scala
-
2src/main/scala/wow/doge/mygame/subsystems/events/MovementEvents.scala
-
3src/main/scala/wow/doge/mygame/subsystems/moddingsystem/ModdingSystem.scala
-
35src/main/scala/wow/doge/mygame/subsystems/scriptsystem/ScriptActor.scala
-
73src/main/scala/wow/doge/mygame/subsystems/scriptsystem/ScriptCachingActor.scala
-
1src/main/scala/wow/doge/mygame/subsystems/scriptsystem/ScriptSystemModule.scala
-
750src/main/scala/wow/doge/mygame/utils/BorderlessScene.scala
-
104src/main/scala/wow/doge/mygame/utils/GenericConsoleStream.scala
-
71src/main/scala/wow/doge/mygame/utils/JFXConsoleStream.scala
-
130src/main/scala/wow/doge/mygame/utils/ResizeHelper.java
-
24src/main/scala/wow/doge/mygame/utils/TreeTest.scala
@ -0,0 +1,10 @@ |
|||||
|
package com.jayfella.jme |
||||
|
|
||||
|
package object jfx { |
||||
|
// object JavaFxUI { |
||||
|
// def apply(app: Application) = { |
||||
|
// JavaFxUI.initialize(app) |
||||
|
// JavaFxUI.getInstance() |
||||
|
// } |
||||
|
// } |
||||
|
} |
||||
@ -0,0 +1,33 @@ |
|||||
|
package wow.doge.mygame.game.subsystems.ai |
||||
|
|
||||
|
import com.badlogic.gdx.ai.pfa.Connection |
||||
|
import wow.doge.mygame.game.subsystems.ai.gdx.MyIndexedGraph |
||||
|
import scala.collection.immutable.ArraySeq |
||||
|
// import com.badlogic.gdx.ai.pfa.indexed.IndexedGraph |
||||
|
// import scala.jdk.javaapi.CollectionConverters._ |
||||
|
|
||||
|
case class City(x: Float, y: Float, name: String, index: Int) |
||||
|
case class Street(fromNode: City, toNode: City, cost: Float) |
||||
|
extends Connection[City] { |
||||
|
|
||||
|
override def getCost(): Float = cost |
||||
|
|
||||
|
override def getFromNode(): City = fromNode |
||||
|
|
||||
|
override def getToNode(): City = toNode |
||||
|
|
||||
|
} |
||||
|
|
||||
|
class CityGraph extends MyIndexedGraph[City] { |
||||
|
|
||||
|
override def getConnections( |
||||
|
city: City |
||||
|
): IndexedSeq[Connection[City]] = |
||||
|
ArraySeq(Street(City(0f, 0f, "egw", 0), City(0f, 0f, "egw", 0), 1)) |
||||
|
// or Vector(Street(City(0f, 0f, "egw", 0), City(0f, 0f, "egw", 0), 1)) |
||||
|
|
||||
|
override def getIndex(city: City): Int = ??? |
||||
|
|
||||
|
override def getNodeCount(): Int = ??? |
||||
|
|
||||
|
} |
||||
@ -0,0 +1,43 @@ |
|||||
|
/******************************************************************************* |
||||
|
* Copyright 2014 See AUTHORS file. |
||||
|
* |
||||
|
* Licensed under the Apache License, Version 2.0 (the "License"); |
||||
|
* you may not use this file except in compliance with the License. |
||||
|
* You may obtain a copy of the License at |
||||
|
* |
||||
|
* http://www.apache.org/licenses/LICENSE-2.0 |
||||
|
* |
||||
|
* Unless required by applicable law or agreed to in writing, software |
||||
|
* distributed under the License is distributed on an "AS IS" BASIS, |
||||
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
|
* See the License for the specific language governing permissions and |
||||
|
* limitations under the License. |
||||
|
******************************************************************************/ |
||||
|
|
||||
|
package wow.doge.mygame.game.subsystems.ai.gdx; |
||||
|
|
||||
|
import com.badlogic.gdx.ai.pfa.Connection; |
||||
|
|
||||
|
import com.badlogic.gdx.utils.Array; |
||||
|
// import java.lang.Iterable; |
||||
|
import java.util.List; |
||||
|
import scala.collection.immutable.IndexedSeq; |
||||
|
|
||||
|
/** |
||||
|
* A graph is a collection of nodes, each one having a collection of outgoing |
||||
|
* {@link Connection connections}. |
||||
|
* |
||||
|
* @param <N> Type of node |
||||
|
* |
||||
|
* @author davebaol |
||||
|
*/ |
||||
|
public interface Graph<N> { |
||||
|
|
||||
|
/** |
||||
|
* Returns the connections outgoing from the given node. |
||||
|
* |
||||
|
* @param fromNode the node whose outgoing connections will be returned |
||||
|
* @return the array of connections outgoing from the given node. |
||||
|
*/ |
||||
|
public IndexedSeq<Connection<N>> getConnections(N fromNode); |
||||
|
} |
||||
@ -0,0 +1,371 @@ |
|||||
|
/******************************************************************************* |
||||
|
* Copyright 2014 See AUTHORS file. |
||||
|
* |
||||
|
* Licensed under the Apache License, Version 2.0 (the "License"); |
||||
|
* you may not use this file except in compliance with the License. |
||||
|
* You may obtain a copy of the License at |
||||
|
* |
||||
|
* http://www.apache.org/licenses/LICENSE-2.0 |
||||
|
* |
||||
|
* Unless required by applicable law or agreed to in writing, software |
||||
|
* distributed under the License is distributed on an "AS IS" BASIS, |
||||
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
|
* See the License for the specific language governing permissions and |
||||
|
* limitations under the License. |
||||
|
******************************************************************************/ |
||||
|
|
||||
|
package wow.doge.mygame.game.subsystems.ai.gdx; |
||||
|
|
||||
|
import com.badlogic.gdx.ai.pfa.Connection; |
||||
|
import com.badlogic.gdx.ai.pfa.GraphPath; |
||||
|
import com.badlogic.gdx.ai.pfa.Heuristic; |
||||
|
import com.badlogic.gdx.ai.pfa.PathFinder; |
||||
|
import com.badlogic.gdx.ai.pfa.PathFinderQueue; |
||||
|
import com.badlogic.gdx.ai.pfa.PathFinderRequest; |
||||
|
import com.badlogic.gdx.utils.Array; |
||||
|
import com.badlogic.gdx.utils.BinaryHeap; |
||||
|
import com.badlogic.gdx.utils.TimeUtils; |
||||
|
import java.util.List; |
||||
|
import wow.doge.mygame.game.subsystems.ai.gdx.Graph; |
||||
|
import wow.doge.mygame.game.subsystems.ai.gdx.MyIndexedGraph; |
||||
|
import scala.collection.immutable.IndexedSeq; |
||||
|
|
||||
|
/** |
||||
|
* A fully implemented {@link PathFinder} that can perform both interruptible |
||||
|
* and non-interruptible pathfinding. |
||||
|
* <p> |
||||
|
* This implementation is a common variation of the A* algorithm that is faster |
||||
|
* than the general A*. |
||||
|
* <p> |
||||
|
* In the general A* implementation, data are held for each node in the open or |
||||
|
* closed lists, and these data are held as a NodeRecord instance. Records are |
||||
|
* created when a node is first considered and then moved between the open and |
||||
|
* closed lists, as required. There is a key step in the algorithm where the |
||||
|
* lists are searched for a node record corresponding to a particular node. This |
||||
|
* operation is something time-consuming. |
||||
|
* <p> |
||||
|
* The indexed A* algorithm improves execution speed by using an array of all |
||||
|
* the node records for every node in the graph. Nodes must be numbered using |
||||
|
* sequential integers (see {@link MyIndexedGraph#getIndex(Object)}), so we |
||||
|
* don't need to search for a node in the two lists at all. We can simply use |
||||
|
* the node index to look up its record in the array (creating it if it is |
||||
|
* missing). This means that the close list is no longer needed. To know whether |
||||
|
* a node is open or closed, we use the {@link NodeRecord#category category} of |
||||
|
* the node record. This makes the search step very fast indeed (in fact, there |
||||
|
* is no search, and we can go straight to the information we need). |
||||
|
* Unfortunately, we can't get rid of the open list because we still need to be |
||||
|
* able to retrieve the element with the lowest cost. However, we use a |
||||
|
* {@link BinaryHeap} for the open list in order to keep performance as high as |
||||
|
* possible. |
||||
|
* |
||||
|
* @param <N> Type of node |
||||
|
* |
||||
|
* @author davebaol |
||||
|
*/ |
||||
|
public class IndexedAStarPathFinder<N> implements PathFinder<N> { |
||||
|
MyIndexedGraph<N> graph; |
||||
|
NodeRecord<N>[] nodeRecords; |
||||
|
BinaryHeap<NodeRecord<N>> openList; |
||||
|
NodeRecord<N> current; |
||||
|
public Metrics metrics; |
||||
|
|
||||
|
/** The unique ID for each search run. Used to mark nodes. */ |
||||
|
private int searchId; |
||||
|
|
||||
|
private static final int UNVISITED = 0; |
||||
|
private static final int OPEN = 1; |
||||
|
private static final int CLOSED = 2; |
||||
|
|
||||
|
public IndexedAStarPathFinder(MyIndexedGraph<N> graph) { |
||||
|
this(graph, false); |
||||
|
} |
||||
|
|
||||
|
@SuppressWarnings("unchecked") |
||||
|
public IndexedAStarPathFinder(MyIndexedGraph<N> graph, boolean calculateMetrics) { |
||||
|
this.graph = graph; |
||||
|
this.nodeRecords = (NodeRecord<N>[]) new NodeRecord[graph.getNodeCount()]; |
||||
|
this.openList = new BinaryHeap<NodeRecord<N>>(); |
||||
|
if (calculateMetrics) |
||||
|
this.metrics = new Metrics(); |
||||
|
} |
||||
|
|
||||
|
@Override |
||||
|
public boolean searchConnectionPath(N startNode, N endNode, Heuristic<N> heuristic, |
||||
|
GraphPath<Connection<N>> outPath) { |
||||
|
|
||||
|
// Perform AStar |
||||
|
boolean found = search(startNode, endNode, heuristic); |
||||
|
|
||||
|
if (found) { |
||||
|
// Create a path made of connections |
||||
|
generateConnectionPath(startNode, outPath); |
||||
|
} |
||||
|
|
||||
|
return found; |
||||
|
} |
||||
|
|
||||
|
@Override |
||||
|
public boolean searchNodePath(N startNode, N endNode, Heuristic<N> heuristic, GraphPath<N> outPath) { |
||||
|
|
||||
|
// Perform AStar |
||||
|
boolean found = search(startNode, endNode, heuristic); |
||||
|
|
||||
|
if (found) { |
||||
|
// Create a path made of nodes |
||||
|
generateNodePath(startNode, outPath); |
||||
|
} |
||||
|
|
||||
|
return found; |
||||
|
} |
||||
|
|
||||
|
protected boolean search(N startNode, N endNode, Heuristic<N> heuristic) { |
||||
|
|
||||
|
initSearch(startNode, endNode, heuristic); |
||||
|
|
||||
|
// Iterate through processing each node |
||||
|
do { |
||||
|
// Retrieve the node with smallest estimated total cost from the open list |
||||
|
current = openList.pop(); |
||||
|
current.category = CLOSED; |
||||
|
|
||||
|
// Terminate if we reached the goal node |
||||
|
if (current.node == endNode) |
||||
|
return true; |
||||
|
|
||||
|
visitChildren(endNode, heuristic); |
||||
|
|
||||
|
} while (openList.size > 0); |
||||
|
|
||||
|
// We've run out of nodes without finding the goal, so there's no solution |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
@Override |
||||
|
public boolean search(PathFinderRequest<N> request, long timeToRun) { |
||||
|
|
||||
|
long lastTime = TimeUtils.nanoTime(); |
||||
|
|
||||
|
// We have to initialize the search if the status has just changed |
||||
|
if (request.statusChanged) { |
||||
|
initSearch(request.startNode, request.endNode, request.heuristic); |
||||
|
request.statusChanged = false; |
||||
|
} |
||||
|
|
||||
|
// Iterate through processing each node |
||||
|
do { |
||||
|
|
||||
|
// Check the available time |
||||
|
long currentTime = TimeUtils.nanoTime(); |
||||
|
timeToRun -= currentTime - lastTime; |
||||
|
if (timeToRun <= PathFinderQueue.TIME_TOLERANCE) |
||||
|
return false; |
||||
|
|
||||
|
// Retrieve the node with smallest estimated total cost from the open list |
||||
|
current = openList.pop(); |
||||
|
current.category = CLOSED; |
||||
|
|
||||
|
// Terminate if we reached the goal node; we've found a path. |
||||
|
if (current.node == request.endNode) { |
||||
|
request.pathFound = true; |
||||
|
|
||||
|
generateNodePath(request.startNode, request.resultPath); |
||||
|
|
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
// Visit current node's children |
||||
|
visitChildren(request.endNode, request.heuristic); |
||||
|
|
||||
|
// Store the current time |
||||
|
lastTime = currentTime; |
||||
|
|
||||
|
} while (openList.size > 0); |
||||
|
|
||||
|
// The open list is empty and we've not found a path. |
||||
|
request.pathFound = false; |
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
protected void initSearch(N startNode, N endNode, Heuristic<N> heuristic) { |
||||
|
if (metrics != null) |
||||
|
metrics.reset(); |
||||
|
|
||||
|
// Increment the search id |
||||
|
if (++searchId < 0) |
||||
|
searchId = 1; |
||||
|
|
||||
|
// Initialize the open list |
||||
|
openList.clear(); |
||||
|
|
||||
|
// Initialize the record for the start node and add it to the open list |
||||
|
NodeRecord<N> startRecord = getNodeRecord(startNode); |
||||
|
startRecord.node = startNode; |
||||
|
startRecord.connection = null; |
||||
|
startRecord.costSoFar = 0; |
||||
|
addToOpenList(startRecord, heuristic.estimate(startNode, endNode)); |
||||
|
|
||||
|
current = null; |
||||
|
} |
||||
|
|
||||
|
protected void visitChildren(N endNode, Heuristic<N> heuristic) { |
||||
|
// Get current node's outgoing connections |
||||
|
IndexedSeq<Connection<N>> connections = graph.getConnections(current.node); |
||||
|
|
||||
|
// Loop through each connection in turn |
||||
|
for (int i = 0; i < connections.size(); i++) { |
||||
|
if (metrics != null) |
||||
|
metrics.visitedNodes++; |
||||
|
|
||||
|
Connection<N> connection = connections.apply(i); |
||||
|
|
||||
|
// Get the cost estimate for the node |
||||
|
N node = connection.getToNode(); |
||||
|
float nodeCost = current.costSoFar + connection.getCost(); |
||||
|
|
||||
|
float nodeHeuristic; |
||||
|
NodeRecord<N> nodeRecord = getNodeRecord(node); |
||||
|
if (nodeRecord.category == CLOSED) { // The node is closed |
||||
|
|
||||
|
// If we didn't find a shorter route, skip |
||||
|
if (nodeRecord.costSoFar <= nodeCost) |
||||
|
continue; |
||||
|
|
||||
|
// We can use the node's old cost values to calculate its heuristic |
||||
|
// without calling the possibly expensive heuristic function |
||||
|
nodeHeuristic = nodeRecord.getEstimatedTotalCost() - nodeRecord.costSoFar; |
||||
|
} else if (nodeRecord.category == OPEN) { // The node is open |
||||
|
|
||||
|
// If our route is no better, then skip |
||||
|
if (nodeRecord.costSoFar <= nodeCost) |
||||
|
continue; |
||||
|
|
||||
|
// Remove it from the open list (it will be re-added with the new cost) |
||||
|
openList.remove(nodeRecord); |
||||
|
|
||||
|
// We can use the node's old cost values to calculate its heuristic |
||||
|
// without calling the possibly expensive heuristic function |
||||
|
nodeHeuristic = nodeRecord.getEstimatedTotalCost() - nodeRecord.costSoFar; |
||||
|
} else { // the node is unvisited |
||||
|
|
||||
|
// We'll need to calculate the heuristic value using the function, |
||||
|
// since we don't have a node record with a previously calculated value |
||||
|
nodeHeuristic = heuristic.estimate(node, endNode); |
||||
|
} |
||||
|
|
||||
|
// Update node record's cost and connection |
||||
|
nodeRecord.costSoFar = nodeCost; |
||||
|
nodeRecord.connection = connection; |
||||
|
|
||||
|
// Add it to the open list with the estimated total cost |
||||
|
addToOpenList(nodeRecord, nodeCost + nodeHeuristic); |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
|
||||
|
protected void generateConnectionPath(N startNode, GraphPath<Connection<N>> outPath) { |
||||
|
|
||||
|
// Work back along the path, accumulating connections |
||||
|
// outPath.clear(); |
||||
|
while (current.node != startNode) { |
||||
|
outPath.add(current.connection); |
||||
|
current = nodeRecords[graph.getIndex(current.connection.getFromNode())]; |
||||
|
} |
||||
|
|
||||
|
// Reverse the path |
||||
|
outPath.reverse(); |
||||
|
} |
||||
|
|
||||
|
protected void generateNodePath(N startNode, GraphPath<N> outPath) { |
||||
|
|
||||
|
// Work back along the path, accumulating nodes |
||||
|
// outPath.clear(); |
||||
|
while (current.connection != null) { |
||||
|
outPath.add(current.node); |
||||
|
current = nodeRecords[graph.getIndex(current.connection.getFromNode())]; |
||||
|
} |
||||
|
outPath.add(startNode); |
||||
|
|
||||
|
// Reverse the path |
||||
|
outPath.reverse(); |
||||
|
} |
||||
|
|
||||
|
protected void addToOpenList(NodeRecord<N> nodeRecord, float estimatedTotalCost) { |
||||
|
openList.add(nodeRecord, estimatedTotalCost); |
||||
|
nodeRecord.category = OPEN; |
||||
|
if (metrics != null) { |
||||
|
metrics.openListAdditions++; |
||||
|
metrics.openListPeak = Math.max(metrics.openListPeak, openList.size); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
protected NodeRecord<N> getNodeRecord(N node) { |
||||
|
int index = graph.getIndex(node); |
||||
|
NodeRecord<N> nr = nodeRecords[index]; |
||||
|
if (nr != null) { |
||||
|
if (nr.searchId != searchId) { |
||||
|
nr.category = UNVISITED; |
||||
|
nr.searchId = searchId; |
||||
|
} |
||||
|
return nr; |
||||
|
} |
||||
|
nr = nodeRecords[index] = new NodeRecord<N>(); |
||||
|
nr.node = node; |
||||
|
nr.searchId = searchId; |
||||
|
return nr; |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* This nested class is used to keep track of the information we need for each |
||||
|
* node during the search. |
||||
|
* |
||||
|
* @param <N> Type of node |
||||
|
* |
||||
|
* @author davebaol |
||||
|
*/ |
||||
|
static class NodeRecord<N> extends BinaryHeap.Node { |
||||
|
/** The reference to the node. */ |
||||
|
N node; |
||||
|
|
||||
|
/** The incoming connection to the node */ |
||||
|
Connection<N> connection; |
||||
|
|
||||
|
/** The actual cost from the start node. */ |
||||
|
float costSoFar; |
||||
|
|
||||
|
/** The node category: {@link #UNVISITED}, {@link #OPEN} or {@link #CLOSED}. */ |
||||
|
int category; |
||||
|
|
||||
|
/** ID of the current search. */ |
||||
|
int searchId; |
||||
|
|
||||
|
/** Creates a {@code NodeRecord}. */ |
||||
|
public NodeRecord() { |
||||
|
super(0); |
||||
|
} |
||||
|
|
||||
|
/** Returns the estimated total cost. */ |
||||
|
public float getEstimatedTotalCost() { |
||||
|
return getValue(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* A class used by {@link IndexedAStarPathFinder} to collect search metrics. |
||||
|
* |
||||
|
* @author davebaol |
||||
|
*/ |
||||
|
public static class Metrics { |
||||
|
public int visitedNodes; |
||||
|
public int openListAdditions; |
||||
|
public int openListPeak; |
||||
|
|
||||
|
public Metrics() { |
||||
|
} |
||||
|
|
||||
|
public void reset() { |
||||
|
visitedNodes = 0; |
||||
|
openListAdditions = 0; |
||||
|
openListPeak = 0; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,41 @@ |
|||||
|
/******************************************************************************* |
||||
|
* Copyright 2014 See AUTHORS file. |
||||
|
* |
||||
|
* Licensed under the Apache License, Version 2.0 (the "License"); |
||||
|
* you may not use this file except in compliance with the License. |
||||
|
* You may obtain a copy of the License at |
||||
|
* |
||||
|
* http://www.apache.org/licenses/LICENSE-2.0 |
||||
|
* |
||||
|
* Unless required by applicable law or agreed to in writing, software |
||||
|
* distributed under the License is distributed on an "AS IS" BASIS, |
||||
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
|
* See the License for the specific language governing permissions and |
||||
|
* limitations under the License. |
||||
|
******************************************************************************/ |
||||
|
|
||||
|
package wow.doge.mygame.game.subsystems.ai.gdx; |
||||
|
|
||||
|
import wow.doge.mygame.game.subsystems.ai.gdx.Graph; |
||||
|
|
||||
|
/** |
||||
|
* A graph for the {@link IndexedAStarPathFinder}. |
||||
|
* |
||||
|
* @param <N> Type of node |
||||
|
* |
||||
|
* @author davebaol |
||||
|
*/ |
||||
|
public interface MyIndexedGraph<N> extends Graph<N> { |
||||
|
|
||||
|
/** |
||||
|
* Returns the unique index of the given node. |
||||
|
* |
||||
|
* @param node the node whose index will be returned |
||||
|
* @return the unique index of the given node. |
||||
|
*/ |
||||
|
public int getIndex(N node); |
||||
|
|
||||
|
/** Returns the number of nodes in this graph. */ |
||||
|
public int getNodeCount(); |
||||
|
|
||||
|
} |
||||
@ -0,0 +1,43 @@ |
|||||
|
package wow.doge.mygame.game.subsystems.ui |
||||
|
|
||||
|
import com.jme3.app.Application |
||||
|
import com.jayfella.jme.jfx.JavaFxUI |
||||
|
import scalafx.application.Platform |
||||
|
import monix.execution.CancelablePromise |
||||
|
import monix.bio.Task |
||||
|
import cats.effect.concurrent.Deferred |
||||
|
import scala.concurrent.duration._ |
||||
|
import wow.doge.mygame.game.GameApp |
||||
|
|
||||
|
object JFxUI { |
||||
|
def apply(app: GameApp) = |
||||
|
Task(JavaFxUI.initialize(app)) |
||||
|
.executeOn(app.scheduler) >> Task.sleep(500.millis) >> Task( |
||||
|
JavaFxUI.getInstance() |
||||
|
) |
||||
|
// Task { |
||||
|
// Platform.runLater(() => { |
||||
|
// println("here jfx") |
||||
|
// JavaFxUI.initialize(app) |
||||
|
// println("here2 jfx2") |
||||
|
// val inst = JavaFxUI.getInstance() |
||||
|
// println(inst) |
||||
|
// }) |
||||
|
// } |
||||
|
// Task.fromFuture { |
||||
|
// val p = CancelablePromise[JavaFxUI]() |
||||
|
// Platform.runLater(() => { |
||||
|
// println("here") |
||||
|
// JavaFxUI.initialize(app) |
||||
|
// println("here2") |
||||
|
// val inst = JavaFxUI.getInstance() |
||||
|
// println(inst) |
||||
|
// p.success(inst) |
||||
|
// }) |
||||
|
// p.future |
||||
|
// } |
||||
|
// for { |
||||
|
// d <- Deferred[Task, JavaFxUI] |
||||
|
// _ <- Task(JavaFxUI.initialize(app)) |
||||
|
// } yield () |
||||
|
} |
||||
@ -0,0 +1,88 @@ |
|||||
|
package wow.doge.mygame.implicits |
||||
|
|
||||
|
import javafx.{ |
||||
|
collections => jfxc, |
||||
|
event => jfxe, |
||||
|
geometry => jfxg, |
||||
|
scene => jfxs, |
||||
|
util => jfxu |
||||
|
} |
||||
|
import javafx.scene.{input => jfxsi, layout => jfxsl, paint => jfxsp} |
||||
|
import scalafx.scene.Scene |
||||
|
import monix.execution.Cancelable |
||||
|
import monix.reactive.OverflowStrategy |
||||
|
import monix.reactive.Observable |
||||
|
import monix.execution.Ack |
||||
|
import scalafx.scene.control.ButtonBase |
||||
|
|
||||
|
object JavaFXMonixObservables { |
||||
|
|
||||
|
implicit final class SceneObservables(private val scene: Scene) |
||||
|
extends AnyVal { |
||||
|
def observableMousePressed(): Observable[jfxsi.MouseEvent] = { |
||||
|
import monix.execution.cancelables.SingleAssignCancelable |
||||
|
Observable.create(OverflowStrategy.Unbounded) { sub => |
||||
|
val c = SingleAssignCancelable() |
||||
|
val l = new jfxe.EventHandler[jfxsi.MouseEvent] { |
||||
|
override def handle(event: jfxsi.MouseEvent): Unit = { |
||||
|
if (sub.onNext(event) == Ack.Stop) c.cancel() |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
scene.onMousePressed = l |
||||
|
c := Cancelable(() => |
||||
|
scene.removeEventHandler( |
||||
|
jfxsi.MouseEvent.MOUSE_PRESSED, |
||||
|
l |
||||
|
) |
||||
|
) |
||||
|
c |
||||
|
} |
||||
|
} |
||||
|
def observableMouseDragged(): Observable[jfxsi.MouseEvent] = { |
||||
|
import monix.execution.cancelables.SingleAssignCancelable |
||||
|
Observable.create(OverflowStrategy.Unbounded) { sub => |
||||
|
val c = SingleAssignCancelable() |
||||
|
val l = new jfxe.EventHandler[jfxsi.MouseEvent] { |
||||
|
override def handle(event: jfxsi.MouseEvent): Unit = { |
||||
|
if (sub.onNext(event) == Ack.Stop) c.cancel() |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
scene.onMouseDragged = l |
||||
|
c := Cancelable(() => |
||||
|
scene.removeEventHandler( |
||||
|
jfxsi.MouseEvent.MOUSE_DRAGGED, |
||||
|
l |
||||
|
) |
||||
|
) |
||||
|
c |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
implicit final class OnActionObservable( |
||||
|
private val button: ButtonBase |
||||
|
) extends AnyVal { |
||||
|
def observableAction(): Observable[jfxe.ActionEvent] = { |
||||
|
import monix.execution.cancelables.SingleAssignCancelable |
||||
|
Observable.create(OverflowStrategy.Unbounded) { sub => |
||||
|
val c = SingleAssignCancelable() |
||||
|
val l = new jfxe.EventHandler[jfxe.ActionEvent] { |
||||
|
override def handle(event: jfxe.ActionEvent): Unit = { |
||||
|
if (sub.onNext(event) == Ack.Stop) c.cancel() |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
button.onAction = l |
||||
|
c := Cancelable(() => |
||||
|
button.removeEventHandler( |
||||
|
jfxe.ActionEvent.ACTION, |
||||
|
l |
||||
|
) |
||||
|
) |
||||
|
c |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -1,43 +0,0 @@ |
|||||
package wow.doge.mygame.implicits |
|
||||
|
|
||||
import enumeratum._ |
|
||||
|
|
||||
sealed trait TestEnum extends EnumEntry |
|
||||
|
|
||||
object TestEnum extends Enum[TestEnum] { |
|
||||
val values = findValues |
|
||||
case object Test2 extends TestEnum |
|
||||
} |
|
||||
|
|
||||
sealed trait Greeting extends EnumEntry |
|
||||
|
|
||||
object Greeting extends Enum[Greeting] { |
|
||||
|
|
||||
/* |
|
||||
`findValues` is a protected method that invokes a macro to find all `Greeting` object declarations inside an `Enum` |
|
||||
|
|
||||
You use it to implement the `val values` member |
|
||||
*/ |
|
||||
val values = findValues |
|
||||
|
|
||||
case object Hello extends Greeting |
|
||||
case object GoodBye extends Greeting |
|
||||
case object Hi extends Greeting |
|
||||
case object Bye extends Greeting |
|
||||
|
|
||||
} |
|
||||
object ObsTest {} |
|
||||
|
|
||||
sealed trait PlayerMovementEnum extends EnumEntry { |
|
||||
def test: String |
|
||||
} |
|
||||
|
|
||||
object PlayerMovementEnum extends Enum[PlayerMovementEnum] { |
|
||||
val values = findValues |
|
||||
case object MOVE_RIGHT extends PlayerMovementEnum { |
|
||||
val test = "hmm" |
|
||||
} |
|
||||
case object MOVE_LEFT extends PlayerMovementEnum { |
|
||||
val test = "mmh" |
|
||||
} |
|
||||
} |
|
||||
@ -0,0 +1,18 @@ |
|||||
|
package wow.doge.mygame.implicits |
||||
|
|
||||
|
import javafx.{ |
||||
|
collections => jfxc, |
||||
|
event => jfxe, |
||||
|
geometry => jfxg, |
||||
|
scene => jfxs, |
||||
|
util => jfxu |
||||
|
} |
||||
|
import javafx.scene.{input => jfxsi, layout => jfxsl, paint => jfxsp} |
||||
|
import scalafx.scene.Scene |
||||
|
import monix.execution.Cancelable |
||||
|
import monix.reactive.OverflowStrategy |
||||
|
import monix.reactive.Observable |
||||
|
import monix.execution.Ack |
||||
|
import scalafx.scene.control.Button |
||||
|
|
||||
|
package object observables {} |
||||
@ -0,0 +1,102 @@ |
|||||
|
package wow.doge.mygame.launcher |
||||
|
|
||||
|
import scalafx.geometry.Insets |
||||
|
import scalafx.scene.Scene |
||||
|
import scalafx.scene.effect.DropShadow |
||||
|
import scalafx.scene.layout.HBox |
||||
|
import scalafx.scene.paint.Color._ |
||||
|
import scalafx.scene.paint._ |
||||
|
import scalafx.scene.text.Text |
||||
|
import scalafx.scene.control.Button |
||||
|
import scalafx.scene.layout.VBox |
||||
|
import scalafx.scene.layout.FlowPane |
||||
|
import scalafx.geometry.Orientation |
||||
|
import scalafx.geometry.Pos |
||||
|
import scalafx.stage.Stage |
||||
|
|
||||
|
object DefaultUI { |
||||
|
def scene( |
||||
|
// stage: Stage, |
||||
|
launchButton: Button, |
||||
|
exitButton: Button |
||||
|
) = |
||||
|
new Scene { |
||||
|
fill = Color.rgb(38, 38, 38) |
||||
|
content = new VBox { |
||||
|
children = Seq( |
||||
|
new HBox { |
||||
|
padding = Insets(50, 80, 50, 80) |
||||
|
children = Seq( |
||||
|
new Text { |
||||
|
text = "JMonkeyEngine" |
||||
|
style = "-fx-font: normal bold 50pt sans-serif" |
||||
|
fill = new LinearGradient(endX = 0, stops = Stops(Red, DarkRed)) |
||||
|
}, |
||||
|
new Text { |
||||
|
text = " Game" |
||||
|
style = "-fx-font: italic bold 50pt sans-serif" |
||||
|
fill = new LinearGradient( |
||||
|
endX = 0, |
||||
|
stops = Stops(White, DarkGray) |
||||
|
) |
||||
|
effect = new DropShadow { |
||||
|
color = DarkGray |
||||
|
radius = 15 |
||||
|
spread = 0.25 |
||||
|
} |
||||
|
} |
||||
|
) |
||||
|
}, |
||||
|
new FlowPane { |
||||
|
hgap = 10 |
||||
|
padding = Insets(50, 80, 50, 80) |
||||
|
orientation = Orientation.Horizontal |
||||
|
alignment = Pos.Center |
||||
|
children = Seq(launchButton, exitButton) |
||||
|
} |
||||
|
) |
||||
|
} |
||||
|
// onMousePressed = (pressEvent) => { |
||||
|
// onMouseDragged = (dragEvent) => { |
||||
|
// stage.setX(dragEvent.getScreenX() - pressEvent.getSceneX()) |
||||
|
// stage.setY(dragEvent.getScreenY() - pressEvent.getSceneY()) |
||||
|
// } |
||||
|
// } |
||||
|
} |
||||
|
|
||||
|
def box(launchButton: Button, exitButton: Button) = |
||||
|
new VBox { |
||||
|
children = Seq( |
||||
|
new HBox { |
||||
|
padding = Insets(50, 80, 50, 80) |
||||
|
children = Seq( |
||||
|
new Text { |
||||
|
text = "JMonkeyEngine" |
||||
|
style = "-fx-font: normal bold 50pt sans-serif" |
||||
|
fill = new LinearGradient(endX = 0, stops = Stops(Red, DarkRed)) |
||||
|
}, |
||||
|
new Text { |
||||
|
text = " Game" |
||||
|
style = "-fx-font: italic bold 50pt sans-serif" |
||||
|
fill = new LinearGradient( |
||||
|
endX = 0, |
||||
|
stops = Stops(White, DarkGray) |
||||
|
) |
||||
|
effect = new DropShadow { |
||||
|
color = DarkGray |
||||
|
radius = 15 |
||||
|
spread = 0.25 |
||||
|
} |
||||
|
} |
||||
|
) |
||||
|
}, |
||||
|
new FlowPane { |
||||
|
hgap = 10 |
||||
|
padding = Insets(50, 80, 50, 80) |
||||
|
orientation = Orientation.Horizontal |
||||
|
alignment = Pos.Center |
||||
|
children = Seq(launchButton, exitButton) |
||||
|
} |
||||
|
) |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,153 @@ |
|||||
|
package wow.doge.mygame.launcher |
||||
|
|
||||
|
import scala.concurrent.duration.FiniteDuration |
||||
|
import scalafx.application.JFXApp |
||||
|
import scalafx.application.JFXApp.PrimaryStage |
||||
|
import wow.doge.mygame.executors.Schedulers |
||||
|
import cats.effect.Resource |
||||
|
import monix.bio.Task |
||||
|
import scala.concurrent.duration._ |
||||
|
import javafx.application.Platform |
||||
|
import scalafx.scene.control.Button |
||||
|
import cats.effect.concurrent.Deferred |
||||
|
import wow.doge.mygame.utils.IOUtils._ |
||||
|
import monix.eval.{Task => ETask} |
||||
|
import monix.reactive.Observable |
||||
|
import monix.bio.Fiber |
||||
|
import scalafx.stage.StageStyle |
||||
|
import scalafx.Includes._ |
||||
|
import wow.doge.mygame.utils.ResizeHelper |
||||
|
import scalafx.scene.Scene |
||||
|
import scalafx.scene.layout.VBox |
||||
|
import wow.doge.mygame.implicits.JavaFXMonixObservables._ |
||||
|
import monix.catnap.cancelables.SingleAssignCancelableF |
||||
|
import monix.catnap.CancelableF |
||||
|
// import wow.doge.mygame.implicits.JavaFXMonixObservables._ |
||||
|
|
||||
|
// import scala.language.implicitConversions |
||||
|
|
||||
|
// object Stage { |
||||
|
// implicit def sfxStage2jfx(v: Stage): jfxs.Stage = if (v != null) v.delegate else null |
||||
|
// } |
||||
|
|
||||
|
object Launcher { |
||||
|
sealed trait LauncherResult |
||||
|
object LauncherResult { |
||||
|
case object LaunchGame extends LauncherResult |
||||
|
case object Exit extends LauncherResult |
||||
|
} |
||||
|
|
||||
|
class Props( |
||||
|
val schedulers: Schedulers, |
||||
|
val signal: Deferred[Task, LauncherResult] |
||||
|
) { |
||||
|
// val resource2 |
||||
|
// : Resource[Task, (LauncherApp, Task[Ref[Task, Stage]], Fiber[Unit])] = |
||||
|
// Resource.make(for { |
||||
|
// app <- Task(new LauncherApp(this)) |
||||
|
// fib <- app.init.start |
||||
|
// } yield ((app, app.stageRef, fib)))(_._3.cancel) |
||||
|
val create = Task(new Launcher(this)) |
||||
|
|
||||
|
val resource: Resource[Task, Launcher] = |
||||
|
Resource.make(for { |
||||
|
app <- Task(new Launcher(this)) |
||||
|
// fib <- app.init.start |
||||
|
} yield (app))(_ => Task.unit) |
||||
|
} |
||||
|
} |
||||
|
class Launcher private (props: Launcher.Props) { |
||||
|
import Launcher._ |
||||
|
|
||||
|
private lazy val launchButton = new Button { |
||||
|
text = "Launch" |
||||
|
} |
||||
|
// private lazy val launchButtonObs = |
||||
|
|
||||
|
private lazy val launchAction = |
||||
|
launchButton |
||||
|
.observableAction() |
||||
|
.doOnNext(_ => toTask(props.signal.complete(LauncherResult.LaunchGame))) |
||||
|
|
||||
|
private lazy val exitButton = new Button { |
||||
|
text = "Exit" |
||||
|
} |
||||
|
// private lazy val exitButtonObs = |
||||
|
|
||||
|
private lazy val exitAction = |
||||
|
exitButton |
||||
|
.observableAction() |
||||
|
.doOnNext(_ => toTask(props.signal.complete(LauncherResult.Exit))) |
||||
|
|
||||
|
private lazy val _scene = |
||||
|
// new Scene { |
||||
|
// content = new VBox |
||||
|
// } |
||||
|
DefaultUI.scene(launchButton, exitButton) |
||||
|
|
||||
|
private lazy val _stage = new PrimaryStage { |
||||
|
scene = _scene |
||||
|
} |
||||
|
|
||||
|
private lazy val internal = new JFXApp { |
||||
|
stage = _stage |
||||
|
stage.initStyle(StageStyle.Undecorated) |
||||
|
// ResizeHelper.addResizeListener(stage) |
||||
|
} |
||||
|
|
||||
|
private lazy val sceneDragObservable = { |
||||
|
lazy val mpo = _scene.observableMousePressed() |
||||
|
lazy val mdo = _scene.observableMouseDragged() |
||||
|
|
||||
|
mpo.mergeMap(pressEvent => |
||||
|
mdo.doOnNext(dragEvent => |
||||
|
ETask( |
||||
|
_stage.setX(dragEvent.screenX - pressEvent.sceneX) |
||||
|
) >> |
||||
|
ETask( |
||||
|
_stage.setY( |
||||
|
dragEvent.screenY - pressEvent.sceneY |
||||
|
) |
||||
|
) |
||||
|
) |
||||
|
) |
||||
|
} |
||||
|
|
||||
|
// var stage = internal.stage |
||||
|
|
||||
|
// lazy val stageRef = Ref.of[Task, Stage](internal.stage) |
||||
|
// stage: => PrimaryStage |
||||
|
def init(delay: FiniteDuration = 2000.millis) = |
||||
|
for { |
||||
|
_ <- Task(Platform.setImplicitExit(false)) |
||||
|
|
||||
|
fib <- Task(internal.main(Array.empty)).start |
||||
|
_ <- Task.sleep(500.millis) |
||||
|
// _ <- Task { |
||||
|
// // lazy val _stage = new CustomStageBuilder() |
||||
|
// // .setWindowTitle("CustomStage example") |
||||
|
// // .setWindowColor("rgb(34,54,122)") |
||||
|
// // .build() |
||||
|
// internal.stage.scene = |
||||
|
// DefaultUI.scene(internal.stage, launchButton, exitButton) |
||||
|
// // _stage.setScene(DefaultUI.scene(launchButton, exitButton)) |
||||
|
// // JFXApp.Stage = _stage |
||||
|
// }.executeOn(props.schedulers.fx) |
||||
|
// c <- SingleAssignCancelableF[Task] |
||||
|
sceneDragFib <- toIO(sceneDragObservable.completedL).start |
||||
|
fib2 <- toIO( |
||||
|
Observable(launchAction, exitAction).merge |
||||
|
.doOnNext(_ => |
||||
|
ETask(internal.stage.close()).executeOn(props.schedulers.fx) |
||||
|
) |
||||
|
// .doOnNext(_ => toTask(fib.cancel)) |
||||
|
.completedL |
||||
|
).start |
||||
|
c <- CancelableF[Task](fib.cancel >> fib2.cancel >> sceneDragFib.cancel) |
||||
|
// _ <- Task { |
||||
|
// internal.stage = stage |
||||
|
// }.executeOn(props.schedulers.fx) |
||||
|
// .delayExecution(delay) |
||||
|
} yield (c) |
||||
|
|
||||
|
} |
||||
@ -0,0 +1,750 @@ |
|||||
|
package wow.doge.mygame.utils |
||||
|
|
||||
|
/* |
||||
|
* Copyright (c) 2011-2019, ScalaFX Project |
||||
|
* All rights reserved. |
||||
|
* |
||||
|
* Redistribution and use in source and binary forms, with or without |
||||
|
* modification, are permitted provided that the following conditions are met: |
||||
|
* * Redistributions of source code must retain the above copyright |
||||
|
* notice, this list of conditions and the following disclaimer. |
||||
|
* * Redistributions in binary form must reproduce the above copyright |
||||
|
* notice, this list of conditions and the following disclaimer in the |
||||
|
* documentation and/or other materials provided with the distribution. |
||||
|
* * Neither the name of the ScalaFX Project nor the |
||||
|
* names of its contributors may be used to endorse or promote products |
||||
|
* derived from this software without specific prior written permission. |
||||
|
* |
||||
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND |
||||
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
||||
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
||||
|
* DISCLAIMED. IN NO EVENT SHALL THE SCALAFX PROJECT OR ITS CONTRIBUTORS BE LIABLE |
||||
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
||||
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR |
||||
|
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED |
||||
|
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
||||
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
|
*/ |
||||
|
|
||||
|
import javafx.scene.{input => jfxsi, layout => jfxsl, paint => jfxsp} |
||||
|
import javafx.{ |
||||
|
collections => jfxc, |
||||
|
event => jfxe, |
||||
|
geometry => jfxg, |
||||
|
scene => jfxs, |
||||
|
util => jfxu |
||||
|
} |
||||
|
import scalafx.Includes._ |
||||
|
import scalafx.beans.property.{ |
||||
|
ObjectProperty, |
||||
|
ReadOnlyDoubleProperty, |
||||
|
ReadOnlyObjectProperty |
||||
|
} |
||||
|
import scalafx.collections._ |
||||
|
import scalafx.delegate.SFXDelegate |
||||
|
import scalafx.geometry.NodeOrientation |
||||
|
import scalafx.scene.image.WritableImage |
||||
|
import scalafx.scene.input.{Dragboard, Mnemonic, TransferMode} |
||||
|
import scalafx.scene.paint.Paint |
||||
|
import com.goxr3plus.fxborderlessscene.borderless.{BorderlessScene => BScene} |
||||
|
|
||||
|
import scala.language.implicitConversions |
||||
|
import scalafx.scene.Cursor |
||||
|
import scalafx.scene._ |
||||
|
import scalafx.stage.Stage |
||||
|
import scalafx.stage.StageStyle |
||||
|
|
||||
|
object BorderlessScene { |
||||
|
implicit def sfxScene2jfx(v: BorderlessScene): Scene = |
||||
|
if (v != null) v.delegate else null |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Wraps [[http://docs.oracle.com/javase/8/javafx/api/javafx/scene/Scene.html]]. |
||||
|
* |
||||
|
* @constructor Create a new ScalaFX Scene with JavaFX Scene as delegate. |
||||
|
* @param delegate JavaFX Scene delegated. Its default value is a JavaFX Scene with a |
||||
|
* [[http://docs.oracle.com/javase/8/javafx/api/javafx/scene/Group.html Group]] as root Node. |
||||
|
*/ |
||||
|
class BorderlessScene( |
||||
|
override val delegate: BScene |
||||
|
) extends SFXDelegate[BScene] { |
||||
|
|
||||
|
def this(stage: Stage, stageStyle: StageStyle, parent: Parent) = |
||||
|
this(new BScene(stage, stageStyle, parent)) |
||||
|
|
||||
|
/** |
||||
|
* Returns the root Node of the scene graph |
||||
|
*/ |
||||
|
def root: ObjectProperty[jfxs.Parent] = delegate.rootProperty |
||||
|
|
||||
|
/** |
||||
|
* Sets the root Node of the scene graph |
||||
|
*/ |
||||
|
def root_=(v: Parent): Unit = { |
||||
|
root() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Returns Nodes children from this Scene's `root`. |
||||
|
*/ |
||||
|
def getChildren = |
||||
|
root.value match { |
||||
|
case group: jfxs.Group => group.getChildren |
||||
|
case pane: jfxsl.Pane => pane.getChildren |
||||
|
case _ => |
||||
|
throw new IllegalStateException( |
||||
|
"Cannot access children of root: " + root + "\n" + |
||||
|
"Use a class that extends Group or Pane, or override the getChildren method." |
||||
|
) |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Returns scene's antialiasing setting. |
||||
|
*/ |
||||
|
def antialiasing: SceneAntialiasing = delegate.getAntiAliasing |
||||
|
|
||||
|
/** |
||||
|
* Returns Content's Node children from this Scene's `root`. |
||||
|
*/ |
||||
|
def content: jfxc.ObservableList[jfxs.Node] = getChildren |
||||
|
|
||||
|
/** |
||||
|
* Sets the list of Nodes children from this Scene's `root`, replacing the prior content. If you want append to |
||||
|
* current content, use `add` or similar. |
||||
|
* |
||||
|
* @param c list of Nodes children from this Scene's `root` to replace prior content. |
||||
|
*/ |
||||
|
def content_=(c: Iterable[Node]): Unit = { |
||||
|
fillSFXCollection(this.content, c) |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Sets a Node child, replacing the prior content. If you want append to current content, use `add` or similar. |
||||
|
* |
||||
|
* @param n Node child to replace prior content. |
||||
|
*/ |
||||
|
def content_=(n: Node): Unit = { |
||||
|
fillSFXCollectionWithOne(this.content, n) |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Specifies the type of camera use for rendering this `Scene`. |
||||
|
*/ |
||||
|
def camera: ObjectProperty[jfxs.Camera] = delegate.cameraProperty |
||||
|
|
||||
|
def camera_=(v: Camera): Unit = { |
||||
|
camera() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines the mouse cursor for this `Scene`. |
||||
|
*/ |
||||
|
def cursor: ObjectProperty[jfxs.Cursor] = delegate.cursorProperty |
||||
|
|
||||
|
def cursor_=(v: Cursor): Unit = { |
||||
|
cursor() = v |
||||
|
} |
||||
|
|
||||
|
/** The effective node orientation of a scene resolves the inheritance of node orientation, returning either left-to-right or right-to-left. */ |
||||
|
def effectiveNodeOrientation: ReadOnlyObjectProperty[jfxg.NodeOrientation] = |
||||
|
delegate.effectiveNodeOrientationProperty |
||||
|
|
||||
|
/** |
||||
|
* Specifies the event dispatcher for this scene. |
||||
|
*/ |
||||
|
def eventDispatcher: ObjectProperty[jfxe.EventDispatcher] = |
||||
|
delegate.eventDispatcherProperty |
||||
|
|
||||
|
def eventDispatcher_=(v: jfxe.EventDispatcher): Unit = { |
||||
|
eventDispatcher() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines the background fill of this Scene. |
||||
|
*/ |
||||
|
def fill: ObjectProperty[jfxsp.Paint] = delegate.fillProperty |
||||
|
|
||||
|
def fill_=(v: Paint): Unit = { |
||||
|
fill() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* The height of this Scene |
||||
|
*/ |
||||
|
def height: ReadOnlyDoubleProperty = delegate.heightProperty |
||||
|
|
||||
|
/** |
||||
|
* The width of this Scene |
||||
|
*/ |
||||
|
def width: ReadOnlyDoubleProperty = delegate.widthProperty |
||||
|
|
||||
|
def nodeOrientation: ObjectProperty[jfxg.NodeOrientation] = |
||||
|
delegate.nodeOrientationProperty |
||||
|
|
||||
|
def nodeOrientation_=(v: NodeOrientation): Unit = { |
||||
|
ObjectProperty.fillProperty[jfxg.NodeOrientation](this.nodeOrientation, v) |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when a mouse button has been clicked (pressed and released) on this `Scene`. |
||||
|
*/ |
||||
|
def onContextMenuRequested = delegate.onContextMenuRequestedProperty |
||||
|
|
||||
|
def onContextMenuRequested_=( |
||||
|
v: jfxe.EventHandler[_ >: jfxsi.ContextMenuEvent] |
||||
|
): Unit = { |
||||
|
onContextMenuRequested() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when drag gesture has been detected. |
||||
|
*/ |
||||
|
def onDragDetected = delegate.onDragDetectedProperty |
||||
|
|
||||
|
def onDragDetected_=(v: jfxe.EventHandler[_ >: jfxsi.MouseEvent]): Unit = { |
||||
|
onDragDetected() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when this `Scene` is a drag and drop gesture source after its data has been |
||||
|
* dropped on a drop target. |
||||
|
*/ |
||||
|
def onDragDone = delegate.onDragDoneProperty |
||||
|
|
||||
|
def onDragDone_=(v: jfxe.EventHandler[_ >: jfxsi.DragEvent]): Unit = { |
||||
|
onDragDone() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when the mouse button is released on this `Scene` during drag and drop gesture. |
||||
|
*/ |
||||
|
def onDragDropped = delegate.onDragDroppedProperty |
||||
|
|
||||
|
def onDragDropped_=(v: jfxe.EventHandler[_ >: jfxsi.DragEvent]): Unit = { |
||||
|
onDragDropped() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when drag gesture enters this Scene. |
||||
|
*/ |
||||
|
def onDragEntered = delegate.onDragEnteredProperty |
||||
|
|
||||
|
def onDragEntered_=(v: jfxe.EventHandler[_ >: jfxsi.DragEvent]): Unit = { |
||||
|
onDragEntered() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when drag gesture exits this Scene. |
||||
|
*/ |
||||
|
def onDragExited = delegate.onDragExitedProperty |
||||
|
|
||||
|
def onDragExited_=(v: jfxe.EventHandler[_ >: jfxsi.DragEvent]): Unit = { |
||||
|
onDragExited() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when drag gesture progresses within this `Scene`. |
||||
|
*/ |
||||
|
def onDragOver = delegate.onDragOverProperty |
||||
|
|
||||
|
def onDragOver_=(v: jfxe.EventHandler[_ >: jfxsi.DragEvent]): Unit = { |
||||
|
onDragOver() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when this `Node` has input focus and the input method text has changed. |
||||
|
*/ |
||||
|
def onInputMethodTextChanged = delegate.onInputMethodTextChangedProperty |
||||
|
|
||||
|
def onInputMethodTextChanged_=( |
||||
|
v: jfxe.EventHandler[_ >: jfxsi.InputMethodEvent] |
||||
|
): Unit = { |
||||
|
onInputMethodTextChanged() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when some `Node` of this `Scene` has input focus and a key has been pressed. |
||||
|
*/ |
||||
|
def onKeyPressed = delegate.onKeyPressedProperty |
||||
|
|
||||
|
def onKeyPressed_=(v: jfxe.EventHandler[_ >: jfxsi.KeyEvent]): Unit = { |
||||
|
onKeyPressed() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when some `Node` of this `Scene` has input focus and a key has been released. |
||||
|
*/ |
||||
|
def onKeyReleased = delegate.onKeyReleasedProperty |
||||
|
|
||||
|
def onKeyReleased_=(v: jfxe.EventHandler[_ >: jfxsi.KeyEvent]): Unit = { |
||||
|
onKeyReleased() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when some `Node` of this `Scene` has input focus and a key has been typed. |
||||
|
*/ |
||||
|
def onKeyTyped = delegate.onKeyTypedProperty |
||||
|
|
||||
|
def onKeyTyped_=(v: jfxe.EventHandler[_ >: jfxsi.KeyEvent]): Unit = { |
||||
|
onKeyTyped() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when a mouse button has been clicked (pressed and released) on this `Scene`. |
||||
|
*/ |
||||
|
def onMouseClicked = delegate.onMouseClickedProperty |
||||
|
|
||||
|
def onMouseClicked_=(v: jfxe.EventHandler[_ >: jfxsi.MouseEvent]): Unit = { |
||||
|
onMouseClicked() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when a mouse button is pressed on this `Scene` and then dragged. |
||||
|
*/ |
||||
|
def onMouseDragged = delegate.onMouseDraggedProperty |
||||
|
|
||||
|
def onMouseDragged_=(v: jfxe.EventHandler[_ >: jfxsi.MouseEvent]): Unit = { |
||||
|
onMouseDragged() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when a full press-drag-release gesture enters this `Scene`. |
||||
|
*/ |
||||
|
def onMouseDragEntered = delegate.onMouseDragEnteredProperty |
||||
|
|
||||
|
def onMouseDragEntered_=( |
||||
|
v: jfxe.EventHandler[_ >: jfxsi.MouseDragEvent] |
||||
|
): Unit = { |
||||
|
onMouseDragEntered() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when a full press-drag-release gesture exits this `Scene`. |
||||
|
*/ |
||||
|
def onMouseDragExited = delegate.onMouseDragExitedProperty |
||||
|
|
||||
|
def onMouseDragExited_=( |
||||
|
v: jfxe.EventHandler[_ >: jfxsi.MouseDragEvent] |
||||
|
): Unit = { |
||||
|
onMouseDragExited() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when a full press-drag-release gesture progresses within this `Scene`. |
||||
|
*/ |
||||
|
def onMouseDragOver = delegate.onMouseDragOverProperty |
||||
|
|
||||
|
def onMouseDragOver_=( |
||||
|
v: jfxe.EventHandler[_ >: jfxsi.MouseDragEvent] |
||||
|
): Unit = { |
||||
|
onMouseDragOver() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when a full press-drag-release gesture ends within this `Scene`. |
||||
|
*/ |
||||
|
def onMouseDragReleased = delegate.onMouseDragReleasedProperty |
||||
|
|
||||
|
def onMouseDragReleased_=( |
||||
|
v: jfxe.EventHandler[_ >: jfxsi.MouseDragEvent] |
||||
|
): Unit = { |
||||
|
onMouseDragReleased() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when the mouse enters this `Scene`. |
||||
|
*/ |
||||
|
def onMouseEntered = delegate.onMouseEnteredProperty |
||||
|
|
||||
|
def onMouseEntered_=(v: jfxe.EventHandler[_ >: jfxsi.MouseEvent]): Unit = { |
||||
|
onMouseEntered() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when the mouse exits this `Scene`. |
||||
|
*/ |
||||
|
def onMouseExited = delegate.onMouseExitedProperty |
||||
|
|
||||
|
def onMouseExited_=(v: jfxe.EventHandler[_ >: jfxsi.MouseEvent]): Unit = { |
||||
|
onMouseExited() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when mouse cursor moves within this `Scene` but no buttons have been pushed. |
||||
|
*/ |
||||
|
def onMouseMoved = delegate.onMouseMovedProperty |
||||
|
|
||||
|
def onMouseMoved_=(v: jfxe.EventHandler[_ >: jfxsi.MouseEvent]): Unit = { |
||||
|
onMouseMoved() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when a mouse button has been pressed on this `Scene`. |
||||
|
*/ |
||||
|
def onMousePressed = delegate.onMousePressedProperty |
||||
|
|
||||
|
def onMousePressed_=(v: jfxe.EventHandler[_ >: jfxsi.MouseEvent]): Unit = { |
||||
|
onMousePressed() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when a mouse button has been released on this `Scene`. |
||||
|
*/ |
||||
|
def onMouseReleased = delegate.onMouseReleasedProperty |
||||
|
|
||||
|
def onMouseReleased_=(v: jfxe.EventHandler[_ >: jfxsi.MouseEvent]): Unit = { |
||||
|
onMouseReleased() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when user performs a scrolling action. |
||||
|
*/ |
||||
|
def onScroll = delegate.onScrollProperty |
||||
|
|
||||
|
def onScroll_=(v: jfxe.EventHandler[_ >: jfxsi.ScrollEvent]): Unit = { |
||||
|
onScroll() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* The URL of the user-agent stylesheet that will be used by this Scene in place of the the platform-default |
||||
|
* user-agent stylesheet. If the URL does not resolve to a valid location, the platform-default user-agent |
||||
|
* stylesheet will be used. |
||||
|
* |
||||
|
* For additional information about using CSS with the scene graph, see the |
||||
|
* [[http://docs.oracle.com/javase/8/javafx/api/javafx/scene/doc-files/cssref.html CSS Reference Guide]]. |
||||
|
* |
||||
|
* @return The URL of the user-agent stylesheet that will be used by this SubScene, or null if has not been set. |
||||
|
*/ |
||||
|
def userAgentStylesheet: ObjectProperty[String] = |
||||
|
delegate.userAgentStylesheetProperty |
||||
|
|
||||
|
/** |
||||
|
* Set the URL of the user-agent stylesheet that will be used by this Scene in place of the the platform-default |
||||
|
* user-agent stylesheet. If the URL does not resolve to a valid location, the platform-default user-agent |
||||
|
* stylesheet will be used. |
||||
|
* |
||||
|
* For additional information about using CSS with the scene graph, see the |
||||
|
* [[http://docs.oracle.com/javase/8/javafx/api/javafx/scene/doc-files/cssref.html CSS Reference Guide]]. |
||||
|
* |
||||
|
* @param url The URL is a hierarchical URI of the form `[scheme:][//authority][path]`. |
||||
|
* If the URL does not have a `[scheme:]` component, the URL is considered to be the `[path]` |
||||
|
* component only. Any leading '/' character of the `[path]` is ignored and the `[path]` is |
||||
|
* treated as a path relative to the root of the application's classpath. |
||||
|
*/ |
||||
|
def userAgentStylesheet_=(url: String): Unit = { |
||||
|
ObjectProperty.fillProperty[String](userAgentStylesheet, url) |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* The `Window` for this Scene |
||||
|
*/ |
||||
|
def window: ReadOnlyObjectProperty[javafx.stage.Window] = |
||||
|
delegate.windowProperty |
||||
|
|
||||
|
/** |
||||
|
* The horizontal location of this `Scene` on the `Window`. |
||||
|
*/ |
||||
|
def x: ReadOnlyDoubleProperty = delegate.xProperty |
||||
|
|
||||
|
/** |
||||
|
* The vertical location of this `Scene` on the `Window`. |
||||
|
*/ |
||||
|
def y: ReadOnlyDoubleProperty = delegate.yProperty |
||||
|
|
||||
|
/** |
||||
|
* Retrieves the depth buffer attribute for this scene. |
||||
|
*/ |
||||
|
def depthBuffer = delegate.isDepthBuffer |
||||
|
|
||||
|
/** |
||||
|
* Gets an observable list of string URLs linking to the stylesheets to use with this Parent's contents. |
||||
|
*/ |
||||
|
def stylesheets: jfxc.ObservableList[String] = delegate.getStylesheets |
||||
|
|
||||
|
/** |
||||
|
* Sets the list of stylesheets URLs, replacing the prior content. If you want append to current content, use `add` or |
||||
|
* similar. |
||||
|
* |
||||
|
* @param c list of stylesheets URLs to replace prior content. |
||||
|
*/ |
||||
|
def stylesheets_=(c: Iterable[String]): Unit = { |
||||
|
fillCollection(stylesheets, c) |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Looks for any node within the scene graph based on the specified CSS selector. |
||||
|
* |
||||
|
* @param selector The css selector to look up |
||||
|
* @return A [[scala.Some]] containing the Node in the scene which matches the CSS selector, or [[scala.None]] |
||||
|
* if none is found. |
||||
|
*/ |
||||
|
def lookup(selector: String): Option[Node] = Option(delegate.lookup(selector)) |
||||
|
|
||||
|
/** |
||||
|
* Registers the specified mnemonic. |
||||
|
* |
||||
|
* @param m The Mnemonic |
||||
|
*/ |
||||
|
def addMnemonic(m: Mnemonic): Unit = { |
||||
|
delegate.addMnemonic(m) |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Unregisters the specified mnemonic. |
||||
|
* |
||||
|
* @param m The Mnemonic to be removed. |
||||
|
*/ |
||||
|
def removeMnemonic(m: Mnemonic): Unit = { |
||||
|
delegate.removeMnemonic(m) |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Gets the list of mnemonics for this `Scene`. |
||||
|
*/ |
||||
|
def getMnemonics |
||||
|
: jfxc.ObservableMap[jfxsi.KeyCombination, jfxc.ObservableList[ |
||||
|
jfxsi.Mnemonic |
||||
|
]] = delegate.getMnemonics |
||||
|
|
||||
|
/** |
||||
|
* Gets the list of accelerators for this Scene. |
||||
|
*/ |
||||
|
def accelerators: jfxc.ObservableMap[jfxsi.KeyCombination, Runnable] = |
||||
|
delegate.getAccelerators |
||||
|
|
||||
|
/** |
||||
|
* Confirms a potential drag and drop gesture that is recognized over this `Scene`. |
||||
|
* |
||||
|
* @param transferModes The supported `TransferMode`(s) of this `Node` |
||||
|
* @return A `Dragboard` to place this `Scene`'s data on |
||||
|
*/ |
||||
|
def startDragAndDrop(transferModes: TransferMode*): Dragboard = |
||||
|
delegate.startDragAndDrop(transferModes.map(_.delegate): _*) |
||||
|
|
||||
|
/** |
||||
|
* Starts a full press-drag-release gesture with this scene as gesture source. |
||||
|
*/ |
||||
|
def startFullDrag(): Unit = { |
||||
|
delegate.startFullDrag() |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* The scene's current focus owner node. This node's "focused" variable might be false if this scene has no window, |
||||
|
* or if the window is inactive (window.focused == false). |
||||
|
* |
||||
|
* @since 2.2 |
||||
|
*/ |
||||
|
def focusOwner: ReadOnlyObjectProperty[jfxs.Node] = |
||||
|
delegate.focusOwnerProperty() |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when user performs a rotation action. |
||||
|
* |
||||
|
* @since 2.2 |
||||
|
*/ |
||||
|
def onRotate = delegate.onRotateProperty |
||||
|
|
||||
|
def onRotate_=(v: jfxe.EventHandler[_ >: jfxsi.RotateEvent]): Unit = { |
||||
|
onRotate() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when a rotation gesture ends. |
||||
|
* |
||||
|
* @since 2.2 |
||||
|
*/ |
||||
|
def onRotationFinished = delegate.onRotationFinishedProperty() |
||||
|
|
||||
|
def onRotationFinished_=( |
||||
|
v: jfxe.EventHandler[_ >: jfxsi.RotateEvent] |
||||
|
): Unit = { |
||||
|
onRotationFinished() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when a rotation gesture starts. |
||||
|
* |
||||
|
* @since 2.2 |
||||
|
*/ |
||||
|
def onRotationStarted = delegate.onRotationFinishedProperty() |
||||
|
|
||||
|
def onRotationStarted_=( |
||||
|
v: jfxe.EventHandler[_ >: jfxsi.RotateEvent] |
||||
|
): Unit = { |
||||
|
onRotationStarted() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when a Scroll gesture ends. |
||||
|
* |
||||
|
* @since 2.2 |
||||
|
*/ |
||||
|
def onScrollFinished = delegate.onScrollFinishedProperty() |
||||
|
|
||||
|
def onScrollFinished_=(v: jfxe.EventHandler[_ >: jfxsi.ScrollEvent]): Unit = { |
||||
|
onScrollFinished() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when a Scroll gesture starts. |
||||
|
* |
||||
|
* @since 2.2 |
||||
|
*/ |
||||
|
def onScrollStarted = delegate.onScrollStartedProperty() |
||||
|
|
||||
|
def onScrollStarted_=(v: jfxe.EventHandler[_ >: jfxsi.ScrollEvent]): Unit = { |
||||
|
onScrollStarted() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when a Swipe Down gesture starts. |
||||
|
* |
||||
|
* @since 2.2 |
||||
|
*/ |
||||
|
def onSwipeDown = delegate.onSwipeDownProperty() |
||||
|
|
||||
|
def onSwipeDown_=(v: jfxe.EventHandler[_ >: jfxsi.SwipeEvent]): Unit = { |
||||
|
onSwipeDown() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when a Swipe Down gesture starts. |
||||
|
* |
||||
|
* @since 2.2 |
||||
|
*/ |
||||
|
def onSwipeLeft = delegate.onSwipeLeftProperty() |
||||
|
|
||||
|
def onSwipeLeft_=(v: jfxe.EventHandler[_ >: jfxsi.SwipeEvent]): Unit = { |
||||
|
onSwipeLeft() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when a Swipe Up gesture starts. |
||||
|
* |
||||
|
* @since 2.2 |
||||
|
*/ |
||||
|
def onSwipeUp = delegate.onSwipeUpProperty() |
||||
|
|
||||
|
def onSwipeUp_=(v: jfxe.EventHandler[_ >: jfxsi.SwipeEvent]): Unit = { |
||||
|
onSwipeUp() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when a Swipe Right gesture starts. |
||||
|
* |
||||
|
* @since 2.2 |
||||
|
*/ |
||||
|
def onSwipeRight = delegate.onSwipeRightProperty() |
||||
|
|
||||
|
def onSwipeRight_=(v: jfxe.EventHandler[_ >: jfxsi.SwipeEvent]): Unit = { |
||||
|
onSwipeRight() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when user performs a Touch action. |
||||
|
* |
||||
|
* @since 2.2 |
||||
|
*/ |
||||
|
def onZoom = delegate.onZoomProperty() |
||||
|
|
||||
|
def onZoom_=(v: jfxe.EventHandler[_ >: jfxsi.ZoomEvent]): Unit = { |
||||
|
onZoom() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when a Zoom gesture ends. |
||||
|
* |
||||
|
* @since 2.2 |
||||
|
*/ |
||||
|
def onZoomFinished = delegate.onZoomFinishedProperty() |
||||
|
|
||||
|
def onZoomFinished_=(v: jfxe.EventHandler[_ >: jfxsi.ZoomEvent]): Unit = { |
||||
|
onZoomFinished() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when a Zoom gesture starts. |
||||
|
* |
||||
|
* @since 2.2 |
||||
|
*/ |
||||
|
def onZoomStarted = delegate.onZoomStartedProperty() |
||||
|
|
||||
|
def onZoomStarted_=(v: jfxe.EventHandler[_ >: jfxsi.ZoomEvent]): Unit = { |
||||
|
onZoomStarted() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when user performs a Touch Moved action. |
||||
|
* |
||||
|
* @since 2.2 |
||||
|
*/ |
||||
|
def onTouchMoved = delegate.onTouchMovedProperty() |
||||
|
|
||||
|
def onTouchMoved_=(v: jfxe.EventHandler[_ >: jfxsi.TouchEvent]): Unit = { |
||||
|
onTouchMoved() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when user performs a Touch Pressed action. |
||||
|
* |
||||
|
* @since 2.2 |
||||
|
*/ |
||||
|
def onTouchPressed = delegate.onTouchPressedProperty() |
||||
|
|
||||
|
def onTouchPressed_=(v: jfxe.EventHandler[_ >: jfxsi.TouchEvent]): Unit = { |
||||
|
onTouchPressed() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when user performs a Touch Released action. |
||||
|
* |
||||
|
* @since 2.2 |
||||
|
*/ |
||||
|
def onTouchReleased = delegate.onTouchReleasedProperty() |
||||
|
|
||||
|
def onTouchReleased_=(v: jfxe.EventHandler[_ >: jfxsi.TouchEvent]): Unit = { |
||||
|
onTouchReleased() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Defines a function to be called when user performs a Touch Stationary action. |
||||
|
* |
||||
|
* @since 2.2 |
||||
|
*/ |
||||
|
def onTouchStationary = delegate.onTouchStationaryProperty() |
||||
|
|
||||
|
def onTouchStationary_=(v: jfxe.EventHandler[_ >: jfxsi.TouchEvent]): Unit = { |
||||
|
onTouchStationary() = v |
||||
|
} |
||||
|
|
||||
|
/** |
||||
|
* Takes a snapshot of this scene and returns the rendered image when it is ready. |
||||
|
* |
||||
|
* @param image The writable image that will be used to hold the rendered scene. |
||||
|
* @return the rendered image |
||||
|
* |
||||
|
* @since 2.2 |
||||
|
*/ |
||||
|
def snapshot(image: WritableImage): WritableImage = delegate.snapshot(image) |
||||
|
|
||||
|
/** |
||||
|
* Takes a snapshot of this scene at the next frame and calls the specified callback method when the image is ready. |
||||
|
* |
||||
|
* @param callback A function to be called when the image is ready. |
||||
|
* @param image The writable image that will be used to hold the rendered scene. |
||||
|
* |
||||
|
* @since 2.2 |
||||
|
*/ |
||||
|
def snapshot(callback: SnapshotResult => Unit, image: WritableImage): Unit = { |
||||
|
val javaCallback = new jfxu.Callback[jfxs.SnapshotResult, java.lang.Void] { |
||||
|
def call(result: jfxs.SnapshotResult): java.lang.Void = { |
||||
|
callback(new SnapshotResult(result)) |
||||
|
null |
||||
|
} |
||||
|
} |
||||
|
delegate.snapshot(javaCallback, image) |
||||
|
} |
||||
|
|
||||
|
} |
||||
@ -0,0 +1,104 @@ |
|||||
|
package wow.doge.mygame.utils |
||||
|
|
||||
|
import java.io.ByteArrayOutputStream |
||||
|
import java.io.OutputStream |
||||
|
import java.io.PrintStream |
||||
|
|
||||
|
import cats.effect.Resource |
||||
|
import monix.bio.Task |
||||
|
import scalafx.scene.control.TextArea |
||||
|
import scalafx.application.Platform |
||||
|
|
||||
|
trait ConsoleStreamable[T] { |
||||
|
def println(inst: T, text: String): Unit |
||||
|
def print(inst: T, text: String): Unit |
||||
|
} |
||||
|
|
||||
|
class GenericConsoleStream[T]( |
||||
|
outputStream: OutputStream, |
||||
|
val config: GenericConsoleStream.Config = |
||||
|
GenericConsoleStream.Config.default, |
||||
|
private var streamable: Option[T] = None |
||||
|
)(implicit |
||||
|
cs: ConsoleStreamable[T] |
||||
|
) extends PrintStream(outputStream, true) { |
||||
|
private lazy val defaultOut = System.out |
||||
|
|
||||
|
def printToStreamable(stble: Option[T], text: String) = |
||||
|
stble.foreach(s => cs.println(s, text)) |
||||
|
|
||||
|
override def println(text: String): Unit = |
||||
|
if (config.exclusive) { |
||||
|
printToStreamable(streamable, text) |
||||
|
} else { |
||||
|
defaultOut.println(text) |
||||
|
printToStreamable(streamable, text) |
||||
|
} |
||||
|
|
||||
|
override def print(text: String): Unit = |
||||
|
streamable.foreach(s => |
||||
|
if (config.exclusive) { |
||||
|
printToStreamable(streamable, text) |
||||
|
} else { |
||||
|
defaultOut.println(text) |
||||
|
printToStreamable(streamable, text) |
||||
|
} |
||||
|
) |
||||
|
|
||||
|
def :=(s: T) = { |
||||
|
streamable match { |
||||
|
case Some(value) => |
||||
|
case None => streamable = Some(s) |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
object GenericConsoleStream { |
||||
|
|
||||
|
/** |
||||
|
* for future use |
||||
|
*/ |
||||
|
case class Config(exclusive: Boolean = false) |
||||
|
object Config { |
||||
|
lazy val default = Config() |
||||
|
} |
||||
|
|
||||
|
implicit val implJFXConsoleStreamForTextArea = |
||||
|
new ConsoleStreamable[scalafx.scene.control.TextArea] { |
||||
|
|
||||
|
override def println( |
||||
|
ta: scalafx.scene.control.TextArea, |
||||
|
text: String |
||||
|
): Unit = |
||||
|
ta.appendText(text + "\n") |
||||
|
|
||||
|
override def print( |
||||
|
ta: scalafx.scene.control.TextArea, |
||||
|
text: String |
||||
|
): Unit = |
||||
|
ta.appendText(text) |
||||
|
|
||||
|
} |
||||
|
|
||||
|
// def textAreaStreamResource(ta: TextArea) = |
||||
|
// Resource.make( |
||||
|
// Task( |
||||
|
// new GenericConsoleStream( |
||||
|
// outputStream = new ByteArrayOutputStream(), |
||||
|
// streamable = ta |
||||
|
// ) |
||||
|
// ) |
||||
|
// )(s => Task(s.close())) |
||||
|
|
||||
|
def textAreaStream( |
||||
|
// ta: TextArea |
||||
|
) = |
||||
|
// Task( |
||||
|
new GenericConsoleStream[TextArea]( |
||||
|
outputStream = new ByteArrayOutputStream() |
||||
|
// streamable = ta |
||||
|
) |
||||
|
// ) |
||||
|
// (s => Task(s.close())) |
||||
|
|
||||
|
} |
||||
@ -1,71 +0,0 @@ |
|||||
package wow.doge.mygame.utils |
|
||||
|
|
||||
import java.io.ByteArrayOutputStream |
|
||||
import java.io.OutputStream |
|
||||
import java.io.PrintStream |
|
||||
|
|
||||
import cats.effect.Resource |
|
||||
import monix.bio.Task |
|
||||
import scalafx.scene.control.TextArea |
|
||||
|
|
||||
trait JFXConsoleStreamable[T] { |
|
||||
def println(inst: T, text: String): Unit |
|
||||
def print(inst: T, text: String): Unit |
|
||||
} |
|
||||
|
|
||||
class JFXConsoleStream[T]( |
|
||||
outputStream: OutputStream, |
|
||||
val config: JFXConsoleStream.Config = JFXConsoleStream.Config.default, |
|
||||
control: T |
|
||||
)(implicit |
|
||||
jcs: JFXConsoleStreamable[T] |
|
||||
) extends PrintStream(outputStream, true) { |
|
||||
private lazy val defaultOut = System.out |
|
||||
override def println(text: String): Unit = |
|
||||
if (config.exclusive) { |
|
||||
jcs.println(control, text + "\n") |
|
||||
} else { |
|
||||
defaultOut.println(text) |
|
||||
jcs.println(control, text + "\n") |
|
||||
} |
|
||||
override def print(text: String): Unit = jcs.println(control, text) |
|
||||
} |
|
||||
|
|
||||
object JFXConsoleStream { |
|
||||
|
|
||||
/** |
|
||||
* for future use |
|
||||
*/ |
|
||||
case class Config(exclusive: Boolean = false) |
|
||||
object Config { |
|
||||
lazy val default = Config() |
|
||||
} |
|
||||
|
|
||||
implicit val implJFXConsoleStreamForTextArea = |
|
||||
new JFXConsoleStreamable[scalafx.scene.control.TextArea] { |
|
||||
|
|
||||
override def println( |
|
||||
ta: scalafx.scene.control.TextArea, |
|
||||
text: String |
|
||||
): Unit = |
|
||||
ta.appendText(text + "\n") |
|
||||
|
|
||||
override def print( |
|
||||
ta: scalafx.scene.control.TextArea, |
|
||||
text: String |
|
||||
): Unit = |
|
||||
ta.appendText(text) |
|
||||
|
|
||||
} |
|
||||
|
|
||||
def textAreaStream(ta: TextArea) = |
|
||||
Resource.make( |
|
||||
Task( |
|
||||
new JFXConsoleStream( |
|
||||
outputStream = new ByteArrayOutputStream(), |
|
||||
control = ta |
|
||||
) |
|
||||
) |
|
||||
)(s => Task(s.close())) |
|
||||
|
|
||||
} |
|
||||
@ -0,0 +1,130 @@ |
|||||
|
package wow.doge.mygame.utils; |
||||
|
|
||||
|
import javafx.event.EventHandler; |
||||
|
import javafx.event.EventType; |
||||
|
import javafx.geometry.Insets; |
||||
|
import javafx.scene.Cursor; |
||||
|
import javafx.scene.Scene; |
||||
|
import javafx.scene.input.MouseEvent; |
||||
|
import javafx.stage.Stage; |
||||
|
|
||||
|
//created by Alexander Berg |
||||
|
public class ResizeHelper { |
||||
|
|
||||
|
public static ResizeListener addResizeListener(Stage stage) { |
||||
|
ResizeListener resizeListener = new ResizeListener(stage); |
||||
|
Scene scene = stage.getScene(); |
||||
|
scene.addEventHandler(MouseEvent.MOUSE_MOVED, resizeListener); |
||||
|
scene.addEventHandler(MouseEvent.MOUSE_PRESSED, resizeListener); |
||||
|
scene.addEventHandler(MouseEvent.MOUSE_DRAGGED, resizeListener); |
||||
|
scene.addEventHandler(MouseEvent.MOUSE_EXITED, resizeListener); |
||||
|
scene.addEventHandler(MouseEvent.MOUSE_EXITED_TARGET, resizeListener); |
||||
|
|
||||
|
return resizeListener; |
||||
|
} |
||||
|
|
||||
|
public static class ResizeListener implements EventHandler<MouseEvent> { |
||||
|
private Stage stage; |
||||
|
private Scene scene; |
||||
|
private Cursor cursorEvent = Cursor.DEFAULT; |
||||
|
private int border = 4; |
||||
|
private double startX = 0; |
||||
|
private double startY = 0; |
||||
|
private double sceneOffsetX = 0; |
||||
|
private double sceneOffsetY = 0; |
||||
|
private double padTop = 0; |
||||
|
private double padRight = 0; |
||||
|
private double padBottom = 0; |
||||
|
private double padLeft = 0; |
||||
|
|
||||
|
public ResizeListener(Stage stage) { |
||||
|
this.stage = stage; |
||||
|
this.scene = stage.getScene(); |
||||
|
} |
||||
|
|
||||
|
public void setPadding(Insets padding) { |
||||
|
padTop = padding.getTop(); |
||||
|
padRight = padding.getRight(); |
||||
|
padBottom = padding.getBottom(); |
||||
|
padLeft = padding.getLeft(); |
||||
|
} |
||||
|
|
||||
|
@Override |
||||
|
public void handle(MouseEvent mouseEvent) { |
||||
|
EventType<? extends MouseEvent> mouseEventType = mouseEvent.getEventType(); |
||||
|
|
||||
|
double mouseEventX = mouseEvent.getSceneX(), mouseEventY = mouseEvent.getSceneY(), |
||||
|
viewWidth = stage.getWidth() - padLeft - padRight, |
||||
|
viewHeight = stage.getHeight() - padTop - padBottom; |
||||
|
|
||||
|
if (MouseEvent.MOUSE_MOVED.equals(mouseEventType)) { |
||||
|
if (mouseEventX < border + padLeft && mouseEventY < border + padTop) { |
||||
|
cursorEvent = Cursor.NW_RESIZE; |
||||
|
} else if (mouseEventX < border + padLeft && mouseEventY > viewHeight - border + padTop) { |
||||
|
cursorEvent = Cursor.SW_RESIZE; |
||||
|
} else if (mouseEventX > viewWidth - border + padLeft && mouseEventY < border + padTop) { |
||||
|
cursorEvent = Cursor.NE_RESIZE; |
||||
|
} else if (mouseEventX > viewWidth - border + padLeft && mouseEventY > viewHeight - border + padTop) { |
||||
|
cursorEvent = Cursor.SE_RESIZE; |
||||
|
} else if (mouseEventX < border + padLeft) { |
||||
|
cursorEvent = Cursor.W_RESIZE; |
||||
|
} else if (mouseEventX > viewWidth - border + padLeft) { |
||||
|
cursorEvent = Cursor.E_RESIZE; |
||||
|
} else if (mouseEventY < border + padTop) { |
||||
|
cursorEvent = Cursor.N_RESIZE; |
||||
|
} else if (mouseEventY > viewHeight - border + padTop) { |
||||
|
cursorEvent = Cursor.S_RESIZE; |
||||
|
} else { |
||||
|
cursorEvent = Cursor.DEFAULT; |
||||
|
} |
||||
|
|
||||
|
scene.setCursor(cursorEvent); |
||||
|
} else if (MouseEvent.MOUSE_EXITED.equals(mouseEventType) |
||||
|
|| MouseEvent.MOUSE_EXITED_TARGET.equals(mouseEventType)) { |
||||
|
scene.setCursor(Cursor.DEFAULT); |
||||
|
} else if (MouseEvent.MOUSE_PRESSED.equals(mouseEventType)) { |
||||
|
startX = viewWidth - mouseEventX; |
||||
|
startY = viewHeight - mouseEventY; |
||||
|
sceneOffsetX = mouseEvent.getSceneX(); |
||||
|
sceneOffsetY = mouseEvent.getSceneY(); |
||||
|
} else if (MouseEvent.MOUSE_DRAGGED.equals(mouseEventType) && !Cursor.DEFAULT.equals(cursorEvent)) { |
||||
|
if (!Cursor.W_RESIZE.equals(cursorEvent) && !Cursor.E_RESIZE.equals(cursorEvent)) { |
||||
|
double minHeight = stage.getMinHeight() > (border * 2) ? stage.getMinHeight() : (border * 2); |
||||
|
|
||||
|
if (Cursor.NW_RESIZE.equals(cursorEvent) || Cursor.N_RESIZE.equals(cursorEvent) |
||||
|
|| Cursor.NE_RESIZE.equals(cursorEvent)) { |
||||
|
if (stage.getHeight() > minHeight || mouseEventY < 0) { |
||||
|
double height = stage.getY() - mouseEvent.getScreenY() + stage.getHeight() + sceneOffsetY; |
||||
|
double y = mouseEvent.getScreenY() - sceneOffsetY; |
||||
|
|
||||
|
stage.setHeight(height); |
||||
|
stage.setY(y); |
||||
|
} |
||||
|
} else { |
||||
|
if (stage.getHeight() > minHeight || mouseEventY + startY - stage.getHeight() > 0) { |
||||
|
stage.setHeight(mouseEventY + startY + padBottom + padTop); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (!Cursor.N_RESIZE.equals(cursorEvent) && !Cursor.S_RESIZE.equals(cursorEvent)) { |
||||
|
double minWidth = stage.getMinWidth() > (border * 2) ? stage.getMinWidth() : (border * 2); |
||||
|
if (Cursor.NW_RESIZE.equals(cursorEvent) || Cursor.W_RESIZE.equals(cursorEvent) |
||||
|
|| Cursor.SW_RESIZE.equals(cursorEvent)) { |
||||
|
if (stage.getWidth() > minWidth || mouseEventX < 0) { |
||||
|
double width = stage.getX() - mouseEvent.getScreenX() + stage.getWidth() + sceneOffsetX; |
||||
|
double x = mouseEvent.getScreenX() - sceneOffsetX; |
||||
|
|
||||
|
stage.setWidth(width); |
||||
|
stage.setX(x); |
||||
|
} |
||||
|
} else { |
||||
|
if (stage.getWidth() > minWidth || mouseEventX + startX - stage.getWidth() > 0) { |
||||
|
stage.setWidth(mouseEventX + startX + padLeft + padRight); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,24 @@ |
|||||
|
package wow.doge.mygame.utils |
||||
|
|
||||
|
import monix.execution.atomic.AtomicAny |
||||
|
|
||||
|
/** |
||||
|
* Useless |
||||
|
*/ |
||||
|
sealed abstract class Tree[+T] |
||||
|
case class Node[T](data: T, children: AtomicAny[LazyList[Tree[T]]]) |
||||
|
extends Tree[T] { |
||||
|
def add(data: T) = { |
||||
|
children.transform(children => |
||||
|
Node(data, AtomicAny(LazyList[Tree[T]]())) #:: children |
||||
|
) |
||||
|
} |
||||
|
} |
||||
|
// case object Leaf extends Tree[Nothing] |
||||
|
case class Data(data: Int) |
||||
|
|
||||
|
class TreeManager[T] { |
||||
|
// val root: AtomicAny[Tree[T]] = AtomicAny(Leaf) |
||||
|
|
||||
|
def add(data: T, node: Node[T]) = {} |
||||
|
} |
||||
Write
Preview
Loading…
Cancel
Save
Reference in new issue