//==============================================================================
void EndEffector::copy(const EndEffector& _otherEndEffector)
{
  if(this == &_otherEndEffector)
    return;

  setState(_otherEndEffector.getEndEffectorState());
  setProperties(_otherEndEffector.getEndEffectorProperties());
}

//==============================================================================
EndEffector::EndEffector(BodyNode* _parent, const PropertiesData& _properties)
  : Entity(ConstructFrame),
    Frame(_parent, ""),
    FixedFrame(_parent, "", _properties.mDefaultTransform),
    TemplatedJacobianNode<EndEffector>(_parent)
{
  setProperties(_properties);
}

// Set velocities, with a dialog
void
ParameterPattern::
setVelocities(QMainWindow *parent,
              EventSelection *selection,
              int normVelocity)
{
    setProperties(parent, selection, Note::EventType,
                  &ParameterPattern::VelocityPatterns, normVelocity);
}

void radiationWallPatch::updateProperties(const dictionary& newDict)
{
    //- the main properties should be updated first
    updateBoundaryProperties(newDict);

    propsDict_ = newDict.subDict(typeName + "Properties");

    setProperties();
}

void JniManager::toProcessRequest(jobject obj, MonoObject* processRequest)
{
    JNIEnv* env = getEnv();

    MonoDomain* monoDomain = getMonoDomain();

    string c_assemblyName = typeConverter->convertToC<string>(env, env->CallObjectMethod(obj, getAssemblyName, "()Ljava/lang/String;"));
    string c_assemblyPath = typeConverter->convertToC<string>(env, env->CallObjectMethod(obj, getAssemblyPath, "()Ljava/lang/String;"));
    string c_methodName = typeConverter->convertToC<string>(env, env->CallObjectMethod(obj, getMethodName, "()Ljava/lang/String;"));

    MonoString* assemblyName = mono_string_new(monoDomain, c_assemblyName.c_str());
    MonoString* assemblyPath = mono_string_new(monoDomain, c_assemblyPath.c_str());
    MonoString* methodName = mono_string_new(monoDomain, c_methodName.c_str());
    bool fullTrust = env->CallBooleanMethod(obj, getFullTrust);
    bool isSingleton = env->CallBooleanMethod(obj, getIsSingleton);
    bool log = env->CallBooleanMethod(obj, getLog);
    bool notifyEvents = env->CallBooleanMethod(obj, getNotifyEvents);

    MonoObject* exception = NULL;

    void* args[1];
    args[0] = assemblyName;
    mono_runtime_invoke(setAssemblyNameField, processRequest, args, &exception);

    args[0] = assemblyPath;
    mono_runtime_invoke(setAssemblyPathField, processRequest, args, &exception);

    args[0] = methodName;
    mono_runtime_invoke(setMethodNameField, processRequest, args, &exception);

    args[0] = &fullTrust;
    mono_runtime_invoke(setFullTrustField, processRequest, args, &exception);

    args[0] = &log;
    mono_runtime_invoke(setLogField, processRequest, args, &exception);

    args[0] = &isSingleton;
    mono_runtime_invoke(setIsSingletonField, processRequest, args, &exception);

    args[0] = &notifyEvents;
    mono_runtime_invoke(setNotifyEventsField, processRequest, args, &exception);

    if (exception)
    {
        const char* message = mono_string_to_utf8(mono_object_to_string(exception, NULL));
        throwException(message);
    }

    jobject javaMethodArguments = env->CallObjectMethod(obj, getMethodArguments);

    setProperties(env, javaMethodArguments, addMethodArgumentsProperty, processRequest);
    //request->MethodArguments = typeConverter->convertToC<Dictionary<String^, Object^>^>(env, env->CallObjectMethod(obj, getMethodArguments));
    //request->InboundProperties = typeConverter->convertToC<Dictionary<String^, Object^>^>(env, env->CallObjectMethod(obj, getInboundProperties));
    //request->InvocationProperties = typeConverter->convertToC<Dictionary<String^, Object^>^>(env, env->CallObjectMethod(obj, getInvocationProperties));
    //request->OutboundProperties = typeConverter->convertToC<Dictionary<String^, Object^>^>(env, env->CallObjectMethod(obj, getOutboundProperties));
    //request->SessionProperties = typeConverter->convertToC<Dictionary<String^, Object^>^>(env, env->CallObjectMethod(obj, getSessionProperties));
}

