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