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; }