#include <AlUniverse.h>
#include <AlCurve.h>
#include <AlCurveCV.h>
#include <AlCurveNode.h>
#include <AlLiveData.h>
#include <AlFunction.h>
#include <AlFunctionHandle.h>
#include <AlCommand.h>
#include <AlUserCommand.h>
#include <AlNotifyDagNode.h>
#include <AlPickList.h>
#include <AlAttributes.h>
#include <AlLineAttributes.h>
#include <string.h>
//	Construction history plug-in example:
//	=====================================
//
// 	The following code implements a simple construction history
// 	command plug-in.  Construction history plug-ins tie into the
// 	command mechanism of Alias and allow the rebuilding of geometry
// 	on the fly.
//
// 	This plug-in accepts two curve nodes from the pick list as input.
// 	The output of the command are two lines.  The first line joins
// 	the start points of the two picked curve nodes together.  The 
//	second line joins the end points of the two picked curve nodes
//	together.  The ouput lines are rebuilt as changes are made to
// 	the constructors to provide the appearance of link objects.
//
// 	Notes on construction history:
//	==============================
//
// 	1.  Construction history commands contain ’constructor’ objects
//	which are used in the construction or creation of new objects.
//
// 	2.  The new objects created are called targets.
//
// 	3.  AlUserCommand is a class that is tied into the command
//	command mechanism of Alias.  Events happen in Alias which
//	may force a rebuild or save, retrieve etc in a command.  The 
//	construction history plug-in implements handlers for the above events.
//	These handlers are called when required by Alias.
//
// 	4.  The inputs or constructors of the command can be taken from
//	the pick list as this example illustrates.
//
// 	5.  For an Alias created object that has construction history,
//	moving the targets causes construction history to be broken.  A
//	plug-in would have to program this enforcement if it did not want
//	the geometry to become out of sync.  One of the reasons why
//	construction history should not update if a target is moved is 
//	that it is very difficult to know how to update a constructor
//	based on the target’s new state.  To enforce this condition,
//	a plug-in would have to make sure it called addTargetRef() on
//	its targets.  If this is done properly, the targets will automatically
//	be given the default construction history colour which is green.
//	In addition, the user will be prompted if construction history
//	is about to be broken.
//
// 	6.  There are several helper classes required by construction
//	history plug-ins.  These include AlNotifyDagNode, AlInput,
//	AlOutput and AlCommand.  It would be very useful to read
//	the documentation for these classes before attempting to
//	write a construction history plug-in.
//
// 	7.  It is not usually the case that one AlUserCommand method calls
//	another.  Instead the Alias command engine calls into the
//	AlUserCommand methods or the AlCommand class is used to make
//	calls to the AlUserCommand.
//
// 	8.  It is possible to save plug-in construction history data into
//	a wire file so that the next time the file is loaded  with the
//	plug-in also loaded, the command will automatically be reinstated 
//	for the objects.  
//	If the plug-in is not loaded the construction history data is loaded,
//	and a message is emitted to the promptline history saying
//	that the plug-in associated with the construction history 
//	command cannot be found.  The construction history data will
//	be resaved when the wire file is written out again regardless
//	of if the plug-in is loaded. 
//
//	Notes on this plug-in:
//	======================
//
//	1.  This plug-in deletes the targets every time the command
//	is executed for simplicity.  This would cause many problems
//	if there was animation on the constructors and we played
//	the frames.  See the AlPlayFrame class for more details.  It
//	is better to modify the geometry than to delete and recreate
//	it.
//
//	2.  Many parts of the code below are generic to all construction
//	history plug-ins.  The specific code that should be replaced
//	for a new plug-in is any code snippet that references the constructors
//	or targets.  The cmdData class would also have to be updated
//	to support the data types required by your plug-in.
//
//	3.  Don’t underestimate the usefullness of the printfs() in
//	the code below.  Construction history plug-ins are difficult
//	to write or understand because of the multiple entry points that are
//	required by the code.  The printfs() will help a great deal in
//	analyzing how this example works.
//	Also if you call AlCommand::setDebug( TRUE ), messages related
//	to the command will be written to the errlog.
//
//
// Prototypes
//
static 
statusCode firstPosition( AlObject *obj, double& x, double& y, double& z );
static
statusCode lastPosition( AlObject *obj, double& x, double& y, double& z );
static
statusCode createLine( AlCurveNode *&cp, double a[3], double b[3] );
static 
void updateLinePosition( AlCurveNode *curveNode, 
	double x, double y, double z, double x2, double y2, double z2 );
