//////////////////////////////////////////////////////////////////////
//  JTestObj.cpp - a minimal external module for NeatTools
//                     generated by Rob Salgado's ModuleMaker
//
//  It has two left-inputs (JInteger, JString) and 
//         two outputs: a right-output JInteger and a bottom-output JString.  
//  The color of module is changed by the JInteger-input.
//  The text drawn on the lower-right corner of the module is changed by 
//         the JString-input.
//
//
//////////////////////////////////////////////////////////////////////

#include "JTestObj.h"
#include "JLinkObj.h"
///
#include "JInteger.h"
#include "JIntegerData.h"
#include "JIntegerProperty.h"
#include "JIntegerListProperty.h"
///
//#include "JRealData.h"
//#include "JRealProperty.h"
///
#include "JString.h"
#include "JStringData.h"
#include "JStringProperty.h"
//
//#include "JBytesData.h" 
//
#include <stdio.h>
#include <malloc.h>
#include <string.h>
//#include <math.h>


// ------------------------------------------------------------------------ //
//
//  Register() registers the module with NeatTools
//
char* theJTestObj = JTestObj().Register();

// ------------------------------------------------------------------------ //
//
void JTestObj::writeContent(JOutputStream& os) {
    
    //call base-class writeContent() first
    JAddObj::writeContent(os);  
  
    //write a table of "persistent variables", 
    //which comprise the "state" of this instance of the module

    //  format:  
    //  put_x_(os, INTERNAL_VARIABLE_TAG, PERSISTENT_VARIABLE)

 
    putInteger(os, "persistentInteger1", persistentInteger1);

    //use JObject for JStrings
    putObject(os, "persistentString1", persistentString1);

}

// ------------------------------------------------------------------------ //
//
void JTestObj::readContent(JDictionary& dict) {
	#ifdef COUT 
	ofstream fout("C:\\_Desktop\\log.txt",ios::app);
	fout <<"(START READ CONTENT)"<<endl;
	#endif
    //apparently called soon after constructor
    //used to rebuild the "persistent state"

    //call base-class readContent() first
    JAddObj::readContent(dict); 
  
    //read a table of "persistent variables", 
    //which comprise the "state" of this instance of the module

    persistentInteger1= getInteger(dict, "persistentInteger1");

    //use JObject for JStrings
    JObject *obj;
    obj = getObject(dict, "persistentString1");
    if (obj) { persistentString1 = *(JString*)obj;}
        ///if (obj) test avoids NULL pointer problem
	#ifdef COUT 
	fout <<"(END READ CONTENT)"<<endl;
	#endif
}

// ------------------------------------------------------------------------ //
//
//  className() returns the name of the module
//
const char* JTestObj::className() const { return "JTestObj";}

// ------------------------------------------------------------------------ //
//
//  clone() is used to instantiate copies of the module
//
JObject* JTestObj::clone() const { return new JTestObj(*this);}

// ------------------------------------------------------------------------ //
//
//  Constructor method
//
JTestObj::JTestObj() {

	count++;
	name++;
		persistentInteger1=name;
	#ifdef COUT 
	ofstream fout("C:\\_Desktop\\log.txt",ios::app);
	fout <<"(There are now "<<count<<")----Constructor: You are named "<<persistentInteger1<<endl;
	#endif
                        //making a clever use of enums defined the header file...
    igm = NUMBER_OF_INPUTS;     // tell NeatTools the number of inputs (declared in JModuleObj)
    ogm = NUMBER_OF_OUTPUTS;    // tell NeatTools the number of outputs (declared in JModuleObj)

    doRepaint = false;

    moduleColor=JColor::green.brighter();   //see JColor.h for definitions

//    persistentInteger1=0;   //initial value of persistentInteger1
    persistentString1=JString("x"); //initial value of persistentString1

}


// ------------------------------------------------------------------------ //
//
//  Copy Constructor method
//
JTestObj::JTestObj(const JTestObj& src):JAddObj(*(JAddObj*)& src) 
{
	count++;
	name++;
///          use your own copy constructor
///          and NOT the compiler-generated one
///          to do memberwise-copy of arrays

	persistentInteger1=name;


	#ifdef COUT 
	ofstream fout("C:\\_Desktop\\log.txt",ios::app); 
	fout <<"(There are now "<<count<<")----COPY Constructor: From "<<src.persistentInteger1<<". You are named "<<persistentInteger1<<endl;
	#endif

} 

JTestObj::~JTestObj(void)
{
	count--;
///          use your own copy constructor
///          and NOT the compiler-generated one
///          to do memberwise-copy of arrays
	#ifdef COUT 
	ofstream fout("C:\\_Desktop\\log.txt",ios::app); 
	fout <<"(There are now "<<count<<")----D E S T R U C T O R: You were named "<<persistentInteger1<<endl;
	#endif

} 

