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 RObject::updateStructure (RData *new_data) { RK_TRACE (OBJECTS); if (new_data->getDataLength () == 0) { // can happen, if the object no longer exists return false; } RK_ASSERT (new_data->getDataLength () >= 5); RK_ASSERT (new_data->getDataType () == RData::StructureVector); if (!canAccommodateStructure (new_data)) return false; bool properties_change = false; properties_change = updateName (new_data->getStructureVector ()[0]); properties_change = updateType (new_data->getStructureVector ()[1]); properties_change = updateClasses (new_data->getStructureVector ()[2]); properties_change = updateMeta (new_data->getStructureVector ()[3]); properties_change = updateDimensions (new_data->getStructureVector ()[4]); if (properties_change) RKGlobals::tracker ()->objectMetaChanged (this); if (type & NeedDataUpdate) updateDataFromR (0); if (isPending ()) type -= Pending; return true; }
bool RObject::updateDimensions (RData *new_data) { RK_TRACE (OBJECTS); RK_ASSERT (new_data->getDataLength () >= 1); RK_ASSERT (new_data->getDataType () == RData::IntVector); bool changed = false; unsigned int new_len = new_data->getDataLength (); int *new_dimensions = new_data->getIntVector (); new_data->detachData (); if (num_dimensions != new_len) { changed = true; } else { for (unsigned int d=0; d < num_dimensions; ++d) { if (dimensions[d] != new_dimensions[d]) { changed = true; break; } } } delete [] dimensions; num_dimensions = new_len; dimensions = new_dimensions; return true; }
bool RObject::updateClasses (RData *new_data) { RK_TRACE (OBJECTS); RK_ASSERT (new_data->getDataLength () >= 1); // or can there be classless objects in R? RK_ASSERT (new_data->getDataType () == RData::StringVector); bool change = false; unsigned int new_len = new_data->getDataLength (); QString *new_classes = new_data->getStringVector (); new_data->detachData (); if (numClasses () != new_len) { change = true; } else { for (unsigned int cn=0; cn < numClasses (); ++cn) { if (classnames[cn] != new_classes[cn]) { change = true; break; } } } num_classes = new_len; delete [] classnames; classnames = new_classes; return change; }
void KHelpDlg::rCommandDone (RCommand *command) { KURL url; if (command->getFlags () == HELP_SEARCH) { resultsList->clear (); RK_ASSERT ((command->getDataLength () % 3) == 0); int count = (command->getDataLength () / 3); for (int i=0; i < count; ++i) { new QListViewItem (resultsList, command->getStringVector ()[i], command->getStringVector ()[count + i], command->getStringVector ()[2*count + i]); } setEnabled(true); } else if (command->getFlags () == GET_HELP_URL) { RK_ASSERT (command->getDataLength ()); url.setPath(command->getStringVector ()[0]); if (QFile::exists (url.path ())) { RKWardMainWindow::getMain ()->openHTML (url); return; } else { KMessageBox::sorry (this, i18n ("No help found on '%1'. Maybe the corresponding package is not installed/loaded, or maybe you mistyped the command. Try using Help->Search R Help for more options.").arg (command->command ().section ("\"", 1, 1)), i18n ("No help found")); } } else if (command->getFlags () == GET_INSTALLED_PACKAGES) { RK_ASSERT (command->getDataType () == RData::StringVector); unsigned int count = command->getDataLength (); for (unsigned int i=0; i < count; ++i) { packagesList->insertItem (command->getStringVector ()[i]); } } else { RK_ASSERT (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) return object->makeClassString ("; "); RK_ASSERT (false); } else if (role == Qt::DecorationRole) { if (col == NameColumn) return RKStandardIcons::iconForObject (object); } else if (role == Qt::ToolTipRole) { return object->getObjectDescription (); } return QVariant (); }
void RObjectList::rCommandDone (RCommand *command) { RK_TRACE (OBJECTS); if (command->getFlags () == ROBJECTLIST_UPDATE_ENVIRONMENTS_COMMAND) { RK_ASSERT (command->getDataType () == RData::StructureVector); const RData::RDataStorage & data = command->structureVector (); RK_ASSERT (data.size () == 2); QStringList new_environments = data[0]->stringVector (); RK_ASSERT (new_environments.size () >= 2); updateEnvironments (new_environments, true); updateNamespaces (data[1]->stringVector ()); RKGlobals::rInterface ()->issueCommand (QString (), RCommand::App | RCommand::Sync | RCommand::EmptyCommand, QString (), this, ROBJECTLIST_UPDATE_COMPLETE_COMMAND, update_chain); } else if (command->getFlags () == ROBJECTLIST_UPDATE_COMPLETE_COMMAND) { RK_ASSERT (update_chain); RKGlobals::rInterface ()->closeChain (update_chain); update_chain = 0; RK_DEBUG (OBJECTS, DL_DEBUG, "object list update complete"); emit (updateComplete ()); } else { RK_ASSERT (false); } }
void RKWorkplace::attachWindow (RKMDIWindow *window) { RK_TRACE (APP); RK_ASSERT (windows.contains (window)); // This should not happen for now. if (!window->isAttached ()) { QWidget *old_parent = window->parentWidget (); window->prepareToBeAttached (); if (old_parent && qobject_cast<DetachedWindowContainer*> (old_parent)) { old_parent->deleteLater (); } } // all the rest is done, even if the window was previously "Attached", as this may also mean it was freshly created window->state = RKMDIWindow::Attached; if (window->isToolWindow ()) { window->tool_window_bar->reclaimDetached (window); } else { view ()->addWindow (window); view ()->topLevelWidget ()->raise (); view ()->topLevelWidget ()->activateWindow (); } RK_ASSERT (window->getPart ()); RKWardMainWindow::getMain ()->partManager ()->addPart (window->getPart ()); }
bool RObject::updateMeta (RData *new_data) { RK_TRACE (OBJECTS); RK_ASSERT (new_data->getDataType () == RData::StringVector); unsigned int len = new_data->getDataLength (); if (len == 1) len = 0; // if it's a single element, it's just a dummy bool change = false; if (len) { if (!meta_map) meta_map = new MetaMap; meta_map->clear (); RK_ASSERT (!(len % 2)); unsigned int cut = len/2; for (unsigned int i=0; i < cut; ++i) { meta_map->insert (new_data->getStringVector ()[i], new_data->getStringVector ()[i+cut]); } type |= HasMetaObject; // TODO: only signal change, if there really was a change! change = true; } else { // no meta data received if (meta_map) { delete meta_map; meta_map = 0; change = true; } type -= (type & HasMetaObject); } return change; }
void RKVariable::setLength (int len) { RK_TRACE (OBJECTS); RK_ASSERT (!getLength ()); // should only be called once RK_ASSERT (dimensions); dimensions[0] = len; }
bool RKVarEditModel::setData (const QModelIndex& index, const QVariant& value, int role) { RK_TRACE (EDITOR); if (!index.isValid ()) return false; int row = index.row (); int col = index.column (); if (edit_blocks || (role != Qt::EditRole) || (col >= apparentCols ()) || (row >= apparentRows ())) { RK_ASSERT (false); return false; } if (col >= objects.size ()) { // trailing col // somebody should add a column for us doInsertColumns (objects.size (), 1); if (col >= objects.size ()) { // apparently, no column has been added in the above signal return false; } } if (row >= objects[0]->getLength ()) { // trailing row insertRows (objects[0]->getLength (), 1); } // edit of normal cells RKVariable* var = objects[col]; RK_ASSERT (var); var->setText (row, value.toString ()); return true; }
QModelIndex RCommandStackModel::index (int row, int column, const QModelIndex& parent) const { RK_ASSERT (listeners > 0); RK_TRACE (RBACKEND); RCommandBase* index_data = 0; if (!parent.isValid ()) { index_data = RCommandStack::regular_stack; } else { RCommandBase* parent_index = static_cast<RCommandBase*> (parent.internalPointer ()); RK_ASSERT (parent_index); // parent is a command -> this must be a substack if (parent_index->commandPointer ()) { RK_ASSERT (parent.row () == 0); index_data = RCommandStack::stackForCommand (parent_index->commandPointer ())->sub_stack; RK_ASSERT (index_data); } else { // parent is a chain or stack RCommandChain *chain = parent_index->chainPointer (); if (chain->commands.size () <= row) { RK_ASSERT (false); return QModelIndex (); } index_data = chain->commands[row]; } } return (createIndex (row, column, index_data)); }
void signal_proxy (int signum) { rk_sighandler_t r_handler = r_sigsegv_handler; rk_sighandler_t default_handler = default_sigsegv_handler; #else void signal_proxy (int signum, siginfo_t *info, void *context) { struct sigaction r_handler = r_sigsegv_handler; struct sigaction default_handler = default_sigsegv_handler; #endif if (signum == SIGILL) { r_handler = r_sigill_handler; default_handler = default_sigill_handler; } else if (signum == SIGABRT) { r_handler = r_sigabrt_handler; default_handler = default_sigabrt_handler; } else { RK_ASSERT (signum == SIGSEGV); } RKRBackend::tryToDoEmergencySave (); // if we are not in the R thread, handling the signal in R does more harm than good. if (RKRBackendProtocolBackend::inRThread ()) { #ifdef Q_WS_WIN if (r_handler) { r_handler (signum); return; } #else if (r_handler.sa_sigaction) { r_handler.sa_sigaction (signum, info, context); return; } else if (r_handler.sa_handler) { r_handler.sa_handler (signum); return; } #endif } #ifdef Q_WS_WIN if (default_handler) { default_handler (signum); return; } #else // this might be a Qt/KDE override or default handling if (default_handler.sa_sigaction) { default_handler.sa_sigaction (signum, info, context); return; } else if (default_handler.sa_handler) { default_handler.sa_handler (signum); return; } #endif RK_ASSERT (false); // had not handler? Could conceivably happen, but should not. signal (signum, SIG_DFL); raise (signum); } }
bool RObject::canAccommodateStructure (RData *new_data) { RK_TRACE (OBJECTS); RK_ASSERT (new_data->getDataLength () >= 5); RK_ASSERT (new_data->getDataType () == RData::StructureVector); if (!isValidName (new_data->getStructureVector ()[0])) return false; if (!isValidType (new_data->getStructureVector ()[1])) return false; return true; }
void RKGraphicsDeviceFrontendTransmitter::setupServer () { RK_TRACE (GRAPHICS_DEVICE); RK_ASSERT (!local_server); local_server = new QLocalServer (); RK_ASSERT (local_server->listen ("rkd" + KRandom::randomString (8))); connect (local_server, SIGNAL (newConnection ()), this, SLOT (newConnection())); server_name = local_server->fullServerName (); }
bool RObject::isValidType (RData *new_data) const { RK_TRACE (OBJECTS); RK_ASSERT (new_data->getDataLength () == 1); RK_ASSERT (new_data->getDataType () == RData::IntVector); int new_type = new_data->getIntVector ()[0]; if (!isMatchingType (type, new_type)) return false; return true; }
RThread::RThread () : QThread (), REmbedInternal () { RK_TRACE (RBACKEND); current_command = 0; RK_ASSERT (this_pointer == 0); this_pointer = this; RK_ASSERT (this_pointer); current_output = 0; out_buf_len = 0; output_paused = false; }
void RKWorkplace::attachWindow (RKMDIWindow *window) { RK_TRACE (APP); RK_ASSERT (windows.find (window) != windows.end ()); // This should not happen for now. window->prepareToBeAttached (); window->state = RKMDIWindow::Attached; view ()->addPage (window); RK_ASSERT (window->getPart ()); RKWardMainWindow::getMain ()->partManager ()->addPart (window->getPart ()); }
RKGraphicsDeviceBackendTransmitter::RKGraphicsDeviceBackendTransmitter (QIODevice* _connection, bool is_q_local_socket) : QThread () { RK_TRACE (GRAPHICS_DEVICE); RK_ASSERT (!connection); RK_ASSERT (_connection); connection = _connection; streamer.setIODevice (connection); alive = true; is_local_socket = is_q_local_socket; start (); }
void RKVarEditDataFrameModel::childAdded (int index, RObject* parent) { RK_TRACE (EDITOR); if (parent == dataframe) { RObject* child = dataframe->findChildByIndex (index); RK_ASSERT (child); if (child->isVariable ()) addObject (index + var_col_offset, static_cast<RKVariable*> (child)); else RK_ASSERT (false); } }
bool RFunctionObject::updateStructure (RData *new_data) { RK_TRACE (OBJECTS); RK_ASSERT (new_data->getDataLength () >= 5); RK_ASSERT (new_data->getDataType () == RData::StructureVector); if (!RObject::updateStructure (new_data)) return false; if (updateArguments (new_data)) RKGlobals::tracker ()->objectMetaChanged (this); return true; }
void RObjectViewerWidget::update () { RK_TRACE (APP); RK_ASSERT (outstanding_commands.isEmpty ()); RK_ASSERT (_object); setText (i18n ("Fetching information. Please wait.")); update_button->setEnabled (false); cancel_button->setEnabled (true); }
bool RObject::isValidName (RData *new_data) { RK_TRACE (OBJECTS); RK_ASSERT (new_data->getDataLength () == 1); RK_ASSERT (new_data->getDataType () == RData::StringVector); if (name != new_data->getStringVector ()[0]) { RK_ASSERT (false); name = new_data->getStringVector ()[0]; return false; } return true; }
double *RKVariable::getNumeric (int from_row, int to_row) { RK_TRACE (OBJECTS); if (to_row >= getLength ()) { RK_ASSERT (false); return 0; } RK_ASSERT (from_row <= to_row); // TODO: no, this is not good. Return a _copy_! // we simply return the whole array starting at the given offset for now. Change this, if the storage mechanism gets changed! return &(myData ()->cell_doubles[from_row]); }
void RCommand::mergeAndDeleteProxy (RCommandProxy *proxy) { RK_TRACE (RBACKEND); RK_ASSERT (proxy); RK_ASSERT (proxy->id == _id); RK_ASSERT (proxy->type == _type); status = proxy->status; has_been_run_up_to = proxy->has_been_run_up_to; swallowData (*proxy); delete proxy; }
RCommandProxy* RCommand::makeProxy () const { RK_TRACE (RBACKEND); RK_ASSERT (status == 0); // Initialization from an already touched command is not a real problem, but certainly no expected usage RK_ASSERT (has_been_run_up_to == 0); RK_ASSERT (getDataType () == RData::NoData); RCommandProxy *ret = new RCommandProxy (_command, _type); ret->id = _id, ret->status = status; ret->has_been_run_up_to = has_been_run_up_to; return ret; }
QVariant RCommandStackModel::data (const QModelIndex& index, int role) const { RK_ASSERT (listeners); RK_TRACE (RBACKEND); if (!index.isValid ()) return QVariant (); RK_ASSERT (index.model () == this); RCommandBase* index_data = static_cast<RCommandBase*> (index.internalPointer ()); if (index_data->commandPointer ()) { RCommand *command = index_data->commandPointer (); if ((index.column () == MAIN_COL) && (role == Qt::DisplayRole)) return (command->command ()); if ((index.column () == FLAGS_COL) && (role == Qt::DisplayRole)) { QString ret; if (command->type () & RCommand::User) ret += 'U'; if (command->type () & RCommand::Plugin) ret += 'P'; if (command->type () & RCommand::PluginCom) ret += 'C'; if (command->type () & RCommand::App) ret += 'A'; if (command->type () & RCommand::Sync) ret += 'S'; if (command->type () & RCommand::EmptyCommand) ret += 'E'; if (command->type () & (RCommand::GetIntVector | RCommand::GetRealVector | RCommand::GetStringVector)) ret += 'D'; if (command->type () & RCommand::DirectToOutput) ret += 'O'; return (ret); } if ((index.column () == STATUS_COL) && (role == Qt::DisplayRole)) { QString ret; if (command->status & RCommand::Running) ret += i18n ("Running"); if (command->status & RCommand::Canceled) { if (!ret.isEmpty ()) ret += ", "; ret += i18n ("Cancelled"); } return (ret); } if ((index.column () == DESC_COL) && (role == Qt::DisplayRole)) { return (command->rkEquivalent ()); } } if (index_data->chainPointer ()) { RCommandChain* chain = index_data->chainPointer (); if (chain->isStack ()) { if ((index.column () == MAIN_COL) && (role == Qt::DisplayRole)) return (i18n ("Command Stack")); } else { if ((index.column () == MAIN_COL) && (role == Qt::DisplayRole)) return (i18n ("Command Chain")); if ((index.column () == STATUS_COL) && (role == Qt::DisplayRole)) { if (chain->closed) return (i18n ("Closed")); return (i18n ("Waiting")); } } } return (QVariant ()); }
Qt::ItemFlags RCommandStackModel::flags (const QModelIndex& index) const { RK_ASSERT (listeners); RK_TRACE (RBACKEND); if (!index.isValid ()) return 0; RK_ASSERT (index.model () == this); RCommandBase* index_data = static_cast<RCommandBase*> (index.internalPointer ()); RK_ASSERT (index_data); if (index_data->commandPointer ()) return (Qt::ItemIsSelectable | Qt::ItemIsEnabled); return Qt::ItemIsEnabled; }
QModelIndex RKObjectListModel::index (int row, int column, const QModelIndex& parent) const { RK_TRACE (OBJECTS); if (!parent.isValid ()) { RK_ASSERT (row == 0); // must cast to RObject, here. Else casting to void* and back will confuse the hell out of GCC 4.2 return (createIndex (row, column, static_cast<RObject *> (RObjectList::getObjectList ()))); } RObject* parent_object = static_cast<RObject*> (parent.internalPointer ()); RK_ASSERT (row < parent_object->numChildrenForObjectModel ()); return (createIndex (row, column, parent_object->findChildByObjectModelIndex (row))); }
bool RObject::updateName (RData *new_data) { RK_TRACE (OBJECTS); RK_ASSERT (new_data->getDataLength () == 1); RK_ASSERT (new_data->getDataType () == RData::StringVector); bool changed = false; if (name != new_data->getStringVector ()[0]) { changed = true; RK_ASSERT (false); name = new_data->getStringVector ()[0]; } return changed; }