#define CMD_NAME "linkObject"	// Used by OpenAlias for creation and 
								// destruction of the command plug-in.
#define CMD_CLASS_ID	50		// A user defined type in case you have
								// more than 1 command. 
const int kIntId = 100;
const int kCharId = 101;
const int kDoubleId = 102;
//
// A user defined data class.  This class contains two 
// constructor dag nodes and their targets.  firstDagObject
// and secondDagObject are the constructors.  firstLineDag and
// secondLineDag are the targets and are
// rebuilt based on the changes to the constructors. 
// 
class cmdData
{
public:
	cmdData*			cmdDataPtr()	{ return this; }
	AlCurveNode*		firstDagObject;
	AlCurveNode*		secondDagObject;
	AlCurveNode*		firstLineDag;
	AlCurveNode*		secondLineDag;
	
	AlData *charData;
	AlData *intData;
	AlData *doubleData;
};
class genericCmd: public AlUserCommand, private cmdData
{
	enum error { kOkay = 0, kInvalid = 1, kDagNodeNotHandled };
public:
	genericCmd();
	~genericCmd();
	virtual int			isValid();
	virtual int			execute();
	virtual int			declareReferences();
	virtual int			instanceDag( AlDagNode *oldDag, AlDagNode *newDag );
	virtual int			undo();
	virtual int			geometryModified( AlDagNode *dag );
	virtual int			listModifiedDagNodes( const AlNotifyDagNode *dagMod, AlObject *obj );
	virtual int			debug( const char *prefix );
	virtual void *		asDerivedPtr();
	virtual statusCode	retrieveWire( AlInput *input );
	virtual statusCode	storeWire( AlOutput *output );
	virtual int			dagModified( AlDagNode *dag );
	// for your own use
	virtual int			type();
	// We didn’t bother to implement these commands since they don’t apply
	// to us (they would be similar to instanceDag() and geometryModified() )
	//
	// virtual int curveOnSurfaceModified( AlCurveOnSurface *surf );
	// The following command is not yet supported
	// virtual statusCode  storeSDL( ofstream &outputSDL );
public:
	// Methods that the UI commands can use to set our fields
	statusCode			set( AlDagNode *firstDag, AlDagNode *secondDag );
	
private:
	boolean requireStrongValidity;
};
//
//	Start command definition
//
genericCmd::genericCmd()
//
//	Initialize the structure
//
{
	firstDagObject = NULL;
	secondDagObject = NULL;
	
	firstLineDag = NULL;
	secondLineDag = NULL;
	
	requireStrongValidity = TRUE;
	
	charData = NULL;
	intData = NULL;
	doubleData = NULL;
}
genericCmd::~genericCmd()
//
// Provide a safe cleanup.
//
{
	if ( firstDagObject != NULL )
		delete firstDagObject;
	if ( secondDagObject != NULL )
		delete secondDagObject;
	if ( firstLineDag != NULL )
		delete firstLineDag;
	if ( secondLineDag != NULL )
		delete secondLineDag;
		
	if ( charData )
		delete charData;
	if ( intData )
		delete intData;
	if ( doubleData )
		delete doubleData;
}
void *genericCmd::asDerivedPtr()
//
//	Provide safe down casting.
//
{
	return this;
}
int genericCmd::type()
//
//	User defined value so you can determine the class type
//	of the command.
//
{
	return CMD_CLASS_ID;
}
int genericCmd::isValid()
//
//	Since the construction history plug-in maintains its own data,
//	it is necessary for it to implement the isValid() method to
//	tell the command layer that it is ok to call this command.
//
{
	// Testing will involve NULL pointer checks, making sure you
	// have the correct kind of Dags and so on.
	
	if( firstDagObject == NULL || secondDagObject == NULL )
		return kInvalid;
		
	if ( requireStrongValidity )
		if ( firstLineDag == NULL || secondLineDag == NULL )
			return kInvalid;
	int result1, result2;
	
	switch( firstDagObject->type() )
	{
		case kCurveNodeType:
			result1 =  kOkay;
			break;
		default:
			result1 =  kDagNodeNotHandled;
			break;
	}
	switch( secondDagObject->type() )
	{
		case kCurveNodeType:
			result2 =  kOkay;
			break;
		default:
			result2 =  kDagNodeNotHandled;
			break;
	}
	if ( result1 == kOkay && result2 == kOkay )
		return kOkay;
		
	return kDagNodeNotHandled;
}
int genericCmd::execute()
//
//	This method is called when the geometry needs to be updated.
//	This will occur if the constructor dag nodes are modified.	
//
{	
	double a[3],b[3];
	
	if ( firstPosition( firstDagObject,a[0], a[1], a[2] ) == sSuccess &&
			 firstPosition( secondDagObject, b[0], b[1], b[2] ) == sSuccess )
	{
		if ( firstLineDag == NULL )
		{
			if ( createLine( firstLineDag, a, b ) == sSuccess )
				printf("created new line\n");
			else
				printf("failed to create new line\n");
		}
		else
		{
			updateLinePosition( firstLineDag, a[0], a[1], a[2], b[0], b[1], b[2]  );
		}
	} 
	if ( lastPosition( firstDagObject,a[0], a[1], a[2] ) == sSuccess &&
			 lastPosition( secondDagObject, b[0], b[1], b[2] ) == sSuccess )
	{
		if ( secondLineDag == NULL )
		{
			if ( createLine( secondLineDag, a, b ) == sSuccess )
				printf("created new line\n");
			else
				printf("failed to create new line\n");
		}
		else
		{
			updateLinePosition( secondLineDag, a[0], a[1], a[2], b[0], b[1], b[2]  );
		}
	} 
	// Force the redrawing of the screen
	AlUniverse::redrawScreen( kRedrawAll );
	return kOkay;
}
int genericCmd::instanceDag( AlDagNode *oldDag, AlDagNode *newDag )
//
//	Handle a dag node being instanced.  Go through the class and replace
//	any references to oldDag with newDag
//
{
printf("genericCmd::instanceDag()\n");
	if ( oldDag == NULL || newDag == NULL )
		return -1;
		
	if( AlAreEqual( firstDagObject, oldDag ) )
	{
		// Toss our old wrapper and replace it with a new one.
		delete firstDagObject;
		firstDagObject = newDag->copyWrapper()->asCurveNodePtr();
	}
	if( AlAreEqual( secondDagObject, oldDag ) )
	{
		// Toss our old wrapper and replace it with a new one.
		delete secondDagObject;
		secondDagObject = newDag->copyWrapper()->asCurveNodePtr();
	}
	return kOkay;
}
int genericCmd::declareReferences()
//
//	Declare any references to constructors and targets.
//	The constructors are the inputs to the command and
//	the targets are the outputs.  By setting this association,
//	Alias will know to call the methods implemented in
//	the plug-in for modifications to the constructor and
//	target dags.
//
{
printf("genericCmd::declareReferences()\n");
	if ( firstDagObject != NULL )
		addConstructorRef( firstDagObject );
	if ( secondDagObject != NULL )
		addConstructorRef( secondDagObject );
	if ( firstLineDag != NULL )
		addTargetRef( firstLineDag );
	if ( secondLineDag != NULL )
		addTargetRef( secondLineDag );
	
	return kOkay;
}
int genericCmd::geometryModified( AlDagNode *dag )
//
//	The geometry for the constructor dags has been modified.
//
{
	if ( dag == NULL )
		return -1;
		
	if ( dag->name() != NULL )
		printf("genericCmd::geometryModified( %s )\n",dag->name());
		
	// If the parameter dag is the same as one of our dags
	// then we don’t have to do much.
	if( AlAreEqual( firstDagObject, dag) )
	{
		return kOkay;
	}
	if( AlAreEqual( secondDagObject, dag) )
	{
		return kOkay;
	}
	// If we have gotten to this point, then one of the
	// dags our command knows about has changed.  Free
	// the dags up and let the command know it has been
	// modified.
	delete firstDagObject;	firstDagObject = NULL;
	delete secondDagObject;	secondDagObject = NULL;
	// Signal that the command has been modified by making the
	// appropriate call.
	AlCommand *cmd = command();
	cmd->modified();
	delete cmd;
	return kOkay;	
}
int genericCmd::dagModified( AlDagNode *dag )
//
//	The dag was modified.  This method will be called if the
//	dag is translated and so on.
//
{
	if ( dag == NULL )
		return -1;
		
	if ( dag->name() != NULL )
		printf("genericCmd::dagModified( %s )\n",dag->name());
		
	// This method does not need to do much for this plug-in.
	if( ( AlIsValid( dag ) && AlIsValid( firstDagObject ) && AlAreEqual( dag, firstDagObject ) ) || 
		( AlIsValid( dag ) && AlIsValid( secondDagObject ) && AlAreEqual( dag, secondDagObject ) ))
	{
	} 
	return kOkay;
}
int genericCmd::debug( const char *prefix )
{
	if ( prefix != NULL )
		printf("genericCmd::debug( %s )\n",prefix);
		
	return kOkay;
}
int genericCmd::undo()
//
//	Undo everything the ’execute’ did.  The cmdData class would need
//	to store the previous state of the world so we can undo one
//	step.
//
//	Note:  for this simple example undo does not need to be written.
//	If a user transforms the constructors curves and then undo’s the
// 	transform from the Alias Edit menu, the ::execute() command will 
//	be called and the curves redrawn properly because of the dag
//	modification handler.
//
{
printf("genericCmd::undo() called\n");
	return kOkay;
}
int genericCmd::listModifiedDagNodes( const AlNotifyDagNode *dagMod, AlObject *obj )
//
//	This routine should call dagMod->notify on every dag node that might
//	be affected if obj is modified.
//	In our example, if one of the constructor is modified, we
//	call the notify() method on the targets of the command.
//
{
printf("genericCmd::listModifiedDagNodes() called\n");
	
	if ( dagMod == NULL || obj == NULL )
		return -1;
		
	if ( AlAreEqual( obj, firstDagObject ) || AlAreEqual( obj, secondDagObject ) )
	{
		dagMod->notify( firstLineDag );
		dagMod->notify( secondLineDag );
	}
	return -1;
}
statusCode genericCmd::retrieveWire( AlInput *input )
//
//	Handler called by the Alias retrieve code for the construction
//	history objects.
//
{
printf("genericCmd::retrieveWire()\n");
	// Replace the old pointers with the newly relocated ones.  The
	// order of resolving must be the same as the declare when
	// we store.
	AlObject *objDag  = input->resolveObject();
	AlObject *objDag2 = input->resolveObject();
	AlObject *objDag3 = input->resolveObject();
	AlObject *objDag4 = input->resolveObject();
	
	if ( !objDag || ! objDag2 || !objDag3 || !objDag4 )
		return sFailure;
	
	// If a pointer was not resolved, then NULL is returned
	//
	// This can happen if the geometry has been deleted when
	// the plug-in is not loaded.
	// Alternatively, we could have just returned sSuccess.
	// When our command is executed, it will be invalid and so it will be
	// deleted.
	firstDagObject  = objDag->asCurveNodePtr(); 
	secondDagObject = objDag2->asCurveNodePtr();
	firstLineDag    = objDag3->asCurveNodePtr();
	secondLineDag   = objDag4->asCurveNodePtr();
	if ( !firstDagObject || !secondDagObject || !firstLineDag || !secondLineDag  )
		return sFailure;
		
	// Test info;
	if ( charData )
		delete charData;
	int i;
	if ( ( charData = input->resolveData( AlData::kDataChar, kCharId )) == NULL )
		return sFailure;
	printf("char data <%s>\n",charData->asCharPtr());	// Null terminated string.
		
	if ( intData )
		delete intData;
	if ( ( intData = input->resolveData( AlData::kDataInt, kIntId ) ) == NULL )
		return sFailure;
	const int *idata = intData->asIntPtr();
	printf("int data <");
	for ( i = 0; i< intData->count(); i++ )
		printf("%d ",idata[i]);
	printf(">\n");
	
	if ( doubleData )
		delete doubleData;
	if ( ( doubleData = input->resolveData( AlData::kDataDouble, kDoubleId ) ) == NULL )
		return sFailure;
	printf("double data <");
	const double *ddata = doubleData->asDoublePtr();
	for ( i = 0; i< doubleData->count(); i++ )
		printf("%g ",ddata[i]);
	printf(">\n");
	
	return sSuccess;
}
statusCode genericCmd::storeWire( AlOutput *output )
//
//	This routine is the handler called by the Alias store code so
//	that it can get a pointer to the construction history plug-ins
//	data.
//
{
printf("genericCmd::storeWire()\n");
	if ( output == NULL )
		return sFailure;
	// Declare all of our references to data so that we can get them back
	// on retrieval.  We are telling Alias to keep track of these
	// pointers in the wire file.
	output->declareObject( firstDagObject );
	output->declareObject( secondDagObject );
	output->declareObject( firstLineDag );
	output->declareObject( secondLineDag );
	// Test info
	AlData *data1 = new AlData;;
	char *cdata = "Save this data.";
	int count = strlen( cdata ) + 1;
	if ( data1->create( kCharId, cdata, count ) != sSuccess )
		return sFailure;
	if ( output->declareData( data1 ) != sSuccess )
		return sFailure;
	AlData *data2 = new AlData;
	int idata[10] = { 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 };
	count = 10;
	if ( data2->create( kIntId, idata, count ) != sSuccess )
		return sFailure;
	if ( output->declareData( data2 ) != sSuccess )
		return sFailure;
	AlData *data3 = new AlData;;
	double ddata[9] = { 10.1, 11.1, 12.1, 13.1, 14.2, 15.1, 16.1, 17.1, 18.1 };
	count = 9;
	if ( data3->create( kDoubleId, ddata, count ) != sSuccess )
		return sFailure;
	if ( output->declareData( data3 ) != sSuccess )
		return sFailure;
	return sSuccess;
}
statusCode genericCmd::set( AlDagNode *firstDag, AlDagNode *secondDag )
//
//	Our helper function for setting the cmdData constructors.
//
{
	if ( firstDag == NULL || secondDag == NULL )
		return sFailure;
		
	firstDagObject = (AlCurveNode *) firstDag->copyWrapper();
	secondDagObject = (AlCurveNode *) secondDag->copyWrapper();
	
	requireStrongValidity = FALSE;
	
	return sSuccess;
}
//
//	End command definition
//
//
//	Begin command invocation (the UI chunk of the code) 
//
AlUserCommand *allocLinkObjectCmd()
//
//	Allocate & return a new command.  This function will be passed
//	to the AlCommand::add() routine
//
{
	return new genericCmd;
}
void do_add_cmd( AlCurveNode *firstDag, AlCurveNode *secondDag )
{
	AlCommand::setDebug( TRUE );	// Static member function call
	AlCommand cmd;
	if( sSuccess == cmd.create( CMD_NAME ) )
	{
		genericCmd *g_cmd = (genericCmd *)cmd.userCommand()->asDerivedPtr();
			g_cmd->set( firstDag, secondDag );
			if( cmd.execute() == 0 )
				cmd.install();
			else
				cmd.deleteObject();
	}
}
//
//	Procedure to find two picked curve nodes and pass them to the
//	construction history command so that they can be used as the
//	constructors of the command.
//
void do_linkObject()
{
	AlObject *firstPickedItem, *secondPickedItem;
	firstPickedItem = NULL;
	secondPickedItem = NULL;
	
	for(	statusCode stat = AlPickList::firstPickItem();
			stat == sSuccess;
			stat = AlPickList::nextPickItem() )
	{
		AlObject *pickedItem = AlPickList::getObject();
		if( pickedItem )
		{
			if( pickedItem->asCurveNodePtr() )
			{
				if ( firstPickedItem == NULL )
					firstPickedItem = pickedItem->copyWrapper();
				else if ( secondPickedItem == NULL )
					secondPickedItem = pickedItem->copyWrapper();
			}
			delete pickedItem;
		}
	}
	
	if ( firstPickedItem && secondPickedItem )
	{
		do_add_cmd( firstPickedItem->asCurveNodePtr(), secondPickedItem->asCurveNodePtr() );
	}
	else
		printf("Failed to get the two picked curve nodes.\n");
		
	if ( firstPickedItem )
		delete firstPickedItem;
	if ( secondPickedItem )
		delete secondPickedItem;
}
static AlFunctionHandle h;
static AlMomentaryFunction hFunc;
extern "C"
PLUGINAPI_DECL int plugin_init( const char *dirName )
{
	AlUniverse::initialize( kZUp );
	//
	// Create a new construction history command
	//
	
	if ( AlCommand::add(  allocLinkObjectCmd, CMD_NAME ) != sSuccess )
	{
		AlPrintf( kPrompt, "The linkObject plug-in failed to install.\n");
		return 1;
	}
	if ( hFunc.create( do_linkObject ) != sSuccess )
		return 1;
	if ( h.create( "linkObject command", &hFunc ) != sSuccess )
		return 1;
		
	if ( h.setAttributeString( "linkObject plugin cmd" ) != sSuccess )
		return 1;
		
	if ( h.setIconPath( makeAltPath( dirName, NULL ) ) != sSuccess )
		return 1;
		
	if ( h.appendToMenu( "mp_objtools" ) != sSuccess )
		return 1;
	AlPrintf( kPrompt, "linkObject installed on Palette ’Object Edit’");
	return 0;
}
extern "C"
PLUGINAPI_DECL int plugin_exit( void )
{
	(void) AlCommand::remove(CMD_NAME );
	(void) h.deleteObject();
	(void) hFunc.deleteObject();
	
	// A redraw is required to ensure history
	// is no longer displayed for the plug-in’s
	// entities.
	AlUniverse::redrawScreen( kRedrawAll );
	// do nothing
	return 0;
}
//
// Helper functions.
//
static statusCode firstPosition( AlObject *obj, double& x, double& y, double& z )
//
//	A simple function for returning the x,y,z values of the first CV.
//
{
	AlCurveNode *cnode = NULL;
	AlCurve *curve = NULL;
	AlCurveCV *cv = NULL;
	statusCode result = sFailure;
	
	if ( ( cnode = obj->asCurveNodePtr()) != NULL )
	{
		curve = cnode->curve();
		if ( curve != NULL )
		{
			cv = curve->firstCV();
			if ( cv != NULL )
			{
				double w;
				if ( cv->worldPosition( x, y, z, w ) == sSuccess )
					result = sSuccess;	
			}
		}
	}
	
	// The cnode wrapper is really the same as obj which is the
	// same as one of the constructors of the command so do not
	// delete it.
	if ( curve )
		delete curve;
	if ( cv )
		delete cv;
		
	return result;
}
static statusCode lastPosition( AlObject *obj, double& x, double& y, double& z )
//
//	A simple function for returning the x,y,z values of the last CV.
//
{
	AlCurveNode *cnode = NULL;
	AlCurve *curve = NULL;
	AlCurveCV *cv = NULL;
	statusCode result = sFailure;
	if ( ( cnode = obj->asCurveNodePtr()) != NULL )
	{
		curve = cnode->curve();
		if ( curve != NULL )
		{
			int numCVs = curve->numberOfCVs();
			cv = curve->getCV( numCVs -1 );
			if ( cv != NULL )
			{
				double w;
				if ( cv->worldPosition( x, y, z, w ) == sSuccess )
					result = sSuccess;	
			}
		}
	}
	// The cnode wrapper is really the same as obj which is the
	// same as one of the constructors of the command so do not
	// delete it.	
	if ( curve )
		delete curve;
	if ( cv )
		delete cv;
		
	return result;
}
static statusCode createLine( AlCurveNode *&cp, double a[3], double b[3] )
//
//	A simple function for creating a line between points a and b.  The
//	curve node created is returned in the ’cp’ parameter.
//
{
	AlCurveNode *cnode = NULL;
	AlCurve *curve = NULL;
	statusCode result = sFailure;
	curve = new AlCurve;
	if ( curve )
	{
		if ( curve->createLine( a, b ) == sSuccess )
		{
			cnode = new AlCurveNode;
			if ( cnode )
			{
				if ( cnode->create( curve ) == sSuccess )
				{
					cp = cnode;
					result = sSuccess;
				}
			}
		}
	}
	if ( curve )
		delete curve;
		
	return result;
}
//
//	Function for updating the position of the line.
//
static void updateLinePosition( AlCurveNode *curveNode, double x, double y, double z, double x2, double y2, double z2 )
{
	if ( curveNode == NULL )
		return;
		
	AlCurve *curve = curveNode->curve();
	if  ( curve == NULL )
		return;
		
	AlAttributes *attr = curve->firstAttribute();
	if ( attr == NULL )
		return;
		
	AlLineAttributes* lineAttr = attr->asLineAttributesPtr();
	if ( lineAttr )
	{
		lineAttr->setStartPoint( x, y, z );
		lineAttr->setEndPoint( x2, y2, z2 );
	}
	
	delete curve;
	delete attr;
}