Property* DynamicProperty::addDynamicProperty(const char* type, const char* name, const char* group,
const char* doc, short attr, bool ro, bool hidden)
{
Base::BaseClass* base = static_cast<Base::BaseClass*>(Base::Type::createInstanceByName(type,true));
if (!base)
return 0;
if (!base->getTypeId().isDerivedFrom(Property::getClassTypeId())) {
delete base;
std::stringstream str;
str << "'" << type << "' is not a property type";
throw Base::Exception(str.str());
}
// get unique name
Property* pcProperty = static_cast<Property*>(base);
std::string ObjectName;
if (name && *name != '\0')
ObjectName = getUniquePropertyName(name);
else
ObjectName = getUniquePropertyName(type);
pcProperty->setContainer(this->pc);
PropData data;
data.property = pcProperty;
data.group = (group ? group : "");
data.doc = (doc ? doc : "");
data.attr = attr;
data.readonly = ro;
data.hidden = hidden;
props[ObjectName] = data;
return pcProperty;
}
void PropertyModel::buildUp(const std::map<std::string, std::vector<App::Property*> >& props)
{
// fill up the listview with the properties
rootItem->reset();
// sort the properties into their groups
std::map<std::string, std::vector<std::vector<App::Property*> > > propGroup;
std::map<std::string, std::vector<App::Property*> >
::const_iterator jt;
for (jt = props.begin(); jt != props.end(); ++jt) {
App::Property* prop = jt->second.front();
const char* group = prop->getGroup();
std::string grp = group ? group : "Base";
propGroup[grp].push_back(jt->second);
}
std::map<std::string, std::vector<std::vector<App::Property*> > >
::const_iterator kt;
for (kt = propGroup.begin(); kt != propGroup.end(); ++kt) {
// set group item
PropertyItem* group = static_cast<PropertyItem*>(PropertySeparatorItem::create());
group->setParent(rootItem);
rootItem->appendChild(group);
group->setPropertyName(QString::fromAscii(kt->first.c_str()));
// setup the items for the properties
std::vector<std::vector<App::Property*> >::const_iterator it;
for (it = kt->second.begin(); it != kt->second.end(); ++it) {
App::Property* prop = it->front();
QString editor = QString::fromAscii(prop->getEditorName());
if (!editor.isEmpty()) {
Base::BaseClass* item = 0;
try {
item = static_cast<Base::BaseClass*>(Base::Type::
createInstanceByName(prop->getEditorName(),true));
}
catch (...) {
}
if (!item) {
qWarning("No property item for type %s found\n", prop->getEditorName());
continue;
}
if (item->getTypeId().isDerivedFrom(PropertyItem::getClassTypeId())) {
PropertyItem* child = (PropertyItem*)item;
child->setParent(rootItem);
rootItem->appendChild(child);
child->setPropertyName(QString::fromAscii(prop->getName()));
child->setPropertyData(*it);
}
}
}
}
reset();
}
//*****************************************************************************************************
// Document
//*****************************************************************************************************
void Document::slotNewObject(const App::DocumentObject& Obj)
{
//Base::Console().Log("Document::slotNewObject() called\n");
std::string cName = Obj.getViewProviderName();
if (cName.empty()) {
// handle document object with no view provider specified
Base::Console().Log("%s has no view provider specified\n", Obj.getTypeId().getName());
return;
}
setModified(true);
Base::BaseClass* base = static_cast<Base::BaseClass*>(Base::Type::createInstanceByName(cName.c_str(),true));
if (base) {
// type not derived from ViewProviderDocumentObject!!!
assert(base->getTypeId().isDerivedFrom(Gui::ViewProviderDocumentObject::getClassTypeId()));
ViewProviderDocumentObject *pcProvider = static_cast<ViewProviderDocumentObject*>(base);
d->_ViewProviderMap[&Obj] = pcProvider;
try {
// if succesfully created set the right name and calculate the view
//FIXME: Consider to change argument of attach() to const pointer
pcProvider->attach(const_cast<App::DocumentObject*>(&Obj));
pcProvider->updateView();
pcProvider->setActiveMode();
}
catch(const Base::MemoryException& e){
Base::Console().Error("Memory exception in '%s' thrown: %s\n",Obj.getNameInDocument(),e.what());
}
catch(Base::Exception &e){
e.ReportException();
}
#ifndef FC_DEBUG
catch(...){
Base::Console().Error("App::Document::_RecomputeFeature(): Unknown exception in Feature \"%s\" thrown\n",Obj.getNameInDocument());
}
#endif
std::list<Gui::BaseView*>::iterator vIt;
// cycling to all views of the document
for (vIt = d->baseViews.begin();vIt != d->baseViews.end();++vIt) {
View3DInventor *activeView = dynamic_cast<View3DInventor *>(*vIt);
if (activeView)
activeView->getViewer()->addViewProvider(pcProvider);
}
// adding to the tree
signalNewObject(*pcProvider);
}
else {
Base::Console().Warning("Gui::Document::slotNewObject() no view provider for the object %s found\n",cName.c_str());
}
}
void TreeView::rowsInserted (const QModelIndex & parent, int start, int end)
{
QTreeView::rowsInserted(parent, start, end);
if (parent.isValid()) {
Base::BaseClass* ptr = static_cast<Base::BaseClass*>(parent.internalPointer());
// type is defined in DocumentModel.cpp
if (ptr->getTypeId() == Base::Type::fromName("Gui::ApplicationIndex")) {
for (int i=start; i<=end;i++) {
QModelIndex document = this->model()->index(i, 0, parent);
this->expand(document);
}
}
}
}
void TreeView::mouseDoubleClickEvent (QMouseEvent * event)
{
QModelIndex index = indexAt(event->pos());
if (!index.isValid() || index.internalPointer() == Application::Instance)
return;
Base::BaseClass* item = 0;
item = static_cast<Base::BaseClass*>(index.internalPointer());
if (item->getTypeId() == Document::getClassTypeId()) {
QTreeView::mouseDoubleClickEvent(event);
const Gui::Document* doc = static_cast<Gui::Document*>(item);
MDIView *view = doc->getActiveView();
if (!view) return;
getMainWindow()->setActiveWindow(view);
}
else if (item->getTypeId().isDerivedFrom(ViewProvider::getClassTypeId())) {
if (static_cast<ViewProvider*>(item)->doubleClicked() == false)
QTreeView::mouseDoubleClickEvent(event);
}
}