// ------------------------------------------------------------------------ //
//
//  paint() method is called by the system
//
void JTestObj::paint(JGraphics g, double dx, double dy, 
                                JRegion& rgn, double scale) {
  //determine the size or extent of the module
  JRect rect = getIExtent(dx, dy, scale);
 
 //the next "write" to screenbuffer g is the appropriate color
  g.setJColor(moduleColor);

  //draw a box with a 3D-look that fills the module extent
  g.fill3DRect(rect.x, rect.y, rect.width, rect.height, 3);

  //make a new rectangle in the lower right corner
  //JRect textrect(rect.x+(int)((double)rect.width/2.0), rect.y+(int)((double)rect.height/2.0), (int)((double)rect.width/2.0), (int)((double)rect.height/2.0) );
  g.setJColor(JColor::black.brighter());
  drawText(g,JInteger(persistentInteger1).toJString(),rect);


    //some examples of graphics
    //
    //int xx[] = { rect.x, rect.x+rect.width-6, rect.x, rect.x};
    //int yy[] = { rect.y, rect.y+(rect.height-1)/2, rect.y+rect.height-1, rect.y};
    //g.drawPolygon(xx, yy, 4);
    //g.drawOval(rect.x+rect.width-5, rect.y+(rect.height-1)/2-2, 5, 5);
    //g.drawLine(rect.x+rect.width, rect.y, rect.x, rect.y+rect.height);
    //drawText(g,label,rect);


}

// ------------------------------------------------------------------------ //
//
//
int JTestObj::inputType(int n) { 
    switch(n)
    {
        case INTEGER_INPUT:
            return JIntegerData::id;
        case STRING_INPUT:
        default:
            return JStringData::id;
    }

    ///for JBytes:
    //  return JBytesData::id;
    ///for JString:
    //  return JStringData::id;
    ///for JIntegers:
    //  return JIntegerData::id;
}

int JTestObj::outputType(int n) { 
    switch(n)
    {
        case INTEGER_OUTPUT:
            return JIntegerData::id;
        case STRING_OUTPUT:
        default:
            return JStringData::id;
    }

    ///for JBytes:
    //  return JBytesData::id;
    ///for JString:
    //  return JStringData::id;
    ///for JIntegers:
    //  return JIntegerData::id;
}


boolean JTestObj::inputAllowed(int n){ 
    return !inputSet(n).last(); //accept only one link per input port
    //return true;      //accept as many links as needed
}
// ------------------------------------------------------------------------ //
boolean JTestObj::outputAllowed(int n){ 
    //return !outputSet(n).last();  //accept only one link per output port
    return true;        //accept as many links as needed
}

// ------------------------------------------------------------------------ //
JString JTestObj::inputTag(int n) {
    char* tag[] = { "input1", "input2"};    //label inputs
    //char* tag[] = { "input"}; //label all inputs "input"

    return tag[n];
}
// ------------------------------------------------------------------------ //
JString JTestObj::outputTag(int n) {    
    char* tag[] = { "output1", "output2"};  //label outputs
    //char* tag[] = { "output"};    //label all outputs "output"

    return tag[n];
}
// ------------------------------------------------------------------------ //


// ------------------------------------------------------------------------ //
int JTestObj::inputFace(int n) { 
    return LEFT;        //all inputs on the leftFace
}
// ------------------------------------------------------------------------ //
int JTestObj::outputFace(int n) { 
    switch (n)
    {
        case INTEGER_OUTPUT:    
            return RIGHT;
        case STRING_OUTPUT:
        default:    
            return BOTTOM;
    }
}

// ------------------------------------------------------------------------ //
//  inputArea, outputArea   defines the area that a port will accept connections
//      leftArea(int portNumber,
//              int whichPortSlotInThisArea,
//              int howManyPortSlotsInThisArea,
//              double whereToStartAreaFraction (default 0.25),
//              double widthAreaFraction (default is 0.50)
//              double perpendicularReciprocalFactor (default is 6)     )
//ex:
//      return leftArea(n, 0, 1);           //port-0 is alone on LEFT
//

JFRect JTestObj::inputArea(int n) {
    return leftArea(n, 0, 2);   //two inputs on the leftArea, starting with 0
}
// ------------------------------------------------------------------------ //
JFRect JTestObj::outputArea(int n) {
    switch (n)
    { 
        case INTEGER_OUTPUT:
            return rightArea(n, INTEGER_OUTPUT, 1);
            //one output on the rightArea, starting with INTEGER_OUTPUT

        case STRING_OUTPUT:
        default:
            return bottomArea(n, STRING_OUTPUT, 1, 0.66, 0.166, 3);
            //one output on the bottomArea, starting with STRING_OUTPUT
            //starting at a position (2/3) of the module WIDTH
            //  use a region of size (1/8) of the module WIDTH
            //  with a depth of size 1/(3) of the module HEIGHT
    }
}

// ------------------------------------------------------------------------ //
// for fine-tuned positioning (for possibly multiple links) with the areas

JFPoint JTestObj::inputPoint(int n, JLinkObj& link) { 
    return leftPoint(n, link, 0, 2);    
}
// ------------------------------------------------------------------------ //
JFPoint JTestObj::outputPoint(int n, JLinkObj& link) { 
    switch (n)
    {
        case INTEGER_OUTPUT:
            return rightPoint(n, link, INTEGER_OUTPUT, 1);
        case STRING_OUTPUT:
        default:
            return bottomPoint(n, link, STRING_OUTPUT, 1, .66, .166);
            //one output on the bottomArea, starting with STRING_OUTPUT
            //starting at a position (2/3) of the module WIDTH
            //  use a region of size (1/6) of the module WIDTH.
            //  the links placed in this area will be spaced uniformly
    }
}



// ------------------------------------------------------------------------ //
//
// engine() is called when an input-event is detected
//
void JTestObj::engine(int n, JLinkObj& link) {

    //if you have more than one input, 
    //you may wish to test "n" to determine which input-port was pinged,
    //then act accordingly.

    switch(n)
    {
        case INTEGER_INPUT:
            //for JIntegers
            int nv;
            link.access(JIntegerData(nv)); //ask module-of-input-link for JInteger

            if (persistentInteger1!=nv) {   //update and broadcast changes only
                moduleColor=JColor(nv,0);
                persistentInteger1=nv;
                repaint();
                //broadcast(0); //ping output-port-0 
                broadcast(INTEGER_OUTPUT); //ping INTEGER_OUTPUT...because it might want to know
            }
            break;

        case STRING_INPUT:
        default:

            //for JStrings
            JString nstr;
            link.access(JStringData(nstr)); //ask module-of-input-link for JString

            if (persistentString1!=nstr) {  //update and broadcast changes only
                persistentString1=nstr;
                repaint();
                //broadcast(1); //ping output-port-1 
                broadcast(STRING_OUTPUT); //ping STRING_OUTPUT...because it might want to know
            }
            break;
    

    }
}

// ------------------------------------------------------------------------ //
//
// access() may be called by an output-link engine() method 
//      when we do a broadcast()
//
void JTestObj::access(int n, JLinkObj& link, const JDataType& data) {

    switch(n)
    {
        case INTEGER_OUTPUT:

            ////How to return a JInteger
            INT(data)=persistentInteger1;
            break;

        case STRING_OUTPUT:
        default:

            ////How to return a JString
            JSTRING(data)=persistentString1;
            break;
            
            ////How to return a JBlock
            ////
            ////data.assign(  JBlock(*buffer)(0,numbytes)  );
            

            ////
            ////in general,
            ////give value (suitably casted) in response to my output ping

    }
            

}
        

// ------------------------------------------------------------------------ //
//
// getProperties() produces a list of properties
//
JArray JTestObj::getProperties() {
  JArray properties;

    //  format:  
    //  J_x_Property(PROPERTYSHEET_VARIABLE_TAG, PERSISTENT_VARIABLE)

    //IntegerProperties need a range to be specified
    //
    properties.append(
        JIntegerProperty("Persistent Integer #1", persistentInteger1, 1, 1000)
    );

    properties.append(
        JStringProperty("Persistent String #1", persistentString1)
    );

        //I think it's okay to use repeated labels as long as one does not
        //want to edit its property field   ///ROB
  return properties;
}

// ------------------------------------------------------------------------ //
//
// updateProperty() updates a given property, as specified by VARIABLE_LABEL
//
boolean JTestObj::updateProperty(JProperty& prop) {

  if (prop.getName() == JString("Persistent Integer #1")) {
      persistentInteger1 = ((JIntegerProperty*)&prop)->value;   //do update
        repaint();      //you might want to repaint()
        broadcast(INTEGER_OUTPUT); //ping INTEGER_OUTPUT...because it might want to know
      return true; //leave and announce that the property was found
  }

  if (prop.getName() == JString("Persistent String #1")) {
    persistentString1 = ((JStringProperty*)&prop)->value;   //do update
        repaint();      //you might want to repaint()
        broadcast(STRING_OUTPUT); //ping STRING_OUTPUT...because it might want to know
    return true;    //leave and announce that the property was found
  }

  return false; //leave and announce that the property was not found
}

// ------------------------------------------------------------------------ //