/*
* TODO XXX FIXME WTF this seems incredibly dangerous legacy code ... it's unused fortunately but should be fully deprecated
*/
bool
QuasiStack::GetFrameMap(frame_map_hdr *&map)
{
short i;
frame_map_hdr *p;
long map_len;
map_len = sizeof(frame_map_hdr) * (countFrames()+1);
map_len += stackable->countControllers()*(sizeof(StabEnt *));
map_len += countFrames()*(sizeof(QuasiStack *));
char *cmap = (char *)malloc(map_len);
map = (frame_map_hdr *)cmap;
p = map;
p->context = context;
p->frame_handle = this;
p->n_children = countFrames();
p->n_controller = stackable->countControllers();
p->status = locusStatus;
cmap += sizeof(frame_map_hdr);
StabEnt **q = (StabEnt **)cmap;
for (i=0; i<stackable->countControllers(); i++) {
*q = stackable->controller(i);
q++;
}
cmap += sizeof(StabEnt *) * stackable->countControllers();
QuasiStack **r = (QuasiStack **)cmap;
for (i=0; i<countFrames(); i++) {
if (frameAt(i)) {
// fprintf(stderr, "\tname %s\n", stackable->Controller(i)->uniqueName());
}
*r++ = frameAt(i);
}
return true;
}
QTextFrame *QTextDocumentPrivate::insertFrame(int start, int end, const QTextFrameFormat &format)
{
Q_ASSERT(start >= 0 && start < length());
Q_ASSERT(end >= 0 && end < length());
Q_ASSERT(start <= end || end == -1);
if (start != end && frameAt(start) != frameAt(end))
return 0;
beginEditBlock();
QTextFrame *frame = qobject_cast<QTextFrame *>(createObject(format));
Q_ASSERT(frame);
// #### using the default block and char format below might be wrong
int idx = formats.indexForFormat(QTextBlockFormat());
QTextCharFormat cfmt;
cfmt.setObjectIndex(frame->objectIndex());
int charIdx = formats.indexForFormat(cfmt);
insertBlock(QTextBeginningOfFrame, start, idx, charIdx, QTextUndoCommand::MoveCursor);
insertBlock(QTextEndOfFrame, ++end, idx, charIdx, QTextUndoCommand::KeepCursor);
frame->d_func()->fragment_start = find(start).n;
frame->d_func()->fragment_end = find(end).n;
insert_frame(frame);
endEditBlock();
return frame;
}
void QTextDocumentPrivate::insert_frame(QTextFrame *f)
{
int start = f->firstPosition();
int end = f->lastPosition();
QTextFrame *parent = frameAt(start-1);
Q_ASSERT(parent == frameAt(end+1));
if (start != end) {
// iterator over the parent and move all children contained in my frame to myself
for (int i = 0; i < parent->d_func()->childFrames.size(); ++i) {
QTextFrame *c = parent->d_func()->childFrames.at(i);
if (start < c->firstPosition() && end > c->lastPosition()) {
parent->d_func()->childFrames.removeAt(i);
f->d_func()->childFrames.append(c);
c->d_func()->parentFrame = f;
}
}
}
// insert at the correct position
int i = 0;
for (; i < parent->d_func()->childFrames.size(); ++i) {
QTextFrame *c = parent->d_func()->childFrames.at(i);
if (c->firstPosition() > end)
break;
}
parent->d_func()->childFrames.insert(i, f);
f->d_func()->parentFrame = parent;
}
bool VideoFrameSource_sV::rebuildRequired(const FrameSize frameSize)
{
bool needsRebuild = false;
QImage frame = frameAt(0, frameSize);
needsRebuild |= frame.isNull();
frame = frameAt(m_videoInfo->framesCount-1, frameSize);
needsRebuild |= frame.isNull();
return needsRebuild;
}
bool VideoFrameSource_sV::rebuildRequired(const FrameSize frameSize)
{
bool needsRebuild = false;
QImage frame = frameAt(0, frameSize);
needsRebuild |= frame.isNull();
//qDebug() << "last frame to check " << m_videoInfo->framesCount-1;
// rewind a little bit to account rounding error...
frame = frameAt(m_videoInfo->framesCount-10, frameSize);
needsRebuild |= frame.isNull();
return needsRebuild;
}
status_t
QuasiStack::LoadSnapshotChildren(tinyxml2::XMLElement *element, std::vector<std::string> textFragments)
{
tinyxml2::XMLNode*childNode = element->FirstChildElement();
int childStackCount = 0;
while (childNode != nullptr) {
tinyxml2::XMLText *textNode;
tinyxml2::XMLElement *elementNode;
if ((textNode = childNode->ToText()) != nullptr) {
textFragments.push_back(textNode->Value());
}
else if ((elementNode = childNode->ToElement()) != nullptr) {
const char *namestr = elementNode->Value();
if (namestr == "stack") {
QuasiStack *child = nullptr;
if (childStackCount < countFrames()) {
child = frameAt(childStackCount);
}
if (child) {
child->LoadSnapshotElement(elementNode);
}
childStackCount++;
} else {
LoadSnapshotElement(elementNode);
}
}
childNode = childNode->NextSibling();
}
return B_OK;
}
int ApiTrace::numCallsInFrame(int idx) const
{
const ApiTraceFrame *frame = frameAt(idx);
if (frame) {
return frame->numTotalCalls();
} else {
return 0;
}
}
void Debugger::traceArgumentsString(PrintWriter& prw)
{
DebugStackFrame* frame = (DebugStackFrame*)frameAt(0);
int count;
Atom* arr;
if (frame && frame->arguments(arr, count))
{
for(int i=0; i<count; i++)
{
prw << asAtom(arr[i]);
if (i+1 < count)
prw << ",";
}
}
}
Stringp Debugger::traceArgumentsString()
{
Stringp args = core->kEmptyString;
DebugStackFrame* frame = (DebugStackFrame*)frameAt(0);
int count;
Atom* arr;
if (frame && frame->arguments(arr, count))
{
Stringp comma = core->newConstantStringLatin1(",");
for(int i=0; i<count; i++)
{
args = core->concatStrings(args, core->format(arr[i]));
if (i+1 < count)
args = core->concatStrings(args, comma);
}
}
return args;
}
status_t
QuasiStack::SaveSnapshot(ostream &out, const char *label)
{
status_t err=B_NO_ERROR;
bool saveChildStacks = true;
if (stackable) {
bool saveBinaryValues = true;
bool saveSymbolicValues = true;
if (stackable->stackSize > 0 && saveBinaryValues) {
out << "<stack name=\"" << label << "\" length=\"" << stackable->stackSize << "\" encoding=\"base64\">" << endl;
std::string outb = Base64::Encode((uchar *)vars, stackable->stackSize);
out << outb << endl;
}
else {
out << "<stack name=\"" << label << "\">" << endl;
}
if (stackable->sym) {
StabEnt *p = stackable->sym->children;
while (p!= nullptr) {
switch (p->type) {
case TypedValue::S_BOOL:
case TypedValue::S_SHORT:
case TypedValue::S_BYTE:
case TypedValue::S_INT:
case TypedValue::S_TIME:
case TypedValue::S_FLOAT:
case TypedValue::S_LONG:
case TypedValue::S_DOUBLE: {
if (p->refType == TypedValue::REF_STACK) {
err=p->SaveSimpleTypeSnapshot(out, stacker, this);
}
break;
}
case TypedValue::S_CHANNEL: {
if (p->refType == TypedValue::REF_STACK) {
err=p->SaveSimpleTypeSnapshot(out, stacker, this);
}
break;
}
case TypedValue::S_TAKE: {
break;
}
case TypedValue::S_CLIP: {
if (p->refType == TypedValue::REF_STACK) {
err=p->SaveSimpleTypeSnapshot(out, stacker, this);
}
break;
}
}
p = p->sibling;
}
}
} else {
out << "<stack name=\""<<label<<"\">"<<endl;
}
if (saveChildStacks) {
for (short i=0; i<countFrames(); i++) {
QuasiStack *s = frameAt(i);
std::string chlabel = "child";
if (s->callingBlock) {
switch (s->callingBlock->type) {
case Block::C_CALL:
if (s->callingBlock->crap.call.crap.lambda) {
chlabel = s->callingBlock->crap.call.crap.lambda->sym->name;
} else {
chlabel = "call";
}
break;
case Block::C_VST:
if (s->callingBlock->crap.call.crap.vstplugin) {
chlabel = s->callingBlock->crap.call.crap.vstplugin->sym->name;
} else {
chlabel = "vst";
}
break;
case Block::C_GENERIC_PLAYER:
case Block::C_MIDI_PLAYER:
case Block::C_SAMPLE_PLAYER:
case Block::C_TUNEDSAMPLE_PLAYER:
case Block::C_STREAM_PLAYER:
case Block::C_MARKOV_PLAYER:
chlabel = findClipPlayer(s->callingBlock->type);
break;
}
}
s->SaveSnapshot(out, chlabel.c_str());
}
}
out <<"</stack>"<<endl;
return err;
}
void Plot::onPickerMoved( const QPointF& pos )
{
const int idx = frameAt( pos.x() );
if ( idx >= 0 )
Q_EMIT cursorMoved( idx );
}
void QTextDocumentPrivate::move(int pos, int to, int length, QTextUndoCommand::Operation op)
{
Q_ASSERT(to <= fragments.length() && to <= pos);
Q_ASSERT(pos >= 0 && pos+length <= fragments.length());
Q_ASSERT(blocks.length() == fragments.length());
if (pos == to)
return;
const bool needsInsert = to != -1;
#if !defined(QT_NO_DEBUG)
const bool startAndEndInSameFrame = (frameAt(pos) == frameAt(pos + length - 1));
const bool endIsEndOfChildFrame = (isAncestorFrame(frameAt(pos), frameAt(pos + length - 1))
&& text.at(find(pos + length - 1)->stringPosition) == QTextEndOfFrame);
const bool startIsStartOfFrameAndEndIsEndOfFrameWithCommonParent
= (text.at(find(pos)->stringPosition) == QTextBeginningOfFrame
&& text.at(find(pos + length - 1)->stringPosition) == QTextEndOfFrame
&& frameAt(pos)->parentFrame() == frameAt(pos + length - 1)->parentFrame());
const bool isFirstTableCell = (qobject_cast<QTextTable *>(frameAt(pos + length - 1))
&& frameAt(pos + length - 1)->parentFrame() == frameAt(pos));
Q_ASSERT(startAndEndInSameFrame || endIsEndOfChildFrame || startIsStartOfFrameAndEndIsEndOfFrameWithCommonParent || isFirstTableCell);
#endif
beginEditBlock();
split(pos);
split(pos+length);
uint dst = needsInsert ? fragments.findNode(to) : 0;
uint dstKey = needsInsert ? fragments.position(dst) : 0;
uint x = fragments.findNode(pos);
uint end = fragments.findNode(pos+length);
uint w = 0;
while (x != end) {
uint n = fragments.next(x);
uint key = fragments.position(x);
uint b = blocks.findNode(key+1);
QTextBlockData *B = blocks.fragment(b);
int blockRevision = B->revision;
QTextFragmentData *X = fragments.fragment(x);
QTextUndoCommand c = { QTextUndoCommand::Removed, true,
op, X->format, X->stringPosition, key, { X->size },
blockRevision };
QTextUndoCommand cInsert = { QTextUndoCommand::Inserted, true,
op, X->format, X->stringPosition, dstKey, { X->size },
blockRevision };
if (key+1 != blocks.position(b)) {
// qDebug("remove_string from %d length %d", key, X->size);
Q_ASSERT(noBlockInString(text.mid(X->stringPosition, X->size)));
w = remove_string(key, X->size, op);
if (needsInsert) {
insert_string(dstKey, X->stringPosition, X->size, X->format, op);
dstKey += X->size;
}
} else {
// qDebug("remove_block at %d", key);
Q_ASSERT(X->size == 1 && isValidBlockSeparator(text.at(X->stringPosition)));
b = blocks.previous(b);
B = 0;
c.command = blocks.size(b) == 1 ? QTextUndoCommand::BlockDeleted : QTextUndoCommand::BlockRemoved;
w = remove_block(key, &c.blockFormat, QTextUndoCommand::BlockAdded, op);
if (needsInsert) {
insert_block(dstKey++, X->stringPosition, X->format, c.blockFormat, op, QTextUndoCommand::BlockRemoved);
cInsert.command = blocks.size(b) == 1 ? QTextUndoCommand::BlockAdded : QTextUndoCommand::BlockInserted;
cInsert.blockFormat = c.blockFormat;
}
}
appendUndoItem(c);
if (B)
B->revision = undoState;
x = n;
if (needsInsert)
appendUndoItem(cInsert);
}
if (w)
unite(w);
Q_ASSERT(blocks.length() == fragments.length());
endEditBlock();
}