ModelEntityItem::ModelEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) :
        EntityItem(entityItemID, properties) 
{ 
    _type = EntityTypes::Model;     
    setProperties(properties, true);
    _lastAnimated = usecTimestampNow();
    _jointMappingCompleted = false;
    _color[0] = _color[1] = _color[2] = 0;
}

	bool DVBC::tune(int streamID, int feFD, const input::dvb::FrontendData &frontendData) {
		SI_LOG_INFO("Stream: %d, Start tuning process for DVB-C(2)...", streamID);

		// Now tune by setting properties
		if (!setProperties(feFD, frontendData)) {
			return false;
		}
		return true;
	}

EntityItem::EntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) {
    _type = EntityTypes::Unknown;
    _lastEdited = 0;
    _lastEditedFromRemote = 0;
    _lastEditedFromRemoteInRemoteTime = 0;
    _lastUpdated = 0;
    _created = properties.getCreated();
    initFromEntityItemID(entityItemID);
    setProperties(properties, true); // force copy
}

void RedSpreadBoom::shoot(int angle, D3DXVECTOR3 startPoint, int ally, float scaleX)
{
	setProperties(angle, ally, scaleX);

	D3DXVECTOR3 velo = D3DXVECTOR3(RED_SPREAD_MOVE_SPEED * Default::cos(DEGREE_TO_RADIAN(angle)),
									RED_SPREAD_MOVE_SPEED * Default::sin(DEGREE_TO_RADIAN(angle)),
									0.0F);

	shoot(velo, startPoint, ally, scaleX);
}

// our non-pure virtual subclass for now...
SphereEntityItem::SphereEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) :
        EntityItem(entityItemID, properties) 
{ 
    _type = EntityTypes::Sphere;
    setProperties(properties);
    // NOTE: _volumeMultiplier is used to compute volume:
    // volume = _volumeMultiplier * _dimensions.x * _dimensions.y * _dimensions.z
    // The formula below looks funny because _dimension.xyz = diameter rather than radius.
    _volumeMultiplier *= PI / 6.0f;
}

Spaceship::Spaceship()
{
	std::cout << "Spaceship() noparam-constructor called." << std::endl;
	setProperties("Default Name", Vector3D(0.0f, 0.0f,0.0f), Vector3D(0.0f, 0.0f,0.0f), 100, 0);
	//m_name = "Default Name";
	//m_position = Vector3D(0.0f,0.0f,0.0f);
	//m_velocity = Vector3D(0.0f,0.0f,0.0f);
	//m_fuelLevel = 100;
	//m_damage = 0;
}

//==============================================================================
EndEffector::EndEffector(BodyNode* parent, const BasicProperties& properties)
  : Entity(ConstructFrame),
    Frame(parent),
    FixedFrame(parent, properties.mDefaultTransform),
    common::EmbedPropertiesOnTopOf<
        EndEffector, detail::EndEffectorProperties,
        detail::EndEffectorCompositeBase>(
      std::make_tuple(parent, properties.mDefaultTransform), common::NoArg)
{
  setProperties(properties);
}

void processSubIntegrators(QDomDocument &doc, const Integrator *integrator, QDomElement integratorNode) {
	int idx = 0;
	while (integrator->getSubIntegrator(idx) != NULL) {
		const Integrator *childIntegrator = integrator->getSubIntegrator(idx);
		QDomElement childIntegratorNode = doc.createElement("integrator");
		setProperties(doc, childIntegratorNode, childIntegrator->getProperties());
		integratorNode.appendChild(childIntegratorNode);
		processSubIntegrators(doc, childIntegrator, childIntegratorNode);
		idx++;
	}
}

//==============================================================================
ShapeNode::ShapeNode(BodyNode* bodyNode, const BasicProperties& properties)
  : Entity(ConstructFrame),
    Frame(bodyNode),
    FixedFrame(bodyNode),
    detail::ShapeNodeCompositeBase(
      std::make_tuple(bodyNode, properties.mRelativeTf),
      bodyNode, properties)
{
  setProperties(properties);
  mAmShapeNode = true;
}

