HPoint

Description

Point objects represent points on a two-dimensional coordinate grid. The object's coordinates are stored as public x and y data members.

Instance Variables

type '[HPoint]'
x The X coordinate of the point
y The Y coordinate of the point

Inherits from:

Constructor Method

The constructor is invoked, when a new instance of HPoint is created.

To create a new instance use HPoint.nu( ) or new HPoint( ).

constructor( )

Description

Creates a new Point object that corresponds to the point (x, y), or that's copied from point. If no coordinate values are assigned, the Point's location is indeterminate.

Parameters

by using a HPoint instance:
point Another HPoint or other compatible structure.

by using separate numeric coordinates:

x x coordinate
y y coordinate

Usage

var myPoint = new HPoint(100,200);
var mySameCoordPoint = new HPoint( myPoint );

Class Methods

implement( interface )

Inherited from: HClass

Description

Copies the members of interface to a HClass or a class inherited from HClass.

Usage:

Defines an interface: 
// Create an interface class that calculates the area
var AreaInterface = HClass.extend({
  constructor: null,
  area: function() {
    return this.getWidth() * this.getHeight();
  }
});



// Create a class that contains the coordinates of a rectangle.
var Rectangle = HClass.extend({
  constructor: function( x, y, width, height ) {
    this.x = x;
    this.y = y;
    this.width = width;
    this.height = height;
  },
  getWidth: function() {
    return this.width;
  },
  getHeight: function() {
    return this.height;
  }
});


// Makes the Rectangle class implement the AreaInterface
Rectangle.implement( AreaInterface );

nu( )

Inherited from: HClass

Class members:

Description

nu is a protected class method.

It does the same thing as the new keyword, but it is a class method.

Parameters:

Any parameters are passed on to the constructor method.

Usage:

Creates a class MyClass, then creates two instances of it: myClassInstance1 and myClassInstance2. The end result is the same. 
var MyClass = HClass.extend({
  name: 'Foo',
  constructor: function( param1, param2 ){
    var logMsg = [ 'param1:', param1,
                   'param2:', param2,
                   'name:', this.name ];
    console.log( logMsg.join(' ') );
  }
});

// Construction using the new keyword:
var myClassInstance1 = new MyClass( 'one', 'two' );

// Construction using the nu method:
var myClassInstance2 = MyClass.nu( 'one', 'two' );
However, when extending in place, the benefits of the nu method become obvious.

// Extending in place with the new keyword:
var myExtendedClassInstance1 = new (
  MyClass.extend({
    name: 'Bar'
  })
)( 'one', 'two' );

// The same as above, but using the nu method:
var myExtendedClassInstance2 = MyClass.extend({
  name: 'Bar'
}).nu( 'one', 'two' );

extend( instance, static )

Inherited from: HClass

Description

The class method used to extend a class.

If the member name constructor is defined as null instead of a function block in the instance object block, the class is defined as a singleton (single instance class).

Parameters:

instance The object that defines the class instance members.
static The object that defines the static class members.

Returns:

Returns the extended class object.

Usage:

var Point = HClass.extend({
  constructor: function( x, y ) {
    this.x = x;
    this.y = y;
  }
});
var Rectangle = Point.extend({
  // Instance members:
  constructor: function( x, y, width, height ) {
    this.base( x, y );
    this.width = width;
    this.height = height;
  },
  getWidth: function() {
    return this.width;
  },
  getHeight: function() {
    return this.height;
  }
},


// Class Members
{ description: "this is a Rectangle",
  getClass: function() {
    return this;
  }
});

Instance Methods

subtract( )

Description

Creates and returns a new Point that subtracts the given Point from this Point. The new object's x coordinate is the difference between the operands' x values; its y value is the difference between the operands' y values.

Parameters

with HPoint:

point An HPoint to subtract from.

with coordinates:

x An X-coordinate to subtract from.
y An Y-coordinate to subtract from.

Returns

A new HPoint.

add( point )

Description

Creates and returns a new Point that adds the given Point and this Point together. The new object's x coordinate is the sum of the operands' x values; its y value is the sum of the operands' y values.

Parameters

with HPoint:
point An HPoint to add to.

with coordinates:

x An X-coordinate to add to.
y An Y-coordinate to add to.

Returns

A new HPoint.

set( )

Description

Sets the Point's x and y coordinates.

Parameters

x The new X coordinate of the point
y The new Y coordinate of the point

constrainTo( rect )

Description

Ensures that the Point lies within rect. If it's already contained in the rectangle, the Point is unchanged; otherwise, it's moved to the rect's nearest edge.

Parameters

rect A HRect instance to constrain to.

equals( point )

Description

Returns true if the two objects' point exactly coincide.

Parameter

point A HPoint to compare to.

Returns

The result; true or false.

toString( )

Inherited from: HClass

Protected instance method, returns the instance represented as a String.

valueOf( )

Inherited from: HClass

Protected instance method, returns the value of an instance.

base( )

Inherited from: HClass

This method can be called from any other method to invoke that method's parent

Other Instance Members

prototype = { }

Inherited from: Object

Description

The prototype member of Object defines the instance members. These are copied to the instance object when the new keyword is called.