private void runProcessingAnimation(double duration) {
timeline.setAutoReverse(true);
timeline.setCycleCount(2);
// transitionRect = new TranslateTransition(Duration.millis(duration), rectangle);
// transitionCircle = new TranslateTransition(Duration.millis(duration), circle);
transitionCircle.setDuration(Duration.millis(duration));
transitionCircle.setNode(circle);
transitionCircle.setAutoReverse(false);
transitionCircle.setByX(150);
transitionCircle.setFromX(0);
transitionRect.setAutoReverse(false);
transitionRect.setDuration(Duration.millis(duration));
transitionRect.setNode(rectangle);
transitionRect.setByX(150);
transitionRect.setFromX(0);
KeyValue keyValue = new KeyValue(imageViewTop.translateYProperty(), 90);
KeyFrame keyFrame =
new KeyFrame(
Duration.millis(duration),
(ActionEvent) -> {
toggleHide(rectangle);
transitionRect.play();
transitionCircle.play();
stackProducts(rectangle, imageViewRightStorage, this);
},
keyValue);
timeline.getKeyFrames().clear();
timeline.getKeyFrames().add(keyFrame);
timeline.play();
}
public void keyPressed(KeyEvent event) {
switch (event.getKeyCode()) {
case KeyEvent.VK_UP:
up = true;
break;
case KeyEvent.VK_DOWN:
down = true;
break;
case KeyEvent.VK_LEFT:
left = true;
break;
case KeyEvent.VK_RIGHT:
right = true;
break;
case KeyEvent.VK_SPACE:
Timeline.doneWait();
break;
case KeyEvent.VK_A:
try {
Timeline.advanceScene();
} catch (ArrayIndexOutOfBoundsException e) {
}
break;
}
}
public void checkPacing(SceneManager sm, Timeline tl) {
ArrayList<Tick> tArr = tl.getTickArr();
int[] delTimeArr = new int[tArr.size() - 1];
int total = 0;
// int count = 0;
if (tArr.size() > 1) {
for (int i = 1; i < tArr.size(); i++) {
delTimeArr[i - 1] = tArr.get(i).getTimeStamp() - tArr.get(i - 1).getTimeStamp();
total = total + delTimeArr[i - 1];
}
println("current sscrubber is at time " + tl.getScrollbarTimeInSecs());
println("totalTime is " + total);
int average = total / (tArr.size() - 1);
println("totalAverage is " + average);
// compare the average to the actual distribution of tick events
for (int i = 0; i < delTimeArr.length; i++) {
if (!(delTimeArr[i] < (average + 20) && delTimeArr[i] > (average - 20))
|| delTimeArr[i] < 3) {
tArr.get(i + 1).setPacingViolation(true);
} else {
if (tArr.get(i + 1).getPacingViolation()) {
tArr.get(i + 1).setPacingViolation(false);
}
}
}
}
}
@Test
public void setFetchCountExceedsUpperBound() {
int originalFetchCount = timeline.getFetchCount();
timeline.setFetchCount(Timeline.FETCH_COUNT_UPPER_BOUND + 1);
assertEquals(originalFetchCount, timeline.getFetchCount());
}
@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
setTitle(R.string.dialog_title_select_timeline);
Timeline timeline =
myContext
.persistentTimelines()
.fromId(getArguments().getLong(IntentExtra.TIMELINE_ID.key, 0));
MyAccount currentMyAccount =
myContext
.persistentAccounts()
.fromAccountName(getArguments().getString(IntentExtra.ACCOUNT_NAME.key));
List<Timeline> timelines =
myContext
.persistentTimelines()
.getFiltered(
true,
TriState.fromBoolean(timeline.isCombined()),
currentMyAccount,
timeline.getOrigin());
if (timelines.isEmpty()) {
returnSelectedTimeline(Timeline.getEmpty(null));
return;
} else if (timelines.size() == 1) {
returnSelectedTimeline(timelines.get(0));
return;
}
final List<TimelineListViewItem> items = new ArrayList<>();
for (Timeline timeline2 : timelines) {
TimelineListViewItem viewItem = new TimelineListViewItem(myContext, timeline2);
items.add(viewItem);
}
Collections.sort(
items, new TimelineListViewItemComparator(R.id.displayedInSelector, true, false));
removeDuplicates(items);
setListAdapter(newListAdapter(items));
getListView()
.setOnItemClickListener(
new AdapterView.OnItemClickListener() {
@Override
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
long timelineId =
Long.parseLong(((TextView) view.findViewById(R.id.id)).getText().toString());
returnSelectedTimeline(myContext.persistentTimelines().fromId(timelineId));
}
});
}
@Override
public Iterable<TimelineRecord> getNextRecords(int maxResults) {
SortedSet<TimelineRecord> result = new TreeSet<>();
UnitOfWork uow = module.currentUnitOfWork();
String schedulesName = SchedulerMixin.getSchedulesIdentity(scheduler);
Schedules schedules = uow.get(Schedules.class, schedulesName);
for (Schedule schedule : schedules.schedules()) {
Timeline timeline = (Timeline) schedule;
Iterable<TimelineRecord> lastRecords = timeline.getNextRecords(maxResults);
Iterables.addAll(result, lastRecords);
}
return Iterables.limit(maxResults, result);
}
@Override
public Iterable<TimelineRecord> getRecords(DateTime from, DateTime to) {
SortedSet<TimelineRecord> result = new TreeSet<>();
UnitOfWork uow = module.currentUnitOfWork();
String schedulesName = SchedulerMixin.getSchedulesIdentity(scheduler);
Schedules schedules = uow.get(Schedules.class, schedulesName);
for (Schedule schedule : schedules.schedules()) {
Timeline timeline = (Timeline) schedule;
Iterable<TimelineRecord> lastRecords = timeline.getRecords(from, to);
Iterables.addAll(result, lastRecords);
}
return result;
}
public void draw() {
background(0);
fill(255);
if (!paused) timeline.moveForward();
if (dragging) drawOrbits(timeline.getFutureObjectStates());
else drawOrbits(timeline.getPastObjectStates());
ArrayList objects = timeline.getStatefulObjects();
for (int i = 0; i < objects.size(); i++) {
CelestialObject obj = (CelestialObject) objects.get(i);
obj.display();
}
}
public void backToCenter() {
float x = 0;
float y = super.getY();
mShiftAnimation.setDestination(x, y);
this.setAnimation(mShiftAnimation);
Timeline.getInstance().addAnimation(mShiftAnimation);
}
public void cancel() {
synchronized (TimelineEngine.LOCK) {
TimelineScenarioState oldState = this.state;
if (oldState != TimelineScenarioState.PLAYING) return;
this.state = TimelineScenarioState.DONE;
for (TimelineScenarioActor waiting : this.waitingActors) {
if (waiting instanceof Timeline) {
((Timeline) waiting).cancel();
}
}
for (TimelineScenarioActor running : this.runningActors) {
if (running instanceof Timeline) {
((Timeline) running).cancel();
}
}
}
}
@Ignore // TODO: Activate once this was fixed
@Test
public void test() {
t.play();
delay(200);
if (!newVal.equals(target.getValue())) {
throw new AssertionError("key value changed");
}
}
public void mouseDragged() {
if (paused) {
ArrayList objects = timeline.getStatefulObjects();
for (int i = 0; i < objects.size(); i++) {
CelestialObject obj = (CelestialObject) objects.get(i);
if (obj.isMouseOver()) {
dragging = true;
PVector pos = obj.getPosition();
pos.x = mouseX;
pos.y = mouseY;
timeline.reset();
timeline.setCurrentState(objects);
sliderTimeline.setValue(0);
break;
}
}
}
}
public void mouseClicked() {
ArrayList objects = timeline.getStatefulObjects();
for (int i = 0; i < objects.size(); i++) {
CelestialObject obj = (CelestialObject) objects.get(i);
if (obj.isMouseOver()) {
println(obj.getName() + " clicked!");
break;
}
}
}
/*
* Q - Up, E - Down, A - Left, D - Right, W - Forward, S - Backward
*/
public void keyPressed() {
if (key == 'q' || key == 'Q') {
globalCameraY--;
}
if (key == 'e' || key == 'E') {
globalCameraY++;
}
if (key == 'w' || key == 'W') {
globalCameraZ--;
}
if (key == 'a' || key == 'A') {
globalCameraX++;
}
if (key == 's' || key == 'S') {
globalCameraZ++;
}
if (key == 'd' || key == 'D') {
globalCameraX--;
}
if (key == ' ') {
if (selectedRule == 0) selectedRule = 1;
else selectedRule = 0;
}
if (key == 't' || key == 'T') {
// if a camera is active, add tick
for (int i = 0; i < cameras.size(); i++) {
if (cameras.get(i).camIsSelected()) {
// need to find which tick is before/after the one that would be placed here
// TODO above
timeline.addTick(cameras.get(i));
}
}
}
if (key == 'l' || key == 'L') {
timeline.play();
}
if (key == 'p' || key == 'P') {
timeline.pause();
}
}
public void onClick(View v) {
// TODO Auto-generated method stub
switch (v.getId()) {
case R.id.cancel:
finish();
break;
case R.id.okay:
// Displaying the count of letters
c = message.getText().length();
String letter_count = Integer.toString(c);
count.setText(letter_count);
Posts post = new Posts();
Log.d(TAG, message.getText().toString());
// get the username from login page
post.username = Timeline.name;
post.message = message.getText().toString();
// post.icon = Timeline.icon;
post.time = now();
Log.d(TAG, post.username + " " + post.message + " " + post.time);
GsonBuilder gsonb = new GsonBuilder();
Gson gson = gsonb.create();
msg = gson.toJson(post);
Log.d(TAG, msg);
Intent res_intent = new Intent();
res_intent.putExtra("message", msg);
List<NameValuePair> list = new ArrayList<NameValuePair>();
HttpPost httppost = new HttpPost(newPostURL);
HttpResponse response;
try {
list.add(new BasicNameValuePair("username", post.username));
list.add(new BasicNameValuePair("message", post.message));
list.add(new BasicNameValuePair("time", post.time));
httppost.setEntity(new UrlEncodedFormEntity(list));
Log.d(TAG, list.toString());
response = client.execute(httppost);
String res = tl.responsetoString(response.getEntity().getContent());
Log.d(TAG, res);
} catch (Exception e) {
e.printStackTrace();
}
setResult(RESULT_OK, res_intent);
finish();
break;
}
}
public void resume() {
synchronized (TimelineEngine.LOCK) {
TimelineScenarioState oldState = this.state;
if (oldState != TimelineScenarioState.SUSPENDED) return;
this.state = this.statePriorToSuspension;
for (TimelineScenarioActor running : this.runningActors) {
if (running instanceof Timeline) {
((Timeline) running).resume();
}
}
}
}
public static void selectTimeline(
FragmentActivity activity,
ActivityRequestCode requestCode,
Timeline timeline,
MyAccount currentMyAccount) {
SelectorDialog selector = new TimelineSelector();
selector.setRequestCode(requestCode);
selector.getArguments().putLong(IntentExtra.TIMELINE_ID.key, timeline.getId());
selector
.getArguments()
.putString(IntentExtra.ACCOUNT_NAME.key, currentMyAccount.getAccountName());
selector.show(activity);
}
private static Timeline getTimeline(UserData user) {
Timeline tl = new Timeline();
TimelinePoint lasttp = null;
boolean truncated = false;
for (Position p : user.getPositions()) {
TimelinePoint tp = new TimelinePoint(p.getHourOfDay(), scaleX(p.getX()), scaleY(p.getY()));
if (lasttp == null) lasttp = tp;
else {
if (!p.isTruncated()) {
TimelineSegment s1 =
new TimelineSegment(
lasttp,
tp,
(truncated || p.isTruncated() ? DrawTimelines.DASHED : DrawTimelines.SOLID));
tl.getSegments().add(s1);
lasttp = tp;
truncated = p.isTruncated();
} else truncated = true;
}
}
return tl;
}
protected void update(BoneRef ref, Bone root, int time) {
boolean isObject = ref instanceof ObjectRef;
// Get the timelines, the refs pointing to
Timeline timeline = getTimeline(ref.timeline);
Timeline.Key key = timeline.getKey(ref.key);
Timeline.Key nextKey = timeline.getKey((ref.key + 1) % timeline.keys.length);
int currentTime = key.time;
int nextTime = nextKey.time;
if (nextTime < currentTime) {
if (!looping) nextKey = key;
else nextTime = length;
}
// Normalize the time
float t = (float) (time - currentTime) / (float) (nextTime - currentTime);
if (Float.isNaN(t) || Float.isInfinite(t)) t = 1f;
if (currentKey.time > currentTime) {
float tMid = (float) (currentKey.time - currentTime) / (float) (nextTime - currentTime);
if (Float.isNaN(tMid) || Float.isInfinite(tMid)) tMid = 0f;
t = (float) (time - currentKey.time) / (float) (nextTime - currentKey.time);
if (Float.isNaN(t) || Float.isInfinite(t)) t = 1f;
t = currentKey.curve.tween(tMid, 1f, t);
} else t = currentKey.curve.tween(0f, 1f, t);
// Tween bone/object
Bone bone1 = key.object();
Bone bone2 = nextKey.object();
Bone tweenTarget = this.tweenedKeys[ref.timeline].object();
if (isObject)
this.tweenObject(
(Object) bone1, (Object) bone2, (Object) tweenTarget, t, key.curve, key.spin);
else this.tweenBone(bone1, bone2, tweenTarget, t, key.curve, key.spin);
this.unmappedTweenedKeys[ref.timeline].active = true;
this.unmapTimelineObject(
ref.timeline,
isObject,
(ref.parent != null) ? this.unmappedTweenedKeys[ref.parent.timeline].object() : root);
}
public void setup() {
size(1024, 768);
background(0);
frameRate(30);
smooth();
drawVectors = false;
paused = true;
timeline = new Timeline();
sim = new GravitySimulation();
sun = new Star(5000, 25, new PVector(300, 500), new PVector(0, 0), 0, "sun");
planet = new Planet(10, 10, new PVector(500, 500), new PVector(0, 40), "planet");
planet2 = new Planet(50, 10, new PVector(150, 500), new PVector(0, -40), "planet2");
timeline.registerStatefulObject(sun);
timeline.registerStatefulObject(planet);
timeline.registerStatefulObject(planet2);
controlP5 = new ControlP5(this);
btnRewind = controlP5.addButton("btnRewind_OnClick", 0, 800, 20, 50, 20);
btnRewind.setLabel("Rewind");
btnPlayPause = controlP5.addButton("btnPlayPause_OnClick", 0, 860, 20, 50, 20);
btnPlayPause.setLabel("Play");
btnFastForward = controlP5.addButton("btnFastForward_OnClick", 0, 920, 20, 80, 20);
btnFastForward.setLabel("Fast Forward");
sliderTimeline = controlP5.addSlider("sliderTimeline_OnClick", 0, 10000, 0, 20, 720, 900, 10);
sliderTimeline.setLabel("Timeline");
}
public void checkCuttingOnAction(SceneManager sm, Timeline tl) {
LinkedList<Event> eList = sm.getEventList();
ArrayList<Tick> tArr = tl.getTickArr();
ListIterator<Event> listIt;
for (int i = 0; i < tArr.size(); i++) {
// println("here");
listIt = eList.listIterator();
while (listIt.hasNext()) {
Event tempEvent = listIt.next();
// check for time colisions.
// println("event " + tempEvent.getTimeStamp() + " tick time " +
// tArr.get(i).getTimeStamp() + " " + tempEvent.type);
if ((tempEvent.getType() == DIA_TIME)
&& (tempEvent.getTimeStamp() == tArr.get(i).getTimeStamp())) {
println("CUTTING ON ACTION ERROR!");
tArr.get(i).setCutViolation(true);
} else {
tArr.get(i).setCutViolation(false);
}
}
}
}
public void resume() {
timeline.play();
}
@Override
public void dispose() {
super.dispose();
}
@After
public void tearDown() {
timeline.dispose();
}
@After
public void cleanUp() {
t.stop();
}
@Override
public void run() {
while (true) {
switch (playState) {
case BUFFERING:
bufferToNextPosition();
break;
case PLAYING:
Date currDate = new Date();
long elapsed = (int) ((currDate.getTime() - lastSliceRequestDate.getTime()) * playSpeed);
this.lastSliceRequestDate = currDate;
// Check if we've been truncated, and move forward if necessary
if (totalElapsed < timeline.getFirstOffset()) {
log.info(
"Elapsed time ({}) occurs before the current timeline ({})",
totalElapsed,
timeline.getFirstOffset());
long position = elapsed;
boolean noMatch = true;
while (noMatch) {
if (position != timeline.getFirstOffset()) {
position = timeline.getFirstOffset();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
// Ignore
}
} else {
noMatch = false;
}
}
log.info("Will buffer to new position: {}", position);
bufferAtPosition(position);
break;
}
// Update actors and build a usage map
Map<String, Integer> slotsUsedByUser = new HashMap<String, Integer>();
Iterator<? extends Actor> i = getJobActors().values().iterator();
while (i.hasNext()) {
Actor actor = i.next();
if (actor instanceof JobActor) {
JobActor jobActor = (JobActor) actor;
if (jobActor.defunct) {
removeJobActor(jobActor.name, jobActor);
} else {
int slots = 1;
if (jobActor.queued) {
// If a job is queued then it is represented by a single sprite, so we need the
// actual number of slots
GridJob job = state.getJobByFullId(jobActor.name);
if (job != null) {
slots = job.getSlots();
}
}
if (jobActor.getName().contains(":")) {
// Parse a jobId like this: 1275988.2828-4000:1
try {
Pattern p = Pattern.compile("(\\d+)\\.(\\d+)-(\\d+):(\\d+)");
Matcher m = p.matcher(jobActor.getName());
if (m.matches()) {
int start = Integer.parseInt(m.group(2));
int end = Integer.parseInt(m.group(3));
int interval = Integer.parseInt(m.group(4));
slots = (end - start) / interval;
}
} catch (Exception e) {
log.error("Error parsing jobId: " + jobActor.getName(), e);
}
} else if (jobActor.getName().contains(",")) {
// Parse a jobId like this: 2968157.205,211
try {
Pattern p = Pattern.compile("(\\d+)\\.(\\d+),(\\d+)");
Matcher m = p.matcher(jobActor.getName());
if (m.matches()) {
int first = Integer.parseInt(m.group(2));
int second = Integer.parseInt(m.group(3));
// There are two jobs listed here, so we require twice the number of slots
slots *= 2;
}
} catch (Exception e) {
log.error("Error parsing jobId: " + jobActor.getName(), e);
}
}
String user = jobActor.getUsername();
if (!slotsUsedByUser.containsKey(user)) {
slotsUsedByUser.put(user, 0);
}
if (!jobActor.queued) {
slotsUsedByUser.put(user, slotsUsedByUser.get(user) + slots);
}
}
}
}
legend.retain(slotsUsedByUser);
updateState(elapsed);
break;
case READY:
break;
case PAUSED:
break;
case END:
return;
default:
log.error("Invalid play state: " + playState);
break;
}
try {
Thread.sleep(50);
} catch (InterruptedException e) {
// Ignore
}
}
}
private List<GridEvent> getNextSlice(long elapsed) {
List<GridEvent> slice = new ArrayList<GridEvent>();
if (elapsed <= 0) return slice;
this.totalElapsed += elapsed;
log.trace("getNextSlice, prevElapsed={}, totalElapsed={}", prevElapsed, totalElapsed);
if (prevElapsed >= totalElapsed) {
log.warn(
"No slice possible with (prevElapsed={}, totalElapsed={})", prevElapsed, totalElapsed);
return slice;
}
long start = prevElapsed;
long end = totalElapsed;
SortedMap<Long, List<Event>> eventSlice = timeline.getEvents(start, end);
if (!eventSlice.isEmpty()) {
// We only move the start of the window up when we find an event. This done because the
// database might
// have gaps if the incoming events cannot be processed in real-time. In that case, we don't
// want to
// miss any events if they come late.
this.prevElapsed = totalElapsed;
log.trace("Timeline has {} offset buckets", timeline.getNumOffsets());
log.info(
"Requested slice where {}<=t<{} and got " + eventSlice.size() + " buckets", start, end);
}
if (!eventSlice.isEmpty()) {
for (Long offset : eventSlice.keySet()) {
log.trace("Got offset bucket {}", offset);
if (offset >= totalElapsed) {
log.warn(
"Timeline returned grid events outside the requested frame: {}>{}",
offset,
totalElapsed);
break;
}
List<Event> events = eventSlice.get(offset);
synchronized (events) {
if (events.isEmpty()) {
log.trace("Got empty offset bucket for offset {}", offset);
}
for (Event event : events) {
if (event instanceof GridEvent) {
GridEvent gridEvent = (GridEvent) event;
log.trace("Got grid event {}", gridEvent);
slice.add(gridEvent);
} else if (event instanceof SnapshotEvent) {
SnapshotEvent gridEvent = (SnapshotEvent) event;
log.trace("Got snapshot event {}", gridEvent);
} else {
log.trace("Got unrecognized event {}", event);
}
}
}
}
}
return slice;
}
private void bufferToNextPosition() {
log.info("Buffering to next position: {}", nextStartingPosition);
int i = 0;
Snapshot reqSnapshot = null;
Snapshot prevSnapshot = null;
for (Snapshot snapshot : timeline.getSnapshots()) {
long offset = timeline.getOffset(snapshot.getSamplingTime());
log.debug("Snapshot {} has offset {}", i, offset);
if (offset >= nextStartingPosition) {
if (prevSnapshot == null) {
reqSnapshot = snapshot;
} else {
reqSnapshot = prevSnapshot;
}
break;
}
prevSnapshot = snapshot;
i++;
}
if (reqSnapshot == null) {
reqSnapshot = prevSnapshot;
if (reqSnapshot == null) {
log.error("Could not find snapshot for offset {}", nextStartingPosition);
setPlayState(PlayState.PAUSED);
return;
}
}
// Initialize the state at the closest possible snapshot
log.info(
"Init with snapshot with offset {}", timeline.getOffset(reqSnapshot.getSamplingTime()));
this.state = new GridState(reqSnapshot, "runState");
initState();
// Apply all events between the closet snapshot and the desired starting position
this.totalElapsed = timeline.getOffset((reqSnapshot.getSamplingTime())) + 1;
// This must be set before calling updateState for the first time after changing the position
// (i.e. totalElapsed)
this.prevElapsed = totalElapsed;
long elapsed = nextStartingPosition - totalElapsed;
if (elapsed < 0) {
log.warn(
"Negative time elapsed. Normalizing to nextStartingPosition={}", nextStartingPosition);
totalElapsed = nextStartingPosition;
elapsed = nextStartingPosition;
}
log.info("Buffering elapsed: {}", elapsed);
this.tweenChanges = false;
updateState(elapsed);
this.tweenChanges = true;
// Get ready to start playing
this.lastSliceRequestDate = new Date();
if (totalElapsed != nextStartingPosition) {
totalElapsed = nextStartingPosition;
}
setPlayState(PlayState.READY);
log.info("Buffered at totalElapsed={}", totalElapsed);
}
@Test
public void setFetchCount() {
timeline.setFetchCount(NEW_FETCH_COUNT);
assertEquals(NEW_FETCH_COUNT, timeline.getFetchCount());
}
@Test
public void initialState() {
assertTrue(timeline.getFetchCount() > 0);
}