void PropagateRemoteMkdir::slotMkcolJobFinished()
{
    _propagator->_activeJobs--;

    Q_ASSERT(_job);

    qDebug() << Q_FUNC_INFO << _job->reply()->request().url() << "FINISHED WITH STATUS"
             << _job->reply()->error()
             << (_job->reply()->error() == QNetworkReply::NoError ? QLatin1String("") : _job->reply()->errorString());

    QNetworkReply::NetworkError err = _job->reply()->error();
    _item->_httpErrorCode = _job->reply()->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();

    if (_item->_httpErrorCode == 405) {
        // This happens when the directory already exists. Nothing to do.
    } else if (err != QNetworkReply::NoError) {
        SyncFileItem::Status status = classifyError(err, _item->_httpErrorCode,
                                      &_propagator->_anotherSyncNeeded);
        auto errorString = _job->reply()->errorString();
        if (_job->reply()->hasRawHeader("OC-ErrorString")) {
            errorString = _job->reply()->rawHeader("OC-ErrorString");
        }
        done(status, errorString);
        return;
    } else if (_item->_httpErrorCode != 201) {
        // Normally we expect "201 Created"
        // If it is not the case, it might be because of a proxy or gateway intercepting the request, so we must
        // throw an error.
        done(SyncFileItem::NormalError, tr("Wrong HTTP code returned by server. Expected 201, but received \"%1 %2\".")
             .arg(_item->_httpErrorCode).arg(_job->reply()->attribute(QNetworkRequest::HttpReasonPhraseAttribute).toString()));
        return;
    }

    _item->_requestDuration = _job->duration();
    _item->_responseTimeStamp = _job->responseTimestamp();
    _item->_fileId = _job->reply()->rawHeader("OC-FileId");

    if (_item->_fileId.isEmpty()) {
        // Owncloud 7.0.0 and before did not have a header with the file id.
        // (https://github.com/owncloud/core/issues/9000)
        // So we must get the file id using a PROPFIND
        // This is required so that we can detect moves even if the folder is renamed on the server
        // while files are still uploading
        _propagator->_activeJobs++;
        auto propfindJob = new PropfindJob(_job->account(), _job->path(), this);
        propfindJob->setProperties(QList<QByteArray>() << "getetag" << "http://owncloud.org/ns:id");
        QObject::connect(propfindJob, SIGNAL(result(QVariantMap)), this, SLOT(propfindResult(QVariantMap)));
        QObject::connect(propfindJob, SIGNAL(finishedWithError()), this, SLOT(propfindError()));
        propfindJob->start();
        _job = propfindJob;
        return;
    }
    success();
}

LineEntityItem::LineEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) :
    EntityItem(entityItemID) ,
    _lineWidth(DEFAULT_LINE_WIDTH),
    _pointsChanged(true),
    _points(QVector<glm::vec3>(0))
{
    _type = EntityTypes::Line;
    setProperties(properties);
    
    
}

PeriodicFunction::PeriodicFunction( PropertySettings& prop )
    : OutputFunction() {
	phasev = 0.0;
	spanv = 1.0;
	amplitudev = 1.0;
	addProperty( "phase", Variant::t_real, this, &SawtoothFunction::phase, &SawtoothFunction::setPhase );
	addProperty( "span", Variant::t_real, this, &SawtoothFunction::span, &SawtoothFunction::setSpan );
	addProperty( "amplitude", Variant::t_real, this, &SawtoothFunction::amplitude, &SawtoothFunction::setAmplitude );
	setProperties( prop );
	//setTypename( "PeriodicFunction" ); // is abstract
}

Exercise::Exercise(const QString &name, const QString &description, const QString &titleFilename, const QString &figureFilename, QObject *parent)
    :QObject(parent),
     m_id(0),
     m_name(name),
     m_description(description),
     m_titleFilename(titleFilename),
     m_figureFilename(figureFilename)
{
    setProperties();

}

void FireCircle::shoot(int angle, D3DXVECTOR3 startPoint, int ally, float scaleX)
{
	setProperties(angle, ally, scaleX);

	shoot(D3DXVECTOR3(BULLET_FIRE_CIRCLE_MOVE_SPEED * Default::cos(DEGREE_TO_RADIAN(angle)),
		BULLET_FIRE_CIRCLE_MOVE_SPEED * Default::sin(DEGREE_TO_RADIAN(angle)),
		0.0F),
		startPoint,
		ally,
		scaleX);
}

void B011001::initialize()
{
	m_Obj = gluNewQuadric();
	gluQuadricTexture(m_Obj, GL_TRUE);
	m_Earth = loadTextureBMP("EarthTexture.bmp");

	glMatrixMode(GL_MODELVIEW);	

	setProperties();

	return ;
}