void DataChannel::setDefaultNameAndDescription() 
{
	String name;
	String description;
	switch (m_type)
	{
	case HEADSTAGE_CHANNEL: 
		name = "CH"; 
		description = "Headstage";
		break;
	case AUX_CHANNEL: 
		name = "AUX "; 
		description = "Auxiliar";
		break;
	case ADC_CHANNEL: 
		name = "ADC "; 
		description = "ADC";
		break;
	default: 
		setName("INVALID");
		setDescription("Invalid Channel");
		setIdentifier("invalid");
		return;
		break;
	}
	name += " p";
	name += String(getSourceNodeID()) + String(".") + String(getSubProcessorIdx());
	name += " n";
	name += String(getSourceTypeIndex());
	setName(name);
	setDescription(description + " data channel");
	setIdentifier("genericdata.continuous");
}
QASTAccessSpecifier::QASTAccessSpecifier(
        QAnnotatedTokenSet* tokenSet,
        QSourceLocation* cursorLocation,
        QSourceLocation* rangeStartLocation,
        QSourceLocation* rangeEndLocation,
        QASTNode *parent)

    : QASTNode("access", tokenSet, cursorLocation, rangeStartLocation, rangeEndLocation, parent){

    switch( clang_getCXXAccessSpecifier(tokenSet->cursor()) ){
    case CX_CXXInvalidAccessSpecifier :
        setIdentifier("invalid");
        break;
    case CX_CXXPrivate :
        setIdentifier("private");
        break;
    case CX_CXXPublic :
        setIdentifier("public");
        break;
    case CX_CXXProtected :
        setIdentifier("protected");
        break;
    }

}
Beispiel #3
0
FakePlayer::FakePlayer()
{
  setIdentifier("fake");
  addOption("interval", 50, "The time in mlsec between two tick");
  addOption("start", 0, "The start time in frame number");
  addOption("duration", 0, "The duration of the fake stream");
}
Beispiel #4
0
Branch::Branch(QPointF sp, QPointF ep, Branch* par, double iden)
{
    setPos(sp, ep);
    setParent(par);
    setThickness();
    setIdentifier(iden);
}
Beispiel #5
0
PVMModule::PVMModule() : InviwoModule() {
    setIdentifier("PVM");
    registerDataReader(new PVMVolumeReader());
    registerDataWriter(new PVMVolumeWriter());

    registerDataReader(new MPVMVolumeReader());
}
Beispiel #6
0
	NE_DLL NEExportable::Identifier::Identifier(const NETString& identifier_string_with_dot_delimiter)
		: NEObject()
	{
		release();

		setIdentifier(identifier_string_with_dot_delimiter);
	}
void Dialog::setTags(const char* localTag,
                     const char* remoteTag)
{
   mLocalTag = localTag;
   mRemoteTag = remoteTag;
   setIdentifier();
}
void Mp3tunesConfig::load()
{
    kDebug( 14310 ) << "load";
    KConfigGroup config = KGlobal::config()->group( "Service_Mp3tunes" );
    m_email = config.readEntry( "email", QString() );
    m_password = config.readEntry( "password", QString() );
    m_identifier = config.readEntry( "identifier", QString() );
    m_pin = config.readEntry( "pin", QString() );
    m_harmonyEmail = config.readEntry( "harmonyEmail", QString() );
    m_partnerToken = config.readEntry( "partnerToken", QString( "4895500420" ) );
    m_harmonyEnabled = config.readEntry( "harmonyEnabled", false );

    if( m_identifier.isEmpty() )
    {
        foreach( const QNetworkInterface &iface, QNetworkInterface::allInterfaces() )
        {
            QString addr = iface.hardwareAddress();
            if( addr != "00:00:00:00:00:00" ) {
                addr.remove( ':' );
                kDebug( 14310 ) << "Using iface \"" << iface.name() << " addr: " << addr;
                setIdentifier( addr + m_partnerToken );
                save();
                break;
            }
        }
void SpikeChannel::setDefaultNameAndDescription()
{
	String name;
	String description;
	switch (m_type)
	{
	case SINGLE: 
		name = "SE ";
		description = "Single electrode";
		break;
	case STEREOTRODE: 
		name = "ST "; 
		description = "Stereotrode";
		break;
	case TETRODE: 
		name = "TT ";
		description = "Tetrode";
		break;
	default: name = "INVALID "; break;
	}
	name += String(" p") + String(getSourceNodeID()) + String(".") + String(getSubProcessorIdx()) + String(" n") + String(getSourceTypeIndex());
	setName(name);
	setDescription(description + " spike data source");
	setIdentifier("spikesource");
}
Beispiel #10
0
Actor::Actor(const char * nFirst, const char * nLast)
{
	setName("actor");
	setNameFirst(nFirst);
	setNameLast(nLast);
	setIdentifier(ID_ACTOR);
	// setPrintChar('@');
	setStrength(25);
}
Beispiel #11
0
void EventChannel::setDefaultNameAndDescription()
{
	String name;
	switch (m_type)
	{
	case TTL: name = "TTL"; break;
	case TEXT: name = "TEXT"; break;
	case INT8_ARRAY: name = "INT8"; break;
	case UINT8_ARRAY: name = "UINT8"; break;
	case INT16_ARRAY: name = "INT16"; break;
	case UINT16_ARRAY: name = "UINT16"; break;
	case INT32_ARRAY: name = "INT32"; break;
	case UINT32_ARRAY: name = "UINT32"; break;
	case INT64_ARRAY: name = "INT64"; break;
	case UINT64_ARRAY: name = "UINT64"; break;
	default: 
		setName("INVALID");
		setDescription("Invalid channel");
		setIdentifier("invalid");
		return;
		break;
	}
	name += "p";
	name += String(getSourceNodeID()) + String(".") + String(getSubProcessorIdx());
	name += " n";
	name += String(getSourceTypeIndex());
	setName(name);
	if (m_type == TTL)
	{
		setDescription("TTL data input");
	}
	else if (m_type == TEXT)
	{
		setDescription("Text event");
	}
	else
	{
		if (m_length > 1)
			setDescription(name + " data array");
		else
			setDescription(name + " single value");
	}
	setIdentifier("genericevent");
}
Beispiel #12
0
void Brick::hit()
{
    if (identifier() == "HiddenBrick" && !isVisible()) {
        show();
        ++m_game->m_remainingBricks;
    } else if (identifier() == "MultipleBrick3") {
        setIdentifier("MultipleBrick2");
        // TODO: make a convenience function out of the following two
        m_game->addScore(qRound(m_game->m_dScore));
        m_game->m_dScore = BRICK_SCORE;
    } else if (identifier() == "MultipleBrick2") {
        setIdentifier("MultipleBrick1");
        m_game->addScore(qRound(m_game->m_dScore));
        m_game->m_dScore = BRICK_SCORE;
    } else if (identifier() == "ExplodingBrick") {
        explode();
    } else if (identifier() != "UnbreakableBrick") {
        forcedHit();
    }
}
Beispiel #13
0
QASTField::QASTField(
        QAnnotatedTokenSet *tokenSet,
        QSourceLocation* cursorLocation,
        QSourceLocation* rangeStartLocation,
        QSourceLocation* rangeEndLocation,
        QASTNode* parent)

    : QASTNode("field", tokenSet, cursorLocation, rangeStartLocation, rangeEndLocation, parent){

    // Get Identifier
    // --------------

    CXString id = clang_getCursorSpelling(tokenSet->cursor());
    setIdentifier(clang_getCString(id));

    // Get Field Type
    // ---------------

    CXType type           = clang_getCursorType(tokenSet->cursor());
    CXString typeSpelling = clang_getTypeSpelling(type);
    m_fieldType           = clang_getCString(typeSpelling);
    clang_disposeString(typeSpelling);

    // Determine field type
    // --------------------

    if ( type.kind == CXType_Unexposed || type.kind == CXType_Invalid || m_fieldType.contains("int") ){
        m_fieldType = "";

        bool doubleColonFlag = false;
        for ( QAnnotatedTokenSet::Iterator it = tokenSet->begin(); it != tokenSet->end(); ++it ){

            CXToken t              = (*it)->token().token;
            CXString tSpelling     = clang_getTokenSpelling(tokenSet->translationUnit(), t);
            const char* tCSpelling = clang_getCString(tSpelling);
            CXTokenKind tKind      = clang_getTokenKind(t);

            if ( tKind == CXToken_Identifier && std::string(clang_getCString(id)) == tCSpelling ){
                break;
            } else if ( tKind == CXToken_Punctuation && std::string("::") == tCSpelling ){
                doubleColonFlag = true;
                m_fieldType    += tCSpelling;
            } else if ( ( tKind == CXToken_Identifier || tKind == CXToken_Keyword ) &&
                        !m_fieldType.isEmpty() && !doubleColonFlag ){
                m_fieldType    += QString(" ") + tCSpelling;
            } else {
                doubleColonFlag = false;
                m_fieldType    += tCSpelling;
            }
        }
    }

    clang_disposeString(id);
}
// 14
void noElse(FILE* file, DynamicTable* symbols, Token token) {
	fprintf(file, "%s\tJP\t_then%d\n", label, top(ifs));
	fflush(file);

	strcpy(label, "_then");
	strcat(label, integerToString(auxiliar, pop(&ifs), 10));

	strcpy(auxiliar, "");

	if(!strcmp(token->type, "IDENTIFIER"))
		setIdentifier(file, symbols, token);
}
// Constructor
Dialog::Dialog(const char* dialogId,
               const char* callId,
               const char* localTag,
               const char* remoteTag,
               const char* direction)
{
   mId = dialogId;
   mCallId = callId;
   mLocalTag = localTag;
   mRemoteTag = remoteTag;
   mDirection = direction;
   setIdentifier();
}
Beispiel #16
0
<name>Module::<name>Module() : InviwoModule() {
    setIdentifier("<name>");
    
    // Add a directory to the search path of the Shadermanager
    //ShaderManager::getPtr()->addShaderSearchPath(InviwoApplication::PATH_MODULES, "<lname>/glsl");
    
    // Register objects that can be shared with the rest of inviwo here:
    
    // Processors
    // registerProcessor(<name>);
    
    // Properties
    // registerProperty(<name>Property);
    
    // Readers and writes
    // registerDataReader(new <name>Reader());
    // registerDataWriter(new <name>Writer());
    
    // Data converters
    // registerRepresentationConverter(new <name>Disk2RAMConverter());

    // Ports
    // registerPort(<name>Outport);
    // registerPort(<name>Inport);

    // PropertyWidgets
    // registerPropertyWidget(<name>PropertyWidgetQt, <name>Property, "Default");
    
    // Dialogs
    // registerDialog("<lname>", <name>DialogQt);
    
    // Other varius things
    // registerCapabilities(Capabilities* info);
    // registerData(Data* data);
    // registerDataRepresentation(DataRepresentation* dataRepresentation);
    // registerSettings(new SystemSettings());
    // registerMetaData(MetaData* meta);   
    // registerPortInspector(PortInspector* portInspector);
    // registerProcessorWidget(std::string processorClassName, ProcessorWidget* processorWidget);
    // registerDrawer(GeometryDrawer* renderer);
    // registerResource(Resource* resource);    
}
Beispiel #17
0
void Processor::deserialize(IvwDeserializer& d) {
    std::string identifier;
    d.deserialize("identifier", identifier, true);
    setIdentifier(identifier);  // Need to use setIdentifier to make sure we get a unique id.

    d.deserialize("InteractonHandlers", interactionHandlers_, "InteractionHandler");

    StandardIdentifier<Port> inportIdentifier;
    d.deserialize("InPorts", inports_, "InPort", inportIdentifier);
    d.deserialize("OutPorts", outports_, "OutPort", inportIdentifier);

    for (auto elem : inports_) {
        elem->setProcessor(this);
    }
    for (auto elem : outports_) {
        elem->setProcessor(this);
    }

    PropertyOwner::deserialize(d);
    MetaDataOwner::deserialize(d);
}
Beispiel #18
0
DebugRenderer::DebugRenderer() : QObject()
{
  setIdentifier("debug");
}
Action::Action( const std::string & identifier ) {
    setIdentifier(identifier);
}
Beispiel #20
0
Python3Module::Python3Module() : InviwoModule() , pyInviwo_(nullptr){
    setIdentifier("Python3");
    PythonExecutionOutputObservable::init();
}
Action::Action( const std::string & identifier,
                const std::string & parameter ) {
    setIdentifier(identifier);
    setParameter(parameter);
}
void Dialog::setDialogId(const char* dialogId)
{
   mId = dialogId;
   setIdentifier();
}
Beispiel #23
0
InviwoCore::InviwoCore() : InviwoModule() {
    setIdentifier("Core");
    // Register Converters
    registerRepresentationConverter(new VolumeDisk2RAMConverter());
    registerRepresentationConverter(new LayerDisk2RAMConverter());
    registerRepresentationConverter(new MeshDisk2RAMConverter());
    // Register MetaData
    registerMetaData(new BoolMetaData());
    registerMetaData(new IntMetaData());
    registerMetaData(new FloatMetaData());
    registerMetaData(new DoubleMetaData());
    registerMetaData(new StringMetaData());
    registerMetaData(new FloatVec2MetaData());
    registerMetaData(new FloatVec3MetaData());
    registerMetaData(new FloatVec4MetaData());
    registerMetaData(new DoubleVec2MetaData());
    registerMetaData(new DoubleVec3MetaData());
    registerMetaData(new DoubleVec4MetaData());
    registerMetaData(new IntVec2MetaData());
    registerMetaData(new IntVec3MetaData());
    registerMetaData(new IntVec4MetaData());
    registerMetaData(new UIntVec2MetaData());
    registerMetaData(new UIntVec3MetaData());
    registerMetaData(new UIntVec4MetaData());
    registerMetaData(new FloatMat2MetaData());
    registerMetaData(new FloatMat3MetaData());
    registerMetaData(new FloatMat4MetaData());
    registerMetaData(new DoubleMat2MetaData());
    registerMetaData(new DoubleMat4MetaData());
    registerMetaData(new DoubleMat3MetaData());
    registerMetaData(new VectorMetaData<2,float>());
    registerMetaData(new VectorMetaData<3,float>());
    registerMetaData(new VectorMetaData<4,float>());
    registerMetaData(new VectorMetaData<2,double>());
    registerMetaData(new VectorMetaData<3,double>());
    registerMetaData(new VectorMetaData<4,double>());
    registerMetaData(new VectorMetaData<2,int>());
    registerMetaData(new VectorMetaData<3,int>());
    registerMetaData(new VectorMetaData<4,int>());
    registerMetaData(new VectorMetaData<2,unsigned int>());
    registerMetaData(new VectorMetaData<3,unsigned int>());
    registerMetaData(new VectorMetaData<4,unsigned int>());
    registerMetaData(new MatrixMetaData<2,float>());
    registerMetaData(new MatrixMetaData<3,float>());
    registerMetaData(new MatrixMetaData<4,float>());
    registerMetaData(new MatrixMetaData<2,double>());
    registerMetaData(new MatrixMetaData<3,double>());
    registerMetaData(new MatrixMetaData<4,double>());
    registerMetaData(new PositionMetaData());
    registerMetaData(new ProcessorMetaData());
    registerMetaData(new ProcessorWidgetMetaData());
    registerMetaData(new PropertyEditorWidgetMetaData());
    // Register Capabilities
    registerCapabilities(new SystemCapabilities());
    // Register Data readers
    registerDataReader(new DatVolumeReader());
    registerDataReader(new IvfVolumeReader());
    registerDataReader(new RawVolumeReader());
    // Register Data writers
    registerDataWriter(new DatVolumeWriter());
    registerDataWriter(new IvfVolumeWriter());
    // Register Settings
    registerSettings(new SystemSettings());
    registerSettings(new LinkSettings());
    // Register Ports
    registerPort(MeshInport);
    registerPort(MeshMultiInport);
    registerPort(MeshOutport);
    registerPort(ImageInport);
    registerPort(ImageOutport);
    registerPort(VolumeInport);
    registerPort(VolumeOutport);
    // Register PortInspectors
    registerPortInspector("org.inviwo.ImageOutport", InviwoApplication::getPtr()->getPath(InviwoApplication::PATH_PORTINSPECTORS, "/imageportinspector.inv"));
    registerPortInspector("org.inviwo.VolumeOutport", InviwoApplication::getPtr()->getPath(InviwoApplication::PATH_PORTINSPECTORS, "/volumeportinspector.inv"));
    registerPortInspector("org.inviwo.GeometryOutport", InviwoApplication::getPtr()->getPath(InviwoApplication::PATH_PORTINSPECTORS, "/geometryportinspector.inv"));
    
    //registerProperty(EventProperty); TODO fix "default" contructor with 2 args...
    registerProperty(CompositeProperty);
    registerProperty(AdvancedMaterialProperty);
    registerProperty(BoolProperty);
    registerProperty(ButtonProperty);
    registerProperty(CameraProperty);
    registerProperty(DirectoryProperty);
    registerProperty(DoubleMat2Property);
    registerProperty(DoubleMat3Property);
    registerProperty(DoubleMat4Property);
    registerProperty(DoubleProperty);
    registerProperty(DoubleVec2Property);
    registerProperty(DoubleVec3Property);
    registerProperty(DoubleVec4Property);
    registerProperty(FileProperty);
    registerProperty(FloatMat2Property);
    registerProperty(FloatMat3Property);
    registerProperty(FloatMat4Property);
    registerProperty(FloatMinMaxProperty);
    registerProperty(FloatProperty);
    registerProperty(FloatVec2Property);
    registerProperty(FloatVec3Property);
    registerProperty(FloatVec4Property);
    registerProperty(ImageEditorProperty);
    registerProperty(IntMinMaxProperty);
    registerProperty(IntProperty);
    registerProperty(IntVec2Property);
    registerProperty(IntVec3Property);
    registerProperty(IntVec4Property);
    registerProperty(OptionPropertyDouble);
    registerProperty(OptionPropertyFloat);
    registerProperty(OptionPropertyInt);
    registerProperty(OptionPropertyString);
    registerProperty(PlaneProperty);
    registerProperty(PositionProperty);
    registerProperty(SimpleLightingProperty);
    registerProperty(SimpleRaycastingProperty);
    registerProperty(StringProperty);
    registerProperty(TransferFunctionProperty);
    registerProperty(VolumeIndicatorProperty);


    // START OF AUTOGENERATED CODE 
    // The following code has been autogenerated using createconverters.py 
    typedef OrdinalPropertyConverter<FloatProperty, IntProperty> FloatPropertyToIntPropertyConverter;
    typedef OrdinalPropertyConverter<FloatProperty, Int64Property> FloatPropertyToInt64PropertyConverter;
    typedef OrdinalPropertyConverter<FloatProperty, DoubleProperty> FloatPropertyToDoublePropertyConverter;
    typedef OrdinalPropertyConverter<IntProperty, FloatProperty> IntPropertyToFloatPropertyConverter;
    typedef OrdinalPropertyConverter<IntProperty, Int64Property> IntPropertyToInt64PropertyConverter;
    typedef OrdinalPropertyConverter<IntProperty, DoubleProperty> IntPropertyToDoublePropertyConverter;
    typedef OrdinalPropertyConverter<Int64Property, FloatProperty> Int64PropertyToFloatPropertyConverter;
    typedef OrdinalPropertyConverter<Int64Property, IntProperty> Int64PropertyToIntPropertyConverter;
    typedef OrdinalPropertyConverter<Int64Property, DoubleProperty> Int64PropertyToDoublePropertyConverter;
    typedef OrdinalPropertyConverter<DoubleProperty, FloatProperty> DoublePropertyToFloatPropertyConverter;
    typedef OrdinalPropertyConverter<DoubleProperty, IntProperty> DoublePropertyToIntPropertyConverter;
    typedef OrdinalPropertyConverter<DoubleProperty, Int64Property> DoublePropertyToInt64PropertyConverter;
    typedef OrdinalPropertyConverter<FloatVec2Property, DoubleVec2Property> FloatVec2PropertyToDoubleVec2PropertyConverter;
    typedef OrdinalPropertyConverter<FloatVec2Property, IntVec2Property> FloatVec2PropertyToIntVec2PropertyConverter;
    typedef OrdinalPropertyConverter<DoubleVec2Property, FloatVec2Property> DoubleVec2PropertyToFloatVec2PropertyConverter;
    typedef OrdinalPropertyConverter<DoubleVec2Property, IntVec2Property> DoubleVec2PropertyToIntVec2PropertyConverter;
    typedef OrdinalPropertyConverter<IntVec2Property, FloatVec2Property> IntVec2PropertyToFloatVec2PropertyConverter;
    typedef OrdinalPropertyConverter<IntVec2Property, DoubleVec2Property> IntVec2PropertyToDoubleVec2PropertyConverter;
    typedef OrdinalPropertyConverter<FloatVec3Property, DoubleVec3Property> FloatVec3PropertyToDoubleVec3PropertyConverter;
    typedef OrdinalPropertyConverter<FloatVec3Property, IntVec3Property> FloatVec3PropertyToIntVec3PropertyConverter;
    typedef OrdinalPropertyConverter<DoubleVec3Property, FloatVec3Property> DoubleVec3PropertyToFloatVec3PropertyConverter;
    typedef OrdinalPropertyConverter<DoubleVec3Property, IntVec3Property> DoubleVec3PropertyToIntVec3PropertyConverter;
    typedef OrdinalPropertyConverter<IntVec3Property, FloatVec3Property> IntVec3PropertyToFloatVec3PropertyConverter;
    typedef OrdinalPropertyConverter<IntVec3Property, DoubleVec3Property> IntVec3PropertyToDoubleVec3PropertyConverter;
    typedef OrdinalPropertyConverter<FloatVec4Property, DoubleVec4Property> FloatVec4PropertyToDoubleVec4PropertyConverter;
    typedef OrdinalPropertyConverter<FloatVec4Property, IntVec4Property> FloatVec4PropertyToIntVec4PropertyConverter;
    typedef OrdinalPropertyConverter<DoubleVec4Property, FloatVec4Property> DoubleVec4PropertyToFloatVec4PropertyConverter;
    typedef OrdinalPropertyConverter<DoubleVec4Property, IntVec4Property> DoubleVec4PropertyToIntVec4PropertyConverter;
    typedef OrdinalPropertyConverter<IntVec4Property, FloatVec4Property> IntVec4PropertyToFloatVec4PropertyConverter;
    typedef OrdinalPropertyConverter<IntVec4Property, DoubleVec4Property> IntVec4PropertyToDoubleVec4PropertyConverter;

    registerPropertyConverter(ScalarToStringConverter<FloatProperty>);
    registerPropertyConverter(ScalarToStringConverter<IntProperty>);
    registerPropertyConverter(ScalarToStringConverter<Int64Property>);
    registerPropertyConverter(ScalarToStringConverter<DoubleProperty>);
    registerPropertyConverter(VectorToStringConverter<FloatVec2Property>);
    registerPropertyConverter(VectorToStringConverter<DoubleVec2Property>);
    registerPropertyConverter(VectorToStringConverter<IntVec2Property>);
    registerPropertyConverter(VectorToStringConverter<FloatVec3Property>);
    registerPropertyConverter(VectorToStringConverter<DoubleVec3Property>);
    registerPropertyConverter(VectorToStringConverter<IntVec3Property>);
    registerPropertyConverter(VectorToStringConverter<FloatVec4Property>);
    registerPropertyConverter(VectorToStringConverter<DoubleVec4Property>);
    registerPropertyConverter(VectorToStringConverter<IntVec4Property>);

    registerPropertyConverter(FloatPropertyToIntPropertyConverter);
    registerPropertyConverter(FloatPropertyToInt64PropertyConverter);
    registerPropertyConverter(FloatPropertyToDoublePropertyConverter);
    registerPropertyConverter(IntPropertyToFloatPropertyConverter);
    registerPropertyConverter(IntPropertyToInt64PropertyConverter);
    registerPropertyConverter(IntPropertyToDoublePropertyConverter);
    registerPropertyConverter(Int64PropertyToFloatPropertyConverter);
    registerPropertyConverter(Int64PropertyToIntPropertyConverter);
    registerPropertyConverter(Int64PropertyToDoublePropertyConverter);
    registerPropertyConverter(DoublePropertyToFloatPropertyConverter);
    registerPropertyConverter(DoublePropertyToIntPropertyConverter);
    registerPropertyConverter(DoublePropertyToInt64PropertyConverter);
    registerPropertyConverter(FloatVec2PropertyToDoubleVec2PropertyConverter);
    registerPropertyConverter(FloatVec2PropertyToIntVec2PropertyConverter);
    registerPropertyConverter(DoubleVec2PropertyToFloatVec2PropertyConverter);
    registerPropertyConverter(DoubleVec2PropertyToIntVec2PropertyConverter);
    registerPropertyConverter(IntVec2PropertyToFloatVec2PropertyConverter);
    registerPropertyConverter(IntVec2PropertyToDoubleVec2PropertyConverter);
    registerPropertyConverter(FloatVec3PropertyToDoubleVec3PropertyConverter);
    registerPropertyConverter(FloatVec3PropertyToIntVec3PropertyConverter);
    registerPropertyConverter(DoubleVec3PropertyToFloatVec3PropertyConverter);
    registerPropertyConverter(DoubleVec3PropertyToIntVec3PropertyConverter);
    registerPropertyConverter(IntVec3PropertyToFloatVec3PropertyConverter);
    registerPropertyConverter(IntVec3PropertyToDoubleVec3PropertyConverter);
    registerPropertyConverter(FloatVec4PropertyToDoubleVec4PropertyConverter);
    registerPropertyConverter(FloatVec4PropertyToIntVec4PropertyConverter);
    registerPropertyConverter(DoubleVec4PropertyToFloatVec4PropertyConverter);
    registerPropertyConverter(DoubleVec4PropertyToIntVec4PropertyConverter);
    registerPropertyConverter(IntVec4PropertyToFloatVec4PropertyConverter);
    registerPropertyConverter(IntVec4PropertyToDoubleVec4PropertyConverter);

    // END OF AUTOGENERATED CODE 

}
Beispiel #24
0
//ConfigurationObject
ConfigurationObject::ConfigurationObject(String identifier, GenericProcessor* source, uint16 subproc)
	: SourceProcessorInfo(source, subproc)
{
	setDefaultNameAndDescription();
	setIdentifier(identifier);
}
AREXPORT ArServerClient::ArServerClient(
	ArSocket *tcpSocket, unsigned int udpPort, long authKey,
	long introKey, 	ArRetFunctor2<bool, ArNetPacket *, 
	struct sockaddr_in *> *sendUdpCallback,
	std::map<unsigned int, ArServerData *> *dataMap,
	const char *passwordKey, const char *serverKey,
	const ArServerUserInfo *userInfo, int rejecting, 
	const char *rejectingString, bool debugLogging,
	const char *serverClientName, bool logPasswordFailureVerbosely,
	bool allowSlowPackets, bool allowIdlePackets) :
  myProcessPacketCB(this, &ArServerClient::processPacket, NULL, true)
{
  ArNetPacket packet;

  // set our default to no command
  pushCommand(0);

  myAuthKey = authKey;
  myIntroKey = introKey;
  myTcpSocket.transfer(tcpSocket);
  myTcpSocket.setCloseCallback(tcpSocket->getCloseCallback());
  myTcpSocket.setNonBlock();
  myTcpReceiver.setSocket(&myTcpSocket);
  myTcpReceiver.setProcessPacketCB(&myProcessPacketCB);
  myTcpSender.setSocket(&myTcpSocket);

  mySendUdpCB = sendUdpCallback;
  myDataMap = dataMap;
  if (udpPort == 0)
    myTcpOnly = true;
  else
    myTcpOnly = false;
  mySentTcpOnly = myTcpOnly;

  myUserInfo = userInfo;
  myPasswordKey = passwordKey;
  myServerKey = serverKey;
  myRejecting = rejecting;
  if (rejectingString != NULL)
    myRejectingString = rejectingString;

  myDebugLogging = debugLogging;
  if (myDebugLogging)
    myVerboseLogLevel = ArLog::Normal;
  else
    myVerboseLogLevel = ArLog::Verbose;

  myTcpSender.setDebugLogging(myDebugLogging);

  myLogPrefix = serverClientName;
  myLogPrefix += ": ";
  myTcpSender.setLoggingPrefix(myLogPrefix.c_str());
  myTcpReceiver.setLoggingPrefix(myLogPrefix.c_str());

  myLogPasswordFailureVerbosely = logPasswordFailureVerbosely;

  mySlowPacketsMutex.setLogName("ArServerClient::mySlowPacketsMutex");
  myIdlePacketsMutex.setLogName("ArServerClient::myIdlePacketsMutex");

  myAllowSlowPackets = allowSlowPackets;
  myAllowIdlePackets = allowIdlePackets;

  setIdentifier(ArServerClientIdentifier());
  internalSwitchState(STATE_SENT_INTRO);

  packet.empty();
  packet.setCommand(ArServerCommands::INTRODUCTION);
  packet.strToBuf("alpha");
  packet.uByte2ToBuf(udpPort);
  packet.uByte4ToBuf(myAuthKey);
  packet.uByte4ToBuf(myIntroKey);
  packet.strToBuf(myPasswordKey.c_str());
  sendPacketTcp(&packet);

  mySlowIdleThread = NULL;

  myHaveSlowPackets = false;
  myHaveIdlePackets = false;
  
  myCreationTime.setToNow();

  resetTracking();
}
Beispiel #26
0
std::string Processor::getIdentifier() {
    if (identifier_.empty()) setIdentifier(getDisplayName());
    return identifier_;
}
Beispiel #27
0
QtWidgetModule::QtWidgetModule() : InviwoModule() {
    setIdentifier("QtWidget");
    registerPropertyWidget(BoolPropertyWidgetQt, BoolProperty, "Default");
    registerPropertyWidget(ButtonPropertyWidgetQt, ButtonProperty, "Default");
    registerPropertyWidget(BoolCompositePropertyWidgetQt, BoolCompositeProperty, "Default");

    registerPropertyWidget(ColorPropertyWidgetQt, IntVec3Property, "Color");
    registerPropertyWidget(ColorPropertyWidgetQt, IntVec4Property, "Color");
    registerPropertyWidget(ColorPropertyWidgetQt, FloatVec3Property, "Color");
    registerPropertyWidget(ColorPropertyWidgetQt, FloatVec4Property, "Color");
    registerPropertyWidget(CompositePropertyWidgetQt, CompositeProperty, "Default");
    registerPropertyWidget(EventPropertyWidgetQt, EventProperty, "Default");
    registerPropertyWidget(FilePropertyWidgetQt, FileProperty, "Default");

    registerPropertyWidget(FloatMat2PropertyWidgetQt, FloatMat2Property, "Default");
    registerPropertyWidget(FloatMat3PropertyWidgetQt, FloatMat3Property, "Default");
    registerPropertyWidget(FloatMat4PropertyWidgetQt, FloatMat4Property, "Default");
    registerPropertyWidget(FloatMinMaxPropertyWidgetQt, FloatMinMaxProperty, "Default");
    registerPropertyWidget(FloatMinMaxTextPropertyWidgetQt, FloatMinMaxProperty, "Text");
    registerPropertyWidget(FloatPropertyWidgetQt, FloatProperty, "Default");
    registerPropertyWidget(FloatAnglePropertyWidgetQt, FloatProperty, "Angle");
    registerPropertyWidget(FloatPropertyWidgetQt, FloatProperty, "Text");
    registerPropertyWidget(FloatVec2PropertyWidgetQt, FloatVec2Property, "Default");
    registerPropertyWidget(FloatVec2PropertyWidgetQt, FloatVec2Property, "Text");
    registerPropertyWidget(FloatVec3PropertyWidgetQt, FloatVec3Property, "Default");
    registerPropertyWidget(FloatVec3PropertyWidgetQt, FloatVec3Property, "Text");
    registerPropertyWidget(FloatVec3PropertyWidgetQt, FloatVec3Property, "Spherical");
    registerPropertyWidget(FloatVec4PropertyWidgetQt, FloatVec4Property, "Default");
    registerPropertyWidget(FloatVec4PropertyWidgetQt, FloatVec4Property, "Text");

    registerPropertyWidget(DoubleMat2PropertyWidgetQt, DoubleMat2Property, "Default");
    registerPropertyWidget(DoubleMat3PropertyWidgetQt, DoubleMat3Property, "Default");
    registerPropertyWidget(DoubleMat4PropertyWidgetQt, DoubleMat4Property, "Default");
    registerPropertyWidget(DoubleMinMaxPropertyWidgetQt, DoubleMinMaxProperty, "Default");
    registerPropertyWidget(DoubleMinMaxTextPropertyWidgetQt, DoubleMinMaxProperty, "Text");
    registerPropertyWidget(DoublePropertyWidgetQt, DoubleProperty, "Default");
    registerPropertyWidget(DoubleAnglePropertyWidgetQt, DoubleProperty, "Angle");
    registerPropertyWidget(DoublePropertyWidgetQt, DoubleProperty, "Text");
    registerPropertyWidget(DoubleVec2PropertyWidgetQt, DoubleVec2Property, "Default");
    registerPropertyWidget(DoubleVec2PropertyWidgetQt, DoubleVec2Property, "Text");
    registerPropertyWidget(DoubleVec3PropertyWidgetQt, DoubleVec3Property, "Default");
    registerPropertyWidget(DoubleVec3PropertyWidgetQt, DoubleVec3Property, "Text");
    registerPropertyWidget(DoubleVec3PropertyWidgetQt, DoubleVec3Property, "Spherical");
    registerPropertyWidget(DoubleVec4PropertyWidgetQt, DoubleVec4Property, "Default");
    registerPropertyWidget(DoubleVec4PropertyWidgetQt, DoubleVec4Property, "Text");
    
    registerPropertyWidget(ImageEditorWidgetQt, FileProperty, "ImageEditor");
    registerPropertyWidget(ImageEditorWidgetQt, ImageEditorProperty, "Default");
    registerPropertyWidget(ImageEditorWidgetQt, ImageEditorProperty, "ImageEditor");
    
    registerPropertyWidget(IntMinMaxPropertyWidgetQt, IntMinMaxProperty, "Default");
    registerPropertyWidget(IntMinMaxTextPropertyWidgetQt, IntMinMaxProperty, "Text");
    registerPropertyWidget(IntPropertyWidgetQt, IntProperty, "Default");
    registerPropertyWidget(IntPropertyWidgetQt, IntProperty, "Text");
    registerPropertyWidget(IntVec2PropertyWidgetQt, IntVec2Property, "Default");
    registerPropertyWidget(IntVec2PropertyWidgetQt, IntVec2Property, "Text");
    registerPropertyWidget(IntVec3PropertyWidgetQt, IntVec3Property, "Default");
    registerPropertyWidget(IntVec3PropertyWidgetQt, IntVec3Property, "Text");
    registerPropertyWidget(IntVec4PropertyWidgetQt, IntVec4Property, "Default");
    registerPropertyWidget(IntVec4PropertyWidgetQt, IntVec4Property, "Text");
    registerPropertyWidget(IntSize2PropertyWidgetQt, IntSize2Property, "Default");
    registerPropertyWidget(IntSize2PropertyWidgetQt, IntSize2Property, "Text");
    registerPropertyWidget(IntSize3PropertyWidgetQt, IntSize3Property, "Default");
    registerPropertyWidget(IntSize3PropertyWidgetQt, IntSize3Property, "Text");
    registerPropertyWidget(IntSize4PropertyWidgetQt, IntSize4Property, "Default");
    registerPropertyWidget(IntSize4PropertyWidgetQt, IntSize4Property, "Text");
    registerPropertyWidget(Int64PropertyWidgetQt, Int64Property, "Default");
    registerPropertyWidget(Int64PropertyWidgetQt, Int64Property, "Text");
    
    registerPropertyWidget(LightPropertyWidgetQt, FloatVec3Property, "LightPosition");
    registerPropertyWidget(OptionPropertyWidgetQt, OptionPropertyInt, "Default");
    registerPropertyWidget(OptionPropertyWidgetQt, OptionPropertySize_t, "Default");
    registerPropertyWidget(OptionPropertyWidgetQt, OptionPropertyFloat, "Default");
    registerPropertyWidget(OptionPropertyWidgetQt, OptionPropertyDouble, "Default");
    registerPropertyWidget(OptionPropertyWidgetQt, OptionPropertyString, "Default");
    registerPropertyWidget(StringPropertyWidgetQt, StringProperty, "Default");
    registerPropertyWidget(StringPropertyWidgetQt, StringProperty, "Password");
    registerPropertyWidget(TextEditorWidgetQt, FileProperty, "TextEditor");
    registerPropertyWidget(TextEditorWidgetQt, FileProperty, "ShaderEditor");
    registerPropertyWidget(TextEditorWidgetQt, StringProperty, "TextEditor");
    registerPropertyWidget(TextEditorWidgetQt, StringProperty, "ShaderEditor");
    registerPropertyWidget(TransferFunctionPropertyWidgetQt, TransferFunctionProperty, "Default");
    registerDialog("RawVolumeReader", RawDataReaderDialogQt);
}
Beispiel #28
0
void ProcessorGraphicsItem::onLabelGraphicsItemChange() {
    if (nameLabel_->isFocusOut()) {
        setIdentifier(nameLabel_->text());
        nameLabel_->setNoFocusOut();
    }
}
Beispiel #29
0
VLCAudioPlayer::VLCAudioPlayer() : FilePlayer()
{
	setIdentifier("vlcaudio");
	addOption("ao", "alsa", "Audio output driver");
}
Beispiel #30
0
testAI::testAI()
{
    setIdentifier("testAI");
}