bool PropertyGridManager::buildNewControl(PropertyGridProperty *const property, int &height)
{
if(nullptr == mContainerWidget)
{
Debug::error(STEEL_METH_INTRO, "no container for controls. Aborting.").endl();
return false;
}
// build the control matching the property value type
Ogre::String const skin = "PanelEmpty";
Ogre::String const controlName = "PropertyGridManager_Control_" + property->id();
// original control size is set here, but the method that build the control can totally resize it.
MyGUI::IntCoord coords(0, height, mContainerWidget->getClientWidget()->getWidth(), 20);
MyGUI::Widget *control = mContainerWidget->createWidget<MyGUI::Widget>(skin, coords, MyGUI::Align::HCenter | MyGUI::Align::Top, controlName);
if(nullptr == control)
{
Debug::error(STEEL_METH_INTRO, "could not build control for property: ", *property, ". Skipping.").endl();
return false;
}
switch(property->valueType())
{
case PropertyGridPropertyValueType::Bool:
buildBoolControl(control, property);
break;
case PropertyGridPropertyValueType::String:
buildStringControl(control, property);
break;
case PropertyGridPropertyValueType::Range:
buildRangeControl(control, property);
break;
case PropertyGridPropertyValueType::StringVectorSelection:
buildStringVectorSelectionControl(control, property);
break;
case PropertyGridPropertyValueType::None:
default:
buildDummyControl(control, property);
}
height = control->getBottom();
mControlsMap.insert(std::make_pair(property->id(), control));
// subscribe to property changes
Signal propertyChanged = property->getSignal(PropertyGridProperty::PublicSignal::changed);
registerSignal(propertyChanged);
mSignals.propertyChanged.insert(propertyChanged);
// update control value
updateControlValue(control, property);
return true;
}
int main(int argc, char *argv[])
{
QApplication::setGraphicsSystem("raster");
QApplication a(argc, argv);
QTextCodec::setCodecForTr(QTextCodec::codecForLocale());
QString privatePathQt(QApplication::applicationDirPath());
QString path(privatePathQt);
path = QDir::toNativeSeparators(path);
Server server;
if (!server.listen(QHostAddress::Any, 6177)) {
std::cerr << "Failed to bind to port" << std::endl;
return 1;
}
QDeclarativeView view;
view.engine()->setOfflineStoragePath(path);
QObject::connect((QObject*)view.engine(), SIGNAL(quit()), &a, SLOT(quit()));
view.setSource(QUrl("qrc:/qml/main.qml"));
view.show();
QString md5;
QString dbname="DemoDB";
QByteArray ba;
ba = QCryptographicHash::hash (dbname.toAscii(), QCryptographicHash::Md5);
md5.append(ba.toHex());
md5.append(".sqlite");
path.append(QDir::separator()).append("Databases");
path.append(QDir::separator()).append(md5);
QSqlDatabase db = QSqlDatabase::addDatabase("QSQLITE");
db.setDatabaseName(path);
if (!db.open()) {
std::cerr << "Cannot open database" << std::endl;
return 1;
}
OrderManager orderManager;
view.rootContext()->setContextProperty("server", &server);
view.rootContext()->setContextProperty("orderManager", &orderManager);
Client client;
QObject::connect(&orderManager, SIGNAL(send()), &client, SLOT(sendOrder()));
QObject::connect(&server, SIGNAL(paied(quint32)), &orderManager, SLOT(payOrder(quint32)));
DeviceManager deviceManager;
QObject::connect(&deviceManager, SIGNAL(registerSignal()), &client, SLOT(sendRegistration()));
view.rootContext()->setContextProperty("deviceManager", &deviceManager);
deviceManager.registerDevice();
return a.exec();
}
void EARA::initialize(int stage) {
AbstractOMNeTARAClient::initialize(stage);
if(stage == 4) {
OMNeTEARAConfiguration config = OMNeTEARAConfiguration(this);
setLogger(config.getLogger());
AbstractEARAClient::initializeEARA(config);
initializeNetworkInterfacesOf(this, config);
notificationBoard->subscribe(this, NF_BATTERY_CHANGED);
WATCH(nrOfDetectedLoops);
WATCH(maximumBatteryCapacityInNetwork);
LOOP_DETECTION_SIGNAL = registerSignal("routingLoopDetected");
DROP_PACKET_WITH_ZERO_TTL = registerSignal("dropZeroTTLPacket");
ROUTE_FAILURE_NO_HOP = registerSignal("routeFailureNoHopAvailable");
NEW_ROUTE_DISCOVERY = registerSignal("newRouteDiscovery");
ROUTE_FAILURE_NEXT_HOP_IS_SENDER = registerSignal("routeFailureNextHopIsSender");
new EARARoutingTableWatcher(routingTable);
}
}
void PropertyGridManager::setAdapter(PropertyGridAdapter *const adapter)
{
if(nullptr != mAdapter)
unsetAdapter();
mAdapter = adapter;
if(nullptr != mAdapter)
{
buildNewControls();
mSignals.newAdapterProperty = mAdapter->getSignal(PropertyGridAdapter::PublicSignal::newProperty);
registerSignal(mSignals.newAdapterProperty);
}
}
void PropertyGridBlackboardModelAdapter::buildProperties()
{
BlackBoardModel *const bbModel = mLevel->blackBoardModelMan()->at(mMid);
if(nullptr == bbModel)
return;
// variables
for(auto it : bbModel->variables())
{
Ogre::String key = it.first;
PropertyGridProperty *prop = new PropertyGridProperty(key);
PropertyGridProperty::StringReadCallback readCB([this, key]()->Ogre::String
{
BlackBoardModel *const bbModel = mLevel->blackBoardModelMan()->at(mMid);
return bbModel->getStringVariable(key);
});
prop->setCallbacks(readCB, nullptr);
PropertyGridAdapter::mProperties.push_back(prop);
}
registerSignal(bbModel->getSignal(BlackBoardModel::PublicSignal::variableChanged));
}
virtual void initialize() override {
arrivalSignal = registerSignal("arrival"); //Initialize signal
lastArrivalTime = 0.0;
interarrivalTimeAccumulated = 0.0;
messageCount = 0;
}
void PropertyGridPhysicsModelAdapter::buildProperties()
{
// speed
{
PropertyGridProperty *prop = new PropertyGridProperty("Velocity");
PropertyGridProperty::StringReadCallback readCB([this]()->Ogre::String
{
PhysicsModel *const pmodel = mLevel->physicsModelMan()->at(mMid);
if(nullptr == pmodel)
return StringUtils::BLANK;
Ogre::Vector3 const v = pmodel->velocity();
u16 width = 4;
Ogre::String const r = "{" +
Ogre::StringConverter::toString(v.x, width) + ", " +
Ogre::StringConverter::toString(v.y, width) + ", " +
Ogre::StringConverter::toString(v.z, width)
+ "}";
return r;
});
prop->setCallbacks(readCB, nullptr);
PropertyGridAdapter::mProperties.push_back(prop);
}
// shape list
{
PropertyGridProperty *prop = new PropertyGridProperty(PhysicsModel::BBOX_SHAPE_ATTRIBUTE);
PropertyGridProperty::StringVectorSelectionReadCallback readCB([this]()->PropertyGridProperty::StringVectorSelection
{
PropertyGridProperty::StringVectorSelection readItem;
PhysicsModel *const pmodel = mLevel->physicsModelMan()->at(mMid);
if(nullptr == pmodel)
return readItem;
readItem.selectableValues = boundingShapeValues();
readItem.selectedIndex = (PropertyGridProperty::StringVectorSelection::selection_type)(std::find(readItem.selectableValues.begin(), readItem.selectableValues.end(), toString(pmodel->shape())) - readItem.selectableValues.begin());
return readItem;
});
PropertyGridProperty::StringVectorSelectionWriteCallback writeCB([this](PropertyGridProperty::StringVectorSelection::selection_type index)
{
Agent *const agent = mLevel->agentMan()->getAgent(mAid);
if(nullptr == agent)
return;
OgreModel *const omodel = agent->ogreModel();
PhysicsModel *const pmodel = mLevel->physicsModelMan()->at(mMid);
if(nullptr == omodel || nullptr == pmodel)
return;
StringVector possibleValues = boundingShapeValues();
BoundingShape shape = BoundingShape::SPHERE;
if(index < possibleValues.size())
shape = toBoundingShape(possibleValues[index]);
pmodel->setShape(omodel, shape);
});
prop->setCallbacks(readCB, writeCB);
PropertyGridAdapter::mProperties.push_back(prop);
}
// mass
{
PropertyGridProperty *prop = new PropertyGridProperty(PhysicsModel::MASS_ATTRIBUTE);
PropertyGridProperty::RangeReadCallback readCB([this]()->PropertyGridProperty::Range
{
PropertyGridProperty::Range range;
PhysicsModel *const pmodel = mLevel->physicsModelMan()->at(mMid);
if(nullptr != pmodel)
range.value = (PropertyGridProperty::Range::value_type)pmodel->mass();
range.min = 0.;
range.max = 100.;
Numeric::clamp(range.value, range.min, range.max);
return range;
});
PropertyGridProperty::RangeWriteCallback writeCB([this](PropertyGridProperty::Range const & range)
{
PhysicsModel *const pmodel = mLevel->physicsModelMan()->at(mMid);
Numeric::clamp(range.value, range.min, range.max);
pmodel->setMass((decltype(pmodel->mass()))range.value);
});
prop->setCallbacks(readCB, writeCB);
PropertyGridAdapter::mProperties.push_back(prop);
}
// damping
{
PropertyGridProperty *prop = new PropertyGridProperty(PhysicsModel::DAMPING_ATTRIBUTE);
PropertyGridProperty::RangeReadCallback readCB([this]()->PropertyGridProperty::Range
{
PropertyGridProperty::Range range;
PhysicsModel *const pmodel = mLevel->physicsModelMan()->at(mMid);
if(nullptr != pmodel)
range.value = (PropertyGridProperty::Range::value_type)pmodel->linearDamping();
range.min = 0.;
range.max = 1.;
Numeric::clamp(range.value, range.min, range.max);
return range;
});
PropertyGridProperty::RangeWriteCallback writeCB([this](PropertyGridProperty::Range const & range)
{
PhysicsModel *const pmodel = mLevel->physicsModelMan()->at(mMid);
Numeric::clamp(range.value, range.min, range.max);
pmodel->setDamping((decltype(pmodel->mass()))range.value);
});
prop->setCallbacks(readCB, writeCB);
PropertyGridAdapter::mProperties.push_back(prop);
}
PhysicsModel *const pmodel = mLevel->physicsModelMan()->at(mMid);
if(nullptr != pmodel)
registerSignal(pmodel->getSignal(PhysicsModel::PublicSignal::transformed));
}
void SimpleGen::initialize()
{
eventSignal = registerSignal("event");
// Start sending messages after 1s
scheduleAt(1.0, event);
}
int main ( int argc, char** argv )
{
if(argc !=2)
std::cout <<"Usage ./server <DbFilename>\n";
FileStorage Db(static_cast<std::string>(argv[1]));
// register the storage system
database.registerStorage(&Db);
// load the data from storage if any
database.loadDataFromStorage();
// register for signal handler
registerSignal();
try
{
std::cout << "Server starting on port 15000....\n";
ServerSocket server ( 15000 );
while ( true )
{
ServerSocket server_sock;
server.accept ( server_sock );
try
{
while ( true )
{
std::string input;
server_sock >> input;
std::string key,value;
std::string result;
// remove the last \r\n from input string
input.erase(input.size()-2);
// space for storing the tokens from input string
std::vector<std::string> token;
std::fill(token.begin(), token.end(), "");
// Parse the input and tokenize it and store in vector for further use
std::stringstream ss(input);
std::string s;
while (getline(ss, s, ' ')) {
token.push_back(s);
}
// Parese rest of input based on first token {SET,GET,SAVE}
switch(hashit(token[0]))
{
case GET:
if (2 != token.size())
goto INVALID;
key = token[1];
result = database.get(key);
// Return the result of GET query
server_sock <<"$3\n";
server_sock << result <<"\n";
break;
case SET:
if (3 != token.size())
goto INVALID;
key = token[1];
value = token[2];
// Store the SET query in memory
database.add(key,value);
server_sock <<"+OK\n";
break;
case SAVE:
if (1 != token.size())
goto INVALID;
database.persistData();
server_sock <<"+OK\n";
break;
INVALID:
default:
server_sock << "-INVALID\n";
break;
}
}
}
catch ( SocketException& ) {}
}
}
catch ( SocketException& e )
{
std::cout << "Exception was caught:" << e.description() << "\nExiting.\n";
}
return 0;
}
void DeviceManager::registerDevice()
{
emit registerSignal();
}
