207 行
8.1 KiB
JavaScript
207 行
8.1 KiB
JavaScript
// Copyright 2011 David Galles, University of San Francisco. All rights reserved.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without modification, are
|
|
// permitted provided that the following conditions are met:
|
|
//
|
|
// 1. Redistributions of source code must retain the above copyright notice, this list of
|
|
// conditions and the following disclaimer.
|
|
//
|
|
// 2. 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.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY David Galles ``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 <COPYRIGHT HOLDER> OR
|
|
// 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.
|
|
//
|
|
// The views and conclusions contained in the software and documentation are those of the
|
|
// authors and should not be interpreted as representing official policies, either expressed
|
|
// or implied, of the University of San Francisco
|
|
|
|
|
|
|
|
function MyAlgorithm(am, w, h)
|
|
{
|
|
this.init(am, w, h);
|
|
}
|
|
|
|
MyAlgorithm.prototype = new Algorithm();
|
|
MyAlgorithm.prototype.constructor = MyAlgorithm;
|
|
MyAlgorithm.superclass = Algorithm.prototype;
|
|
|
|
MyAlgorithm.prototype.init = function(am, w, h)
|
|
{
|
|
// Call the unit function of our "superclass", which adds a couple of
|
|
// listeners, and sets up the undo stack
|
|
MyAlgorithm.superclass.init.call(this, am, w, h);
|
|
|
|
this.addControls();
|
|
|
|
// Useful for memory management
|
|
this.nextIndex = 0;
|
|
|
|
// TODO: Add any code necessary to set up your own algorithm. Initialize data
|
|
// structures, etc.
|
|
|
|
}
|
|
|
|
MyAlgorithm.prototype.addControls = function()
|
|
{
|
|
this.controls = [];
|
|
|
|
// Add any necessary controls for your algorithm.
|
|
// There are libraries that help with text entry, buttons, check boxes, radio groups
|
|
//
|
|
// To add a button myButton:
|
|
// this.mybytton = addControlToAlgorithmBar("Button", "MyButtonText");
|
|
// this.mybytton.onclick = this.myCallback.bind(this);
|
|
// this.controls.push(this.mybutton);
|
|
// where myCallback is a method on this function that implemnts the callback
|
|
//
|
|
// To add a text field myField:
|
|
// this.myField = addControlToAlgorithmBar("Text", "");
|
|
// this.myField.onkeydown = this.returnSubmit(this.myField,
|
|
// this.anotherCallback.bind(this), // callback to make when return is pressed
|
|
// maxFieldLen, // integer, max number of characters allowed in field
|
|
// intOnly); // boolean, true of only digits can be entered.
|
|
// this.controls.push(this.myField);
|
|
//
|
|
// To add a textbox:
|
|
// this.myCheckbox = addCheckboxToAlgorithmBar("Checkbox Label");
|
|
// this.myCheckbox.onclick = this.checkboxCallback.bind(this);
|
|
// this.controls.push(myCheckbox);
|
|
//
|
|
// To add a radio button group:
|
|
// this.radioButtonList = addRadioButtonGroupToAlgorithmBar(["radio button label 1",
|
|
// "radio button label 2",
|
|
// "radio button label 3"],
|
|
// "MyButtonGroupName");
|
|
// this.radioButtonList[0].onclick = this.firstRadioButtonCallback.bind(this);
|
|
// this.controls.push(this.radioButtonList[0]);
|
|
// this.radioButtonList[1].onclick = this.secondRadioButtonCallback.bind(this);
|
|
// this.controls.push(this.radioButtonList[1]);
|
|
// this.radioButtonList[2].onclick = this.thirdRadioButtonCallback.bind(this);
|
|
// this.controls.push(this.radioButtonList[1]);
|
|
//
|
|
// Note that we are adding the controls to the controls array so that they can be enabled / disabled
|
|
// by the animation manager (see enableUI / disableUI below)
|
|
}
|
|
|
|
MyAlgorithm.prototype.reset = function()
|
|
{
|
|
// Reset all of your data structures to *exactly* the state they have immediately after the init
|
|
// function is called. This method is called whenever an "undo" is performed. Your data
|
|
// structures are completely cleaned, and then all of the actions *up to but not including* the
|
|
// last action are then redone. If you implement all of your actions through the "implementAction"
|
|
// method below, then all of this work is done for you in the Animation "superclass"
|
|
|
|
// Reset the (very simple) memory manager
|
|
this.nextIndex = 0;
|
|
|
|
}
|
|
|
|
//////////////////////////////////////////////
|
|
// Callbacks:
|
|
//////////////////////////////////////////////
|
|
//
|
|
// All of your callbacks should *not* do any work directly, but instead should go through the
|
|
// implement action command. That way, undos are handled by ths system "behind the scenes"
|
|
//
|
|
// A typical example:
|
|
//
|
|
//MyAlgorithm.prototype.insertCallback = function(event)
|
|
//{
|
|
// // Get value to insert from textfield (created in addControls above)
|
|
// var insertedValue = this.insertField.value;
|
|
//
|
|
// // If you want numbers to all have leading zeroes, you can add them like this:
|
|
// insertedValue = this.normalizeNumber(insertedValue, 4);
|
|
//
|
|
// // Only do insertion if the text field is not empty ...
|
|
// if (insertedValue != "")
|
|
// {
|
|
// // Clear text field after operation
|
|
// this.insertField.value = "";
|
|
// // Do the actual work. The function implementAction is defined in the algorithm superclass
|
|
// this.implementAction(this.insertElement.bind(this), insertedValue);
|
|
// }
|
|
//}
|
|
// Note that implementAction takes as parameters a function and an argument, and then calls that
|
|
// function using that argument (while also storing the function/argument pair for future undos)
|
|
|
|
//////////////////////////////////////////////
|
|
// Doing actual work
|
|
//////////////////////////////////////////////
|
|
// The functions that are called by implementAction (like insertElement in the comments above) need to:
|
|
//
|
|
// 1. Create an array of strings that represent commands to give to the animation manager
|
|
// 2. Return this array of commands
|
|
//
|
|
// We strongly recommend that you use the this.cmd function, which is a handy utility function that
|
|
// appends commands onto the instance variable this.commands
|
|
//
|
|
// A simple example:
|
|
//
|
|
//MyAlgorithm.simpleAction(input)
|
|
//{
|
|
// this.commands = []; // Empty out our commands variable, so it isn't corrupted by previous actions
|
|
//
|
|
// // Get a new memory ID for the circle that we are going to create
|
|
// var circleID = nextIndex++;
|
|
// var circleX = 50;
|
|
// var circleY = 50;
|
|
//
|
|
// // Create a circle
|
|
// this.cmd("CreateCircle", circleID, "Label", circleX, circleY);
|
|
// circleX = 100;
|
|
// // Move the circle
|
|
// this.cmd("Move", circleID, circleX, circleY);
|
|
// // First Animation step done
|
|
// this.cmd("Step");
|
|
// circleX = 50;
|
|
// circleY = 100;
|
|
// // Move the circle again
|
|
// this.cmd("Move", circleID, circleX, circleY);
|
|
// // Next Animation step done
|
|
// this.cmd("Step");
|
|
// // Return the commands that were generated by the "cmd" calls:
|
|
// return this.commands;
|
|
//}
|
|
|
|
|
|
|
|
// Called by our superclass when we get an animation started event -- need to wait for the
|
|
// event to finish before we start doing anything
|
|
MyAlgorithm.prototype.disableUI = function(event)
|
|
{
|
|
for (var i = 0; i < this.controls.length; i++)
|
|
{
|
|
this.controls[i].disabled = true;
|
|
}
|
|
}
|
|
|
|
// Called by our superclass when we get an animation completed event -- we can
|
|
/// now interact again.
|
|
MyAlgorithm.prototype.enableUI = function(event)
|
|
{
|
|
for (var i = 0; i < this.controls.length; i++)
|
|
{
|
|
this.controls[i].disabled = false;
|
|
}
|
|
}
|
|
|
|
|
|
var currentAlg;
|
|
|
|
function init()
|
|
{
|
|
var animManag = initCanvas();
|
|
currentAlg = new MyAlgorithm(animManag, canvas.width, canvas.height);
|
|
|
|
} |