bool RKObjectListViewSettings::filterAcceptsRow (int source_row, const QModelIndex& source_parent) const {
// RK_TRACE (APP);
// So I tried to use a KRecursiveFilterProxyModel, but
// a) we don't really want recursion to the full depth. Thus limiting it, here.
// b) While we don't handle insertions / removals of source indices in the presence of a filter, correctly, with KRecursiveFilterProxyModel
// I got crashes on this (arguably with the depth-limit in place)
if (acceptRow (source_row, source_parent)) return true;
RObject *parent = static_cast<RObject*> (source_parent.internalPointer ());
if (!parent) {
RK_ASSERT (parent); // should have been accepted, above
return true;
}
RObject *object = parent->findChildByObjectModelIndex (source_row);
if (!object) {
RK_ASSERT (object); // should have been accepted, above
RK_DEBUG (APP, DL_ERROR, "row %d of %d in %s", source_row, sourceModel ()->rowCount (source_parent), qPrintable (parent->getShortName ()));
return false;
}
if (object->isType (RObject::ToplevelEnv | RObject::Workspace) || ((depth_limit > 0) && parent->isType (RObject::ToplevelEnv | RObject::Workspace))) {
QModelIndex source_index = sourceModel ()->index (source_row, 0, source_parent);
for (int row = 0, rows = sourceModel()->rowCount (source_index); row < rows; ++row) {
if (filterAcceptsRow (row, source_index)) return true;
}
}
return false;
}
bool RKObjectListViewSettings::acceptRow (int source_row, const QModelIndex& source_parent) const {
// RK_TRACE (APP);
// always show the root item
if (!source_parent.isValid ()) return true;
RObject* object = static_cast<RObject*> (source_parent.internalPointer ());
// always show global env and search path
if (!object) return true;
if (!object->findChildByObjectModelIndex (source_row)) {
return true;
}
object = object->findChildByObjectModelIndex (source_row);
RK_ASSERT (object);
if (!persistent_settings[ShowObjectsHidden]) {
if (object->getShortName ().startsWith ('.')) return false;
if (object == reinterpret_cast<RObject*> (RObjectList::getObjectList ()->orphanNamespacesObject ())) return false;
}
if (hide_functions && object->isType (RObject::Function)) return false;
if (hide_non_functions && !object->isType (RObject::Function)) return false;
if (filterRegExp ().isEmpty ()) return true;
if (filter_on_name && object->getShortName ().contains (filterRegExp ())) return true;
if (filter_on_label && object->getLabel ().contains (filterRegExp ())) return true;
if (filter_on_class) {
QStringList cnames = object->classNames ();
for (int i = cnames.length () - 1; i >= 0; --i) {
if (cnames[i].contains (filterRegExp ())) return true;
}
}
return false;
}
QVariant RKObjectListModel::data (const QModelIndex& index, int role) const {
RK_TRACE (OBJECTS);
int col = index.column ();
RObject *object = static_cast<RObject*> (index.internalPointer ());
if ((!object) || (col >= ColumnCount)) {
RK_ASSERT (false);
return QVariant ();
}
if (role == Qt::DisplayRole) {
if (col == NameColumn) return object->getShortName ();
if (col == LabelColumn) return object->getLabel ();
if (col == TypeColumn) {
if (object->isVariable ()) return RObject::typeToText (object->getDataType ());
return QVariant ();
}
if ((col == ClassColumn) && (!object->isPseudoObject ())) return object->makeClassString ("; ");
} else if (role == Qt::FontRole) {
if (col == NameColumn && object->isPseudoObject ()) {
QFont font;
font.setItalic (true);
return (font);
}
} else if (role == Qt::DecorationRole) {
if (col == NameColumn) return RKStandardIcons::iconForObject (object);
} else if (role == Qt::ToolTipRole) {
return object->getObjectDescription ();
}
return QVariant ();
}
void RObjectList::updateEnvironments (const QStringList &_env_names, bool force_globalenv_update) {
RK_TRACE (OBJECTS);
RObjectMap newchildmap;
QStringList env_names = _env_names;
if (!env_names.isEmpty ()) {
QString dummy = env_names.takeFirst ();
RK_ASSERT (dummy == ".GlobalEnv");
if (force_globalenv_update) {
// for now, we only update the .GlobalEnv. All others we assume to be static
getGlobalEnv ()->updateFromR (update_chain);
}
} else {
RK_ASSERT (!env_names.isEmpty ());
}
// find which items are new, and copy the old ones
for (int i = 0; i < env_names.count (); ++i) {
QString name = env_names[i];
RObject *obj = findChildByName (name);
if (obj && (i > 0) && (env_names.lastIndexOf (name, i-1) > -1)) { // duplicate environment names can happen (e.g. if a data.frame is attached multiple times)
obj = 0; // only copy the old item once
}
if (!obj) {
obj = createTopLevelEnvironment (name);
RKGlobals::tracker ()->beginAddObject (obj, this, i);
childmap.insert (i, obj);
RKGlobals::tracker ()->endAddObject (obj, this, i);
}
newchildmap.insert (i, obj);
}
// check which envs have been removed or changed position
for (int i = 0; i < childmap.size (); ++i) { // do *not* cache the childmap.size ()! We may change it in the loop.
RObject *obj = childmap[i];
int new_pos = newchildmap.indexOf (obj);
if (new_pos < 0) { // environment is gone
RK_DEBUG (OBJECTS, DL_INFO, "removing toplevel environment %s from list", obj->getShortName ().toLatin1 ().data ());
if (RKGlobals::tracker ()->removeObject (obj, 0, true)) --i;
else (newchildmap.insert (i, obj));
} else if (new_pos != i) {
// this call is rather expensive, all in all, but fortunately called very rarely
moveChild (obj, i, new_pos);
}
}
RK_DO (RK_ASSERT (childmap == newchildmap), OBJECTS, DL_DEBUG); // this is an expensive assert, hence wrapping it inside RK_DO
}
RKEditor *RKWorkplace::editObject (RObject *object, bool initialize_to_empty) {
RK_TRACE (APP);
RObject *iobj = object;
RKEditor *ed = 0;
RKEditorDataFramePart *part = 0;
RKEditor *existing_editor = object->objectOpened ();
if (!existing_editor) {
if (object->isDataFrame ()) {
part = new RKEditorDataFramePart (0); // TODO: reverse creation logic, just as in the other classes!
ed = part->getEditor ();
// TODO: add child objects, too?
ed->openObject (object, initialize_to_empty);
} else if (object->isVariable () && object->getContainer ()->isDataFrame ()) {
existing_editor = object->getContainer ()->objectOpened ();
if (!existing_editor) {
iobj = object->getContainer ();
part = new RKEditorDataFramePart (0);
ed = part->getEditor ();
// TODO: add child objects, too?
ed->openObject (iobj, initialize_to_empty);
// ed->focusObject (obj);
}
}
if (ed) {
ed->setCaption (iobj->getShortName ()); // TODO: move to editor
ed->setIcon (SmallIcon ("spreadsheet"));
addWindow (ed);
ed->setFocus (); // somehow we need to call this explicitly
}
}
if (existing_editor) { // not strictly an else. existing_editor may be reset inside the above if
existing_editor->activate ();
ed = existing_editor;
}
return ed;
}
bool RKVarEditDataFrameModel::insertColumns (int column, int count, const QModelIndex& parent) {
RK_TRACE (EDITOR);
if (parent.isValid ()) {
RK_ASSERT (false);
return false;
}
if (column > trueCols ()) column = trueCols ();
if (column < var_col_offset) column = var_col_offset;
for (int col = column; col < (column + count); ++col) {
RObject *obj = dataframe->createPendingChild (dataframe->validizeName (QString ()), col-var_col_offset);
RK_ASSERT (obj->isVariable ());
// addObject (col, obj); // the object will be added via RKModificationTracker::addObject -> this::childAdded. That will also take care of calling beginInsertColumns()/endInsertColumns()
RKGlobals::rInterface ()->issueCommand (new RCommand (".rk.data.frame.insert.column (" + dataframe->getFullName () + ", \"" + obj->getShortName () + "\", " + QString::number (col+1-var_col_offset) + ")", RCommand::App | RCommand::Sync));
}
return true;
}
