//------------------------------------------------------------------------------
// setSlotNetworks() -- Set our list of networks
//------------------------------------------------------------------------------
bool Station::setSlotNetworks(Basic::PairStream* const a)
{
bool ok = true;
// Remove the old networks list
if (networks != 0) {
// we are no longer the container for these networks
for (Basic::List::Item* item = networks->getFirstItem(); item != 0; item = item->getNext()) {
Basic::Pair* pair = (Basic::Pair*)(item->getValue());
NetIO* p = (NetIO*)( pair->object() );
p->container(0);
}
}
// Set our network list pointer
networks = a;
// Make sure the new network list is setup correctly
if (networks != 0) {
for (Basic::List::Item* item = networks->getFirstItem(); item != 0; item = item->getNext()) {
Basic::Pair* pair = (Basic::Pair*)(item->getValue());
NetIO* p = dynamic_cast<NetIO*>( pair->object() );
if (p != 0) {
// We are this network's container
p->container(this);
}
else {
// Not of the proper type
std::cerr << "Player::setSlotNetworks: network at slot \"" << pair->slot() << "\" is not of class type NetIO" << std::endl;
ok = false;
}
}
}
return ok;
}
// Get the next free missile of type 'missileType'
Missile* SimpleStoresMgr::getSpecificMissile(const Basic::String* const missileType)
{
Missile* msl = 0;
if (missileType != 0) {
Basic::PairStream* list = getWeapons();
if (list != 0) {
// Find the first free (inactive) missile of type weaponType
Basic::List::Item* item = list->getFirstItem();
while (item != 0 && msl == 0) {
Basic::Pair* pair = (Basic::Pair*)(item->getValue());
Missile* p = dynamic_cast<Missile*>( pair->object() );
if (p != 0 && p->isInactive()) {
// Ok, we have a missile, but is it the type we want?
if (*p->getType() == *missileType) {
p->ref();
msl = p;
}
}
item = item->getNext();
}
list->unref();
}
}
return msl;
}
//-----------------------------------------------------------------------------
// Eaagles::Swarms::builder() -- builds simulation tree
//-----------------------------------------------------------------------------
static void builder()
{
cout << "Reading file : " << configFile << endl;
// Read the description file
int errors = 0;
Basic::Object* q1 = Basic::lcParser(configFile, Factory::createObj, &errors);
if (errors > 0) {
cerr << "File: " << configFile << ", errors: " << errors << endl;
exit(1);
}
station = 0;
if (q1 != 0) {
// When we were given a Basic::Pair, get the pointer to its object.
Basic::Pair* pp = dynamic_cast<Basic::Pair*>(q1);
if (pp != 0) {
q1 = pp->object();
}
// What we should have here is the Station object
station = dynamic_cast<Simulation::Station*>(q1);
}
// Make sure we did get a valid Station object (we must have one!)
if (station == 0) {
cout << "Invalid description file!" << endl;
exit(EXIT_FAILURE);
}
}
//------------------------------------------------------------------------------
// Removes a symbol from the master symbol table
//------------------------------------------------------------------------------
bool SymbolLoader::removeSymbol(const int idx)
{
bool ok = false;
// Find the symbol
if (idx >= 1 && idx <= MAX_SYMBOLS) {
const int i = (idx - 1);
if (symbols[i] != 0) {
// ---
// remove the symbol's graphical component from our subcomponent list
// ---
{
// Get the symbol's graphical component
Basic::Pair* pair = symbols[i]->getSymbolPair();
BasicGL::Graphic* g = (BasicGL::Graphic*) pair->object();
Basic::PairStream* x = getComponents();
Basic::Component::processComponents(x, typeid(BasicGL::Graphic), 0, g);
x->unref();
}
// ---
// and remove it from our master symbol table
// ---
symbols[i]->setSymbolPair(0);
symbols[i]->unref();
symbols[i] = 0;
ok = true;
}
}
return ok;
}
//------------------------------------------------------------------------------
// stepOwnshipPlayer() -- Step to the next local player
//------------------------------------------------------------------------------
void SimStation::stepOwnshipPlayer()
{
Basic::PairStream* pl = getSimulation()->getPlayers();
if (pl != nullptr) {
Simulation::Player* f = nullptr;
Simulation::Player* n = nullptr;
bool found = false;
// Find the next player
Basic::List::Item* item = pl->getFirstItem();
while (item != nullptr) {
Basic::Pair* pair = static_cast<Basic::Pair*>(item->getValue());
if (pair != nullptr) {
Simulation::Player* ip = static_cast<Simulation::Player*>(pair->object());
if ( ip->isMode(Simulation::Player::ACTIVE) &&
ip->isLocalPlayer() &&
ip->isClassType(typeid(Simulation::AirVehicle))
) {
if (f == nullptr) { f = ip; } // Remember the first
if (found) { n = ip; ; break; }
if (ip == getOwnship()) found = true;
}
}
item = item->getNext();
}
if (found && n == nullptr) n = f;
if (n != nullptr) setOwnshipPlayer(n);
pl->unref();
}
}
// Default external equipment jettison event handler
bool Stores::onJettisonEvent(ExternalStore* const sys)
{
bool ok = false;
if (sys != 0) {
Basic::PairStream* list = getStores();
if (list != 0) {
// First, make sure it's one of ours!
bool found = false;
Basic::List::Item* item = list->getFirstItem();
while (item != 0 && !found) {
Basic::Pair* pair = static_cast<Basic::Pair*>(item->getValue());
found = (sys == pair->object()); // is it a match?
item = item->getNext();
}
if (found) {
// Send a jettison event to the system
ok = sys->event(JETTISON_EVENT);
}
list->unref();
list = 0;
}
}
return ok;
}
//------------------------------------------------------------------------------
// processBackgroundTasks() -- Process the background models and interfaces
//------------------------------------------------------------------------------
void Station::processBackgroundTasks(const LCreal dt)
{
// Note: interoperability networks are handled by
// processNetworkInputTasks() and processNetworkOutputTasks()
// The I/O handers
if (ioHandlers != 0) {
Basic::List::Item* item = ioHandlers ->getFirstItem();
while (item != 0) {
Basic::Pair* pair = (Basic::Pair*)(item->getValue());
Basic::IoHandler* p = (Basic::IoHandler*)( pair->object() );
p->updateData(dt);
item = item->getNext();
}
}
// Our simulation model
if (sim != 0) sim->updateData(dt);
// The OTW interfaces
if (otw != 0) {
Basic::List::Item* item = otw ->getFirstItem();
while (item != 0) {
Basic::Pair* pair = (Basic::Pair*)(item->getValue());
Otw* p = (Otw*)( pair->object() );
p->updateData(dt);
item = item->getNext();
}
}
}
//-----------------------------------------------------------------------------
// createWindow() -- create the main window
//-----------------------------------------------------------------------------
int GlutDisplay::createWindow()
{
winId = -1;
#ifdef __FREEGLUT_EXT_H__ /* freeglut only */
glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS);
#endif
unsigned int wmode = GLUT_DOUBLE | GLUT_RGB | GLUT_ALPHA;
if (getClearDepth() >= 0.0f) { wmode = wmode | GLUT_DEPTH; }
if (accumBuff) { wmode = wmode | GLUT_ACCUM; }
if (stencilBuff) { wmode = wmode | GLUT_STENCIL; }
glutInitDisplayMode( wmode );
GLint vpX(0), vpY(0); // our initial viewport position
GLsizei vpWidth(0), vpHeight(0); // our initial viewport size
getViewport(&vpX, &vpY, &vpWidth, &vpHeight);
glutInitWindowPosition(vpX, vpY);
glutInitWindowSize(vpWidth, vpHeight);
winId = glutCreateWindow(getName());
if (winId > 0) {
if (isMessageEnabled(MSG_INFO)) {
std::cout << "GlutDisplay::createWindow() name = " << getName() << ", winId = " << winId << std::endl;
}
// Configure the new window
if (fullScreenFlg) glutFullScreen();
glutDisplayFunc(drawFuncCB);
glutReshapeFunc(reshapeItCB);
glutIdleFunc(idleCB);
glutPassiveMotionFunc(passiveMotionFuncCB);
glutMotionFunc(motionFuncCB);
glutKeyboardFunc(keyboardFuncCB);
glutSpecialFunc(specialFuncCB);
glutMouseFunc(mouseFuncCB);
glutEntryFunc(entryFuncCB);
registerGlutDisplay(winId, this);
glutSetWindow(winId);
configure();
loadTextures();
// Create sub windows (if any)
if (subDisplays() != nullptr) {
Basic::List::Item* item = subDisplays()->getFirstItem();
while (item != nullptr) {
Basic::Pair* pair = dynamic_cast<Basic::Pair*>(item->getValue());
if (pair != nullptr) {
GlutDisplay* dobj = dynamic_cast<GlutDisplay*>( pair->object() );
if (dobj != nullptr) dobj->createSubWindow(winId);
}
item = item->getNext();
}
}
// Select this window
select();
}
return winId;
}
//------------------------------------------------------------------------------
// Search all of the objects in the main list for objects of 'type' and add
// them to the sublist. Also check all Stores type objects for any 'type' objects.
//------------------------------------------------------------------------------
void StoresMgr::searchAndAdd(Basic::PairStream* const mainList, const std::type_info& type, Basic::PairStream* sublist)
{
if (mainList != 0 && sublist != 0) {
const Basic::List::Item* item = mainList->getFirstItem();
while (item != 0) {
Basic::Pair* pair = (Basic::Pair*)(item->getValue());
Basic::Component* p = (Basic::Component*)( pair->object() );
// Check the type and add to the list
bool isType = p->isClassType(type);
if (isType) sublist->put(pair);
// If this is a Stores object then check its stores for 'type' objects as well
Stores* sp = dynamic_cast<Stores*>(p);
if ( sp != 0 ) {
Basic::PairStream* pstores = sp->getStores();
searchAndAdd(pstores, type, sublist);
pstores->unref();
}
item = item->getNext();
}
}
}
// Get the next free bomb of type 'bombType'
Bomb* SimpleStoresMgr::getSpecificBomb(const Basic::String* const bombType)
{
Bomb* bomb = 0;
if (bombType != 0) {
Basic::PairStream* list = getWeapons();
if (list != 0) {
// Find the first free (inactive) bomb
Basic::List::Item* item = list->getFirstItem();
while (item != 0 && bomb == 0) {
Basic::Pair* pair = (Basic::Pair*)(item->getValue());
Bomb* p = dynamic_cast<Bomb*>( pair->object() );
if (p != 0 && p->isInactive()) {
// Ok, we have a bomb, but is it the type we want?
if (*p->getType() == *bombType) {
p->ref();
bomb = p;
}
}
item = item->getNext();
}
list->unref();
}
}
return bomb;
}
//------------------------------------------------------------------------------
// Set slot functions
//------------------------------------------------------------------------------
bool StoresMgr::setSlotStores(const Basic::PairStream* const msg)
{
// First let our base class do everything that it needs to.
BaseClass::setSlotStores(msg);
// ---
// Clear all previous stores and assigned weapons
// ---
weaponsList = 0;
externalList = 0;
fuelList = 0;
gunPtr = 0;
// ---
// Use the stores list that the Stores class just processed.
Basic::PairStream* stores = getStores();
if (stores != 0){
// Create the new weapons list that contains all weapons
{
Basic::PairStream* newWeapons = new Basic::PairStream();
searchAndAdd(stores, typeid(Weapon), newWeapons);
if (newWeapons->entries() > 0) weaponsList = newWeapons;
newWeapons->unref();
}
// Create the new external stores list that contains all
// non-weapon, external stores (e.g., fuel tanks, pods, guns)
{
Basic::PairStream* newExternal = new Basic::PairStream();
searchAndAdd(stores, typeid(ExternalStore), newExternal);
if (newExternal->entries() > 0) externalList = newExternal;
newExternal->unref();
}
// Create the new fuel tank list that contains all fuel tanks
{
Basic::PairStream* newFuel = new Basic::PairStream();
searchAndAdd(stores, typeid(FuelTank), newFuel);
if (newFuel->entries() > 0) fuelList = newFuel;
newFuel->unref();
}
// Find the primary gun; i.e., the first gun found on our stores
Basic::List::Item* item = stores->getFirstItem();
while (item != 0 && gunPtr == 0) {
Basic::Pair* pair = (Basic::Pair*)(item->getValue());
Gun* p = dynamic_cast<Gun*>( pair->object() );
if (p != 0) gunPtr = p;
item = item->getNext();
}
stores->unref();
stores = 0;
}
return true;
}
//------------------------------------------------------------------------------
// determineColors() - take our value, and look for a corresponding color
// and breakpoint
//------------------------------------------------------------------------------
bool ColorRotary::determineColor(const LCreal value)
{
bool ok = false;
int breakPoint = 0;
// find out where we are in the break table
unsigned int i = 0;
// do an endpoint check while we are at it
if (value >= myValues[numVals-1]) breakPoint = numVals;
while (!ok && i < numVals) {
if (value >= myValues[i] && value < myValues[i+1]) {
breakPoint = (i + 1);
ok = true;
}
else i++;
}
// now set the proper color (using the breakpoint index)
if (myColors != 0) {
Basic::Pair* pair = myColors->getPosition(breakPoint);
if (pair != 0) {
Basic::Color* listcolor = dynamic_cast<Basic::Color*>(pair->object());
if (listcolor != 0) {
osg::Vec4* vec = (osg::Vec4*) listcolor->getRGBA();
color = *vec;
ok = true;
}
}
}
return ok;
}
//------------------------------------------------------------------------------
// getRCS() -- Get the RCS
//------------------------------------------------------------------------------
LCreal SigSwitch::getRCS(const Emission* const em)
{
LCreal rcs = 0.0;
// Find our ownship player ...
const Player* ownship = (const Player*) findContainerByType(typeid(Player));
if (ownship != 0) {
// get our ownship's camouflage type
unsigned int camouflage = ownship->getCamouflageType();
camouflage++; // our components are one based
// find a RfSignature with this index
Basic::Pair* pair = findByIndex(camouflage);
if (pair != 0) {
RfSignature* sig = dynamic_cast<RfSignature*>( pair->object() );
if (sig != 0) {
// OK -- we've found the correct RfSignature subcomponet
// now let it do all of the work
rcs = sig->getRCS(em);
}
}
}
return rcs;
}
// Default weapon jettison event handler
bool Stores::onJettisonEvent(Weapon* const wpn)
{
bool ok = false;
if (wpn != nullptr) {
Basic::PairStream* list = getStores();
if (list != nullptr) {
// First, make sure it's one of ours!
bool found = false;
Basic::List::Item* item = list->getFirstItem();
while (item != nullptr && !found) {
Basic::Pair* pair = static_cast<Basic::Pair*>(item->getValue());
found = (wpn == pair->object()); // is it a match?
item = item->getNext();
}
if (found) {
// Send a jettison event to the weapon
ok = wpn->event(JETTISON_EVENT);
}
list->unref();
list = nullptr;
}
}
return ok;
}
//-----------------------------------------------------------------------------
// reshape it function, for reshaping our subdisplays
//-----------------------------------------------------------------------------
void GlutDisplay::reshapeIt(int w, int h)
{
//std::cout << "reshapeIt() winID = " << winId;
//std::cout << "; size(" << w << ", " << h << ")";
//std::cout << std::endl;
// make sure we have a min height and width or our displays will get destroyed
if (w > 10 && h > 10) {
BaseClass::reshapeIt(w, h);
if (subDisplays() != nullptr && okToResize) {
// go through and put our new numbers in
Basic::List::Item* item = subDisplays()->getFirstItem();
while (item != nullptr) {
Basic::Pair* pair = static_cast<Basic::Pair*>(item->getValue());
if (pair != nullptr) {
GlutDisplay* gd = dynamic_cast<GlutDisplay*>(pair->object());
if (gd != nullptr) gd->reshapeSubWindow();
}
item = item->getNext();
}
// Restore our window ID
glutSetWindow(this->getWindowId());
}
}
}
//------------------------------------------------------------------------------
// setOwnshipByName() -- set our ownship by name
//------------------------------------------------------------------------------
bool Station::setOwnshipByName(const char* const newOS)
{
bool set = false;
Basic::PairStream* pl = 0;
if (sim != 0) pl = sim->getPlayers();
// Look for this ownship in our list of players
if (newOS != 0 && pl != 0) {
Basic::Pair* p = pl->findByName(newOS);
if (p != 0) {
Player* newOwnship = (Player*) p->object();
if (newOwnship != ownship) {
// Ok, we found the new ownship and it IS a different
// player then the previous ownship ...
setOwnshipPlayer( newOwnship );
set = true;
}
}
// Cleanup
pl->unref();
pl = 0;
}
return set;
}
// MyObj builder
static MyObj* builder(const char* const filename)
{
// read configuration file
int errors = 0;
Basic::Object* obj = Basic::lcParser(filename, factory, &errors);
if (errors > 0) {
std::cerr << "File: " << filename << ", errors: " << errors << std::endl;
std::exit(EXIT_FAILURE);
}
// test to see if an object was created
if (obj == 0) {
std::cerr << "Invalid configuration file, no objects defined!" << std::endl;
std::exit(EXIT_FAILURE);
}
// do we have a Basic::Pair, if so, point to object in Pair, not Pair itself
Basic::Pair* pair = dynamic_cast<Basic::Pair*>(obj);
if (pair != 0) {
obj = pair->object();
obj->ref();
pair->unref();
}
// try to cast to proper object, and check
MyObj* myObj = dynamic_cast<MyObj*>(obj);
if (myObj == 0) {
std::cerr << "Invalid configuration file!" << std::endl;
std::exit(EXIT_FAILURE);
}
return myObj;
}
// Get the next free weapon of this 'type'
Weapon* SimpleStoresMgr::getSpecificWeapon(const std::type_info& type)
{
Weapon* wpn = 0;
if (&type != 0) {
Basic::PairStream* list = getWeapons();
if (list != 0) {
// Find the first free (inactive) bomb
Basic::List::Item* item = list->getFirstItem();
while (item != 0 && wpn == 0) {
Basic::Pair* pair = (Basic::Pair*)(item->getValue());
Weapon* p = dynamic_cast<Weapon*>( pair->object() );
if (p != 0 && p->isInactive() && p->isClassType(type)) {
p->ref();
wpn = p;
}
item = item->getNext();
}
list->unref();
}
}
return wpn;
}
//------------------------------------------------------------------------------
// getTrackManagerByType() -- return the first track manager of type
//------------------------------------------------------------------------------
TrackManager* OnboardComputer::getTrackManagerByType(const std::type_info& type)
{
TrackManager* p = 0;
Basic::Pair* pair = findByType(type);
if (pair != 0) {
p = dynamic_cast<TrackManager*>( pair->object() );
}
return p;
}
//------------------------------------------------------------------------------
// getTrackManagerByName() -- return a track manager by name
//------------------------------------------------------------------------------
TrackManager* OnboardComputer::getTrackManagerByName(const char* const name)
{
TrackManager* p = 0;
Basic::Pair* pair = findByName(name);
if (pair != 0) {
p = dynamic_cast<TrackManager*>( pair->object() );
}
return p;
}
//------------------------------------------------------------------------------
// outputDevices() -- Process station hardware outputs
//------------------------------------------------------------------------------
void Station::outputDevices(const LCreal dt)
{
if (ioHandlers != 0) {
Basic::List::Item* item = ioHandlers ->getFirstItem();
while (item != 0) {
Basic::Pair* pair = (Basic::Pair*)(item->getValue());
Basic::IoHandler* p = (Basic::IoHandler*)( pair->object() );
p->outputDevices(dt);
item = item->getNext();
}
}
}
//------------------------------------------------------------------------------
// setSlotModeSingle() -- takes a single Mode and inits the mode list
//------------------------------------------------------------------------------
bool RfSensor::setSlotModeSingle(RfSensor* const obj)
{
if (modes != 0) modes->unref();
modes = new Basic::PairStream();
Basic::Pair* p = new Basic::Pair("1",obj);
modes->put( p );
p->unref();
return processModes();
}
//------------------------------------------------------------------------------
// getSymbolIndex() - returns the symbol index for a particular object, if
// it exists in our list of symbols. If it doesn't exist, we return 0.
//------------------------------------------------------------------------------
int SymbolLoader::getSymbolIndex(const BasicGL::Graphic* const mySymbol) const
{
int index = 0;
for (int i = 0; i < MAX_SYMBOLS; i++) {
if (symbols[i] != 0) {
Basic::Pair* p = symbols[i]->getSymbolPair();
BasicGL::Graphic* graph = (BasicGL::Graphic*)p->object();
if (mySymbol == graph) index = (i + 1);
}
}
return index;
}
//-----------------------------------------------------------------------------
// findSelected() -- find the selected graphic from the 'select buffer'.
//
// 1) When item == 0, returns nearest (by depth buffer) entry.
// 2) When item < 0, returns furthest (by depth buffer) entry.
// 3) When item > 0, returns the item'th selected entry or the first entry if
// there are less than 'item' entries
// 4) Returns zero(0) when there are no entries in the select buffer or if the
// Graphic for the select ID is not found.
//-----------------------------------------------------------------------------
BasicGL::Graphic* FoxDisplay::findSelected(const GLuint sbuff[], const int size, const int item)
{
BasicGL::Graphic* sel = nullptr;
GLuint id = 0;
GLuint dmin = 0;
GLuint dmax = 0;
int cnt = 0;
int idx = 0;
while (idx < size && sbuff[idx] > 0) {
int n = sbuff[idx++]; // Number of select names
GLuint xmin = sbuff[idx++]; // Min Depth
GLuint xmax = sbuff[idx++]; // Max Depth
// First select name only
GLuint xId = sbuff[idx++];
for (int i = 1; i < n; i++) { idx++; }
if (cnt == 0) {
// First item
id = xId;
dmin = xmin;
dmax = xmax;
}
else if (item == 0 && xmin < dmin) {
// Nearest --
dmin = xmin;
id = xId;
}
else if (item < 0 && xmax > dmax) {
// Nearest --
dmax = xmax;
id = xId;
}
else if (item == (cnt+1)) {
id = xId;
}
cnt++;
}
// Find the Graphic with this id
if (id > 0) {
//std::cout << "selected id = " << id << std::endl;
Basic::Pair* pair = findBySelectName(id);
if (pair != nullptr) {
sel = dynamic_cast<BasicGL::Graphic*>(pair->object());
if (sel != nullptr) {
return sel;
}
}
}
return sel;
}
//------------------------------------------------------------------------------
// resetStores() -- Reset all stores
//------------------------------------------------------------------------------
void Stores::resetStores(Basic::PairStream* const list)
{
// Reset the external stores
if (list != 0) {
Basic::List::Item* item = list->getFirstItem();
while (item != 0) {
Basic::Pair* pair = static_cast<Basic::Pair*>(item->getValue());
Basic::Component* p = static_cast<Basic::Component*>( pair->object() );
p->event(RESET_EVENT);
item = item->getNext();
}
}
}
void MultiActorAgent::setState(Basic::Ubf::State* const x)
{
if (x == nullptr)
return;
if (state != nullptr)
state->unref();
state = x;
state->ref();
state->container(this);
Basic::Pair* p = new Basic::Pair("", state);
addComponent(p);
p->unref();
}
//------------------------------------------------------------------------------
// setOwnshipPlayer() -- set this player as our ownship
//------------------------------------------------------------------------------
bool Station::setOwnshipPlayer(Player* const newOS)
{
// Is it already own ownship? Yes, then nothing else to do.
if (newOS == ownship) return true;
// When we're just setting a null(0) ownship ...
if (newOS == 0) {
// Unref the old player
if (ownshipName != 0) { ownshipName->unref(); ownshipName = 0; }
if (ownship != 0) {
ownship->event(ON_OWNSHIP_DISCONNECT);
ownship->unref();
ownship = 0;
}
return true;
}
// Look for this ownship in our list of players
bool set = false;
Basic::PairStream* pl = sim->getPlayers();
if (pl != 0) {
Basic::List::Item* item = pl->getFirstItem();
while (item != 0 && !set) {
Basic::Pair* pair = dynamic_cast<Basic::Pair*>(item->getValue());
if (pair != 0) {
Player* ip = dynamic_cast<Player*>( pair->object() );
if (ip == newOS && ip->isLocalPlayer()) {
// Unref the old stuff
if (ownshipName != 0) { ownshipName->unref(); ownshipName = 0; }
if (ownship != 0) {
ownship->event(ON_OWNSHIP_DISCONNECT);
ownship->unref();
ownship = 0;
}
// Ok, we found the player -- make it our ownship
ownship = newOS;
ownship->ref();
ownshipName = pair->slot();
ownshipName->ref();
ownship->event(ON_OWNSHIP_CONNECT);
set = true;
}
}
item = item->getNext();
}
pl->unref();
pl = 0;
}
return set;
}
//------------------------------------------------------------------------------
// build() -- build the table in our components list
//------------------------------------------------------------------------------
void Table::build()
{
Basic::PairStream* newList = 0;
if (rows > 0 && columns != 0) {
newList = new Basic::PairStream();
// For each row: create a TableRow containing all the items in 'columns'
for (unsigned int i = 1; i <= rows; i++) {
// new row
TableRow* row = new TableRow();
row->container(this);
const Basic::List::Item* item = columns->getFirstItem();
while (item != 0) {
const Basic::Pair* pair = static_cast<const Basic::Pair*>(item->getValue());
const Basic::Object* obj = pair->object();
if (obj->isClassType(typeid(BasicGL::Graphic))) {
Basic::Pair* pp = pair->clone();
BasicGL::Graphic* gobj = static_cast<BasicGL::Graphic*>(pp->object());
gobj->container(row);
row->put(pp);
pp->unref();
}
item = item->getNext();
}
// put the row on our components list with a slotname equal to its row number
{
char cbuf[8];
sprintf(cbuf,"%d",i);
Basic::Pair* pp = new Basic::Pair(cbuf,row);
newList->put(pp);
pp->unref();
}
row->unref();
}
// Position our subcomponents
position();
}
// These are new our subcomponents ...
processComponents(newList,typeid(Basic::Component));
if (newList != 0) newList->unref();
}
//------------------------------------------------------------------------------
// reset() -- Reset parameters
//------------------------------------------------------------------------------
void Page::reset()
{
BaseClass::reset();
if (subpages != 0) {
// Reset all of our sub-pages
Basic::List::Item* item = subpages->getFirstItem();
while (item != 0) {
Basic::Pair* pair = (Basic::Pair*)(item->getValue());
Component* obj = (Component*)( pair->object() );
if (obj != 0) obj->reset();
item = item->getNext();
}
}
}
// DATALINK_MESSAGE event handler
bool Datalink::onDatalinkMessageEvent(Basic::Object* const msg)
{
// Just pass it down to all of our subcomponents
Basic::PairStream* subcomponents = getComponents();
if (subcomponents != 0) {
for (Basic::List::Item* item = subcomponents->getFirstItem(); item != 0; item = item->getNext()) {
Basic::Pair* pair = static_cast<Basic::Pair*>(item->getValue());
Basic::Component* sc = static_cast<Basic::Component*>(pair->object());
sc->event(DATALINK_MESSAGE, msg);
}
subcomponents->unref();
subcomponents = 0;
}
return true;
}