示例#1
0
文件: Parser.C 项目: LifeGo/wt
  void setMemberName(const StrValue& value)
  {
    assert(state() == InObject);

    currentValue_ = &((currentObject())[s_.str()] = Value::Null);
    s_.clear();
  }
示例#2
0
bool CanvasObjectManager::testObjectDiscarding()
{
   /* This test validate if every objects is discarded by the right events
    * 
    * 
    */
   m_DisableTransition = true;
   bool success = true;

   //First, lets test "ANY"
   for (int j=0;j<ELEMENT_COUNT;j++) {
      if (OBJ_DEF(j).outEvent == CanvasEvent::ANY) {
         for (int index=1;index<EVENT_COUNT;index++) {
            const CanvasEvent event = eventIndexToFlag(index);
            CanvasObjectManager::Object next = static_cast<CanvasObjectManager::Object>(j);
            reset();
            initiateInTransition(next);
            newEvent(static_cast<CanvasEvent>(event));
            if ((next == currentObject() && m_slEvents[index] != next)
               && !(next == currentObject() && currentObject() == CanvasObjectManager::Object::NoObject )) {
               qDebug() << "testObjectDiscarding failed with ANY, was" << j << "is" << (int)m_CurrentObject << event << (event == CanvasEvent::ANY);
               success = false;
            }
         }
      }
   }

   for (int j=0;j<ELEMENT_COUNT;j++) {
      if (OBJ_DEF(j).outEvent != CanvasEvent::ANY) {
         for (int index=2;index<EVENT_COUNT;index++) {
            CanvasObjectManager::Object next = static_cast<CanvasObjectManager::Object>(j);
            reset();
            initiateInTransition(next);
            const CanvasEvent event = eventIndexToFlag(index);
            newEvent(static_cast<CanvasEvent>(event));
            if ( OBJ_DEF(next).outEvent & event && next == currentObject() ) {
               qDebug() << "ntestObjectDiscarding failed, event #" << index << "should discard" << (int)next;
               success = false;
            }
         }
      }
   }

   qDebug() << "\n\n\ntestObjectDiscarding"<<success;
   return false;
}
示例#3
0
void OsgForm::setupUserInterface()
{
    QVBoxLayout *vbl = dynamic_cast<QVBoxLayout*>(ui->leftWidget->layout());

    if (vbl) {
        vbl->insertWidget(0, m_viewToolBar);
        vbl->insertWidget(0, m_viewMenuBar);

        QMenu *viewmenu = new QMenu("view");
        viewmenu->addAction("top");
        viewmenu->addAction("front");
        viewmenu->addAction("right");

        m_viewMenuBar->addMenu(viewmenu);

        m_viewToolBar->addAction("hello");
        m_viewToolBar->addAction("goodBye");

        m_viewToolBar->hide();
        m_viewMenuBar->hide();
    }


    buildLayerBox();
    connect(ui->osgTreeWidget, SIGNAL(currentObject(osg::ref_ptr<osg::Object>)),
            ui->osgPropertyTable, SLOT(displayObject(osg::ref_ptr<osg::Object>)));
    connect(&m_loadWatcher, SIGNAL(finished()),
            this, SLOT(readNodesFinished()));
    connect(&m_saveWatcher, SIGNAL(finished()),
            this, SLOT(wrieNodesFinished()) );
    connect(ui->osgPropertyTable, SIGNAL(itemChanged(QTableWidgetItem*)),
            this, SLOT(itemWasChangedInTable(QTableWidgetItem*)));
    connect(ui->osgTreeWidget, SIGNAL(itemChanged(QTreeWidgetItem*,int)),
            this, SLOT(itemWasChangedInTree(QTreeWidgetItem*, int)));
    connect(ui->cameraMaskLineEdit, SIGNAL(editingFinished()),
            this, SLOT(setCameraMaskFromLineEdit()));

    QList<int> sz;
    sz.append(100);
    for (int i=1 ; i < ui->splitterLeftRight->children().size() ; i++)
        sz.append(0);
    ui->splitterLeftRight->setSizes(sz);

    ui->splitter->setStretchFactor(0, 1);
    ui->splitter->setStretchFactor(1, 0);
    ui->splitter->setStretchFactor(2, 0);

    ui->progressBar->hide();
    this->setCameraMask(ui->osg3dView->getCamera()->getCullMask());

    QRegExpValidator *rev = new QRegExpValidator(QRegExp("[0-9a-fA-F]{1,8}"));
    ui->cameraMaskLineEdit->setValidator(rev);

}
示例#4
0
void TilesetDocument::removeTiles(const QList<Tile *> &tiles)
{
    // Switch current object to the tileset when it is one of the removed tiles
    for (Tile *tile : tiles) {
        if (tile == currentObject()) {
            setCurrentObject(mTileset.data());
            break;
        }
    }

    mTileset->removeTiles(tiles);
    emit tilesetChanged(mTileset.data());
}
示例#5
0
// Paint the current picture to the given device
void PlayGround::drawGameboard( QPainter &artist, const QRect &area ) const
{
  artist.drawPixmap(area.topLeft(), gameboard, area);

  artist.setPen(white);
  for (int text = 0; text < texts; text++)
    drawText(artist, textsLayout[text], textsList[text]);

  artist.setPen(black);
  for (QPtrListIterator<ToDraw> currentObject(toDraw);
       currentObject.current();
       ++currentObject)
    currentObject.current()->draw(artist, area, objectsLayout, &gameboard, &masks);
}
示例#6
0
void
ModelEdit::slotEditObject()
{
    BusinessObject* object = currentObject();
    if (object == NULL) {
	qApp->beep();
	QMessageBox::critical(this, tr("Error"), "No object selected");
	return;
    }

    ObjectEdit* edit = new ObjectEdit(this, *object);
    edit->show();
    _objectEdits.push_back(edit);
}
示例#7
0
void
ModelEdit::slotRemoveObject()
{
    BusinessObject* object = currentObject();
    if (object == NULL) {
	qApp->beep();
	QMessageBox::critical(this, tr("Error"), "No object selected");
	return;
    }

    QString name = object->name;
    QString message = "Are you sure you want to remove \"" + name + "\"";
    int result = QMessageBox::warning(this, "Warning", message,
				      QMessageBox::No, QMessageBox::Yes);
    if (result != QMessageBox::Yes) return;

    remove(*object);
}
示例#8
0
std::vector<ModelObject> getRecursiveChildrenAndResources(const ModelObject& object) {
  std::set<Handle> resultSet;
  std::pair<HandleSet::const_iterator,bool> insertResult;
  std::vector<ModelObject> result;
  resultSet.insert(object.handle());
  result.push_back(object);

  std::deque<ModelObject> objectQueue;
  objectQueue.push_back(object);

  while (objectQueue.size() > 0) {
    ModelObject currentObject(objectQueue[0]);
    objectQueue.pop_front();
    // resources
    for (const ResourceObject& resource : currentObject.resources()) {
      insertResult = resultSet.insert(resource.handle());
      if (insertResult.second) {
        // new object
        ModelObject mo = resource.cast<ModelObject>();
        result.push_back(mo);
        objectQueue.push_back(mo);
      }
    }
    // children
    OptionalParentObject opo = currentObject.optionalCast<ParentObject>();
    if (opo) {
      ParentObject currentParent(*opo);
      for (const ModelObject& child : currentParent.children()) {
        insertResult = resultSet.insert(child.handle());
        if (insertResult.second) {
          // new object
          result.push_back(child);
          objectQueue.push_back(child);
        }
      }
    }
  }

  return result;
}
示例#9
0
void ObjectDatabase::loadFromXml(const std::string filePath){
  
  tinyxml2::XMLDocument doc;
  doc.LoadFile(filePath.c_str());
  
  if (!doc.Error()) {
    
    tinyxml2::XMLElement * xeObject = doc.FirstChildElement()->FirstChildElement("object");
    
    while(xeObject)
    {
      Object currentObject(xeObject);
      objectDb_.push_back(currentObject);
      xeObject = xeObject->NextSiblingElement("object");
    }
  }
  else {
  
    std::cout << "Document Parsing Error: " << filePath << "exiting" << std::endl;
    exit(EXIT_FAILURE);
  }
}
示例#10
0
void
ModelEdit::refreshObjects()
{
    BusinessObject* oldObject = currentObject();
    QListViewItem* current = NULL;

    _objects->clear();
    for (unsigned int i = 0; i < _curr.objects.size(); ++i) {
	const BusinessObject& object = _curr.objects[i];

	ListViewItem* lvi = new ListViewItem(_objects);
	lvi->setValue(0, object.name);
	if (object.number != -1)
	    lvi->setValue(1, object.number);
	lvi->setValue(2, object.description);

	if (oldObject != NULL && object.name == oldObject->name)
	    current = lvi;
    }

    if (current == NULL) current = _objects->firstChild();
    _objects->setCurrentItem(current);
    _objects->setSelected(current, true);
}
void MRmiServerPrivateSocket::invoke(QDataStream& stream)
{
    char* className   = 0;
    char* methodName  = 0;
    quint16 arglength = 0;

    QVariant arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9;

    stream >> arglength >> className >> methodName;
    switch (arglength) {
    case 0:
        QMetaObject::invokeMethod(currentObject(),
                                  methodName);
        break;
    case 1:
        stream >> arg0;
        QMetaObject::invokeMethod(currentObject(),
                                  methodName,
                                  unmarshall(arg0.typeName(),
                                             arg0.data()));

        break;
    case 2:
        stream >> arg0 >> arg1;
        QMetaObject::invokeMethod(currentObject(),
                                  methodName,
                                  unmarshall(arg0.typeName(),
                                             arg0.data()),
                                  unmarshall(arg1.typeName(),
                                             arg1.data()));
        break;
    case 3:
        stream >> arg0 >> arg1 >> arg2;
        QMetaObject::invokeMethod(currentObject(),
                                  methodName,
                                  unmarshall(arg0.typeName(),
                                             arg0.data()),
                                  unmarshall(arg1.typeName(),
                                             arg1.data()),
                                  unmarshall(arg2.typeName(),
                                             arg2.data()));
        break;
    case 4:
        stream >> arg0 >> arg1 >> arg2 >> arg3;
        QMetaObject::invokeMethod(currentObject(),
                                  methodName,
                                  unmarshall(arg0.typeName(),
                                             arg0.data()),
                                  unmarshall(arg1.typeName(),
                                             arg1.data()),
                                  unmarshall(arg2.typeName(),
                                             arg2.data()),
                                  unmarshall(arg3.typeName(),
                                             arg3.data()));
        break;
    case 5:
        stream >> arg0 >> arg1 >> arg2 >> arg3 >> arg4;
        QMetaObject::invokeMethod(currentObject(),
                                  methodName,
                                  unmarshall(arg0.typeName(),
                                             arg0.data()),
                                  unmarshall(arg1.typeName(),
                                             arg1.data()),
                                  unmarshall(arg2.typeName(),
                                             arg2.data()),
                                  unmarshall(arg3.typeName(),
                                             arg3.data()),
                                  unmarshall(arg4.typeName(),
                                             arg4.data()));
        break;
    case 6:
        stream >> arg0 >> arg1 >> arg2 >> arg3 >> arg4 >> arg5;
        QMetaObject::invokeMethod(currentObject(),
                                  methodName,
                                  unmarshall(arg0.typeName(),
                                             arg0.data()),
                                  unmarshall(arg1.typeName(),
                                             arg1.data()),
                                  unmarshall(arg2.typeName(),
                                             arg2.data()),
                                  unmarshall(arg3.typeName(),
                                             arg3.data()),
                                  unmarshall(arg4.typeName(),
                                             arg4.data()),
                                  unmarshall(arg5.typeName(),
                                             arg5.data()));
        break;
    case 7:
        stream >> arg0 >> arg1 >> arg2 >> arg3 >> arg4 >> arg5 >> arg6;
        QMetaObject::invokeMethod(currentObject(),
                                  methodName,
                                  unmarshall(arg0.typeName(),
                                             arg0.data()),
                                  unmarshall(arg1.typeName(),
                                             arg1.data()),
                                  unmarshall(arg2.typeName(),
                                             arg2.data()),
                                  unmarshall(arg3.typeName(),
                                             arg3.data()),
                                  unmarshall(arg4.typeName(),
                                             arg4.data()),
                                  unmarshall(arg5.typeName(),
                                             arg5.data()),
                                  unmarshall(arg6.typeName(),
                                             arg6.data()));
        break;
    case 8:
        stream >> arg0 >> arg1 >> arg2 >> arg3 >> arg4 >> arg5 >> arg6 >> arg7;
        QMetaObject::invokeMethod(currentObject(),
                                  methodName,
                                  unmarshall(arg0.typeName(),
                                             arg0.data()),
                                  unmarshall(arg1.typeName(),
                                             arg1.data()),
                                  unmarshall(arg2.typeName(),
                                             arg2.data()),
                                  unmarshall(arg3.typeName(),
                                             arg3.data()),
                                  unmarshall(arg4.typeName(),
                                             arg4.data()),
                                  unmarshall(arg5.typeName(),
                                             arg5.data()),
                                  unmarshall(arg6.typeName(),
                                             arg6.data()),
                                  unmarshall(arg7.typeName(),
                                             arg7.data()));
        break;
    case 9:
        stream >> arg0 >> arg1 >> arg2 >> arg3 >> arg4 >> arg5 >> arg6 >> arg7
        >> arg8;
        QMetaObject::invokeMethod(currentObject(),
                                  methodName,
                                  unmarshall(arg0.typeName(),
                                             arg0.data()),
                                  unmarshall(arg1.typeName(),
                                             arg1.data()),
                                  unmarshall(arg2.typeName(),
                                             arg2.data()),
                                  unmarshall(arg3.typeName(),
                                             arg3.data()),
                                  unmarshall(arg4.typeName(),
                                             arg4.data()),
                                  unmarshall(arg5.typeName(),
                                             arg5.data()),
                                  unmarshall(arg6.typeName(),
                                             arg6.data()),
                                  unmarshall(arg7.typeName(),
                                             arg7.data()),
                                  unmarshall(arg8.typeName(),
                                             arg8.data()));
        break;
    case 10:
        stream >> arg0 >> arg1 >> arg2 >> arg3 >> arg4 >> arg5 >> arg6 >> arg7
        >> arg8 >> arg9;
        QMetaObject::invokeMethod(currentObject(),
                                  methodName,
                                  unmarshall(arg0.typeName(),
                                             arg0.data()),
                                  unmarshall(arg1.typeName(),
                                             arg1.data()),
                                  unmarshall(arg2.typeName(),
                                             arg2.data()),
                                  unmarshall(arg3.typeName(),
                                             arg3.data()),
                                  unmarshall(arg4.typeName(),
                                             arg4.data()),
                                  unmarshall(arg5.typeName(),
                                             arg5.data()),
                                  unmarshall(arg6.typeName(),
                                             arg6.data()),
                                  unmarshall(arg7.typeName(),
                                             arg7.data()),
                                  unmarshall(arg8.typeName(),
                                             arg8.data()),
                                  unmarshall(arg9.typeName(),
                                             arg9.data()));
        break;
    default:
        break;

    }

    delete[] className;
    delete[] methodName;
    method_size = 0;
}