MidiData& MidiData::operator=(const MidiData &other)
{
midiLock.lockWait();
clearNotes();
for(int mi = -1; mi < NUM_MIDI_NOTES; mi++)
{
auto iter = other.data.find(mi);
if(iter != other.data.end())
{
data.emplace(mi, std::vector<MidiNote*>());
data[mi].reserve(iter->second.size());
for(auto n : iter->second)
data[mi].push_back(new MidiNote(*n));
}
}
numNotes = other.numNotes;
span = other.span;
midiLock.unlock();
return *this;
}
void ReplayRobHousePage::actionPerformed( GUIComponent *inTarget ) {
if( inTarget == &mDoneButton ) {
mDone = true;
clearNotes();
}
else if( inTarget == &mMusicToggleButton ) {
musicOff = mMusicToggleButton.getToggled();
if( musicOff ) {
setMusicLoudness( 0 );
}
else {
setMusicLoudness( 1 );
}
SettingsManager::setSetting( "musicOff", musicOff );
}
else if( inTarget == &mGridDisplay ) {
if( mGridDisplay.getJustRestarted() ) {
// grid resets itself, but we control backpack slots
// all rings off (cancel any tool use in-progress during restart)
for( int j=0; j<NUM_PACK_SLOTS; j++ ) {
if( mPackSlots[j]->getRingOn() ) {
mPackSlots[j]->setRingOn( false );
}
}
// restore original tool list
inventorySlotsFromString( mPackSlotsString, mPackSlots,
NUM_PACK_SLOTS );
}
else {
int pickedID = mGridDisplay.getToolIDJustPicked();
if( pickedID != -1 ) {
// select one of our matching backpack slots
for( int j=0; j<NUM_PACK_SLOTS; j++ ) {
if( mPackSlots[j]->getObject() == pickedID ) {
mPackSlots[j]->setRingOn( true );
break;
}
}
}
else if( mGridDisplay.getToolJustUsed() ) {
// spend tool from selected slot
for( int j=0; j<NUM_PACK_SLOTS; j++ ) {
if( mPackSlots[j]->getRingOn() ) {
mPackSlots[j]->addToQuantity( -1 );
mPackSlots[j]->setRingOn( false );
break;
}
}
}
}
}
}
void pattern::loadSettings( const QDomElement & _this )
{
unfreeze();
m_patternType = static_cast<PatternTypes>( _this.attribute( "type"
).toInt() );
setName( _this.attribute( "name" ) );
if( _this.attribute( "pos" ).toInt() >= 0 )
{
movePosition( _this.attribute( "pos" ).toInt() );
}
changeLength( MidiTime( _this.attribute( "len" ).toInt() ) );
if( _this.attribute( "muted" ).toInt() != isMuted() )
{
toggleMute();
}
clearNotes();
QDomNode node = _this.firstChild();
while( !node.isNull() )
{
if( node.isElement() &&
!node.toElement().attribute( "metadata" ).toInt() )
{
note * n = new note;
n->restoreState( node.toElement() );
m_notes.push_back( n );
}
node = node.nextSibling();
}
m_steps = _this.attribute( "steps" ).toInt();
if( m_steps == 0 )
{
m_steps = MidiTime::stepsPerTact();
}
ensureBeatNotes();
checkType();
/* if( _this.attribute( "frozen" ).toInt() )
{
freeze();
}*/
emit dataChanged();
updateBBTrack();
}
////////////////////////////////////////////////////////////
//reset the tile
////////////////////////////////////////////////////////////
void TTile::resetTile()
{
clearNotes();
if(tileIsChangeable)
tileValue = 0;
else
parentBoard->tileFilled(true);
hasCoral = false;
coralSize = 0;
mistake = false;
getParentBoard()->updateAllPossibilities();
}
void Cache::softLoad() {
clearNotes();
clearSearches();
qDebug() << "Notes size: " << notes->size();
for(int i=0;i<notes->size();i++){
Note note = notes->at(i);
if (m_sel_notebook) {
if (note.notebookGuid == m_sel_notebook->guid){
NoteWrapper* noteWrapper = new NoteWrapper(note);
noteAdded(noteWrapper);
}
} else {
NoteWrapper* noteWrapper = new NoteWrapper(note);
noteAdded(noteWrapper);
}
}
}
void Cache::load(){
tags = DatabaseManager::instance()->getTags();
notebooks = DatabaseManager::instance()->getNotebooks();
notes = DatabaseManager::instance()->getNotes();
searches = DatabaseManager::instance()->getSavedSearches();
clearNotes();
clearSearches();
qDebug() << "Notes size: " << notes->size();
for(int i=0;i<notes->size();i++){
Note note = notes->at(i);
if (m_sel_notebook) {
if (note.notebookGuid == m_sel_notebook->guid){
NoteWrapper* noteWrapper = new NoteWrapper(note);
noteAdded(noteWrapper);
}
} else {
NoteWrapper* noteWrapper = new NoteWrapper(note);
noteAdded(noteWrapper);
}
}
}
void Pattern::clear()
{
addJournalCheckPoint();
clearNotes();
ensureBeatNotes();
}
long getmodel(Symbolhandle list, long nargs, long startKey, long silent,
Symbolhandle symhWts, Symbolhandle symhOffset,
Symbolhandle symhN)
{
long i, j, i2, inc;
long ny, ndata, nvars, nfactors, nterms, nerrorterms;
long needed, balanced;
long foundNonIntY = 0, foundNonIntN = 0;
long intercept;
long nmissing, nzerowt;
long dim[2];
modelPointer kterm;
Symbolhandle symh;
double tmp;
double *glmoffset, *casewts, *misswts, *ptmp, *factorvar;
double yi, logitni, *y, *logitn, maxlevel;
long caseweights = MODELTYPE & CASEWEIGHTS;
char *ipfwarning =
"WARNING: ipf() cannot be used, poisson() substituted";
modelInfoPointer info = (modelInfoPointer) 0;
WHERE("getmodel");
TRASH(NTRASH,errorExit);
*OUTSTR = '\0';
USEGLMOFFSET = 0;
if (!initmodelparse(STRMODEL) || modelparse() != 0)
{/* parse it */
goto errorExit;
}
info = getModelInfo(); /* retrieve model information */
if((ndata = checkVariables(info)) < 0)
{
goto errorExit;
}
if(!(GLMCONTROL & MULTIVAR) && !isVector(info->modelvars[0]))
{
sprintf(OUTSTR,
"ERROR: non-vector response variable for %s()", FUNCNAME);
goto errorExit;
}
NVARS = nvars = MODELINFO->nvars = info->nvars;
NFACTORS = nfactors = MODELINFO->nfactors = info->nfactors;
NTERMS = nterms = MODELINFO->nterms = info->nterms;
NERRORTERMS = nerrorterms = MODELINFO->nerrorterms = info->nerrorterms;
for(i=0;i<nerrorterms;i++)
{
modeltermAssign((modelPointer) info->errorterms[i],
(modelPointer) MODELINFO->errorterms[i]);
}
/* Note: As of 930601, INTMODEL has been eliminated */
MODEL = info->model;
info->model = (modelHandle) 0;
if(MODELTYPE & (OLSREG|LEAPS))
{
NFACTORS = nfactors = MODELINFO->nfactors = 0;
intercept = 0;
for(j=0;j<nterms;j++)
{
kterm = modelterm(MODEL,j);
if(nvInTerm(kterm) > 1)
{
sprintf(OUTSTR,
"ERROR: crossed variates and/or factors are illegal for %s()",
FUNCNAME);
goto errorExit;
} /*if(nvInTerm(modelterm(MODEL,j)) > 1)*/
if(modeltermEqual(kterm,(modelPointer) NULLTERM))
{
intercept = 1;
}
} /*for(j=0;j<nterms;j++)*/
} /*if(MODELTYPE & (OLSREG|LEAPS))*/
if (MODELTYPE & LEAPS && !intercept)
{
sprintf(OUTSTR,
"ERROR: a model without an intercept is illegal for %s()",
FUNCNAME);
goto errorExit;
}
/* set up MODELVARS */
for (i = 0; i <= nvars; i++)
{
if(MODELVARS[i] != (Symbolhandle) 0)
{
Delete(MODELVARS[i]);
}
MODELVARS[i] = Makesymbol(REAL);
if (MODELVARS[i] == (Symbolhandle) 0)
{
goto errorExit;
}
if (!Copy(info->modelvars[i], MODELVARS[i]))
{
goto errorExit;
}
info->modelvars[i] = (Symbolhandle) 0;
strcpy(VARNAMES[i], NAME(MODELVARS[i]));
if(i < nvars)
{
NCLASSES[i] = info->nclasses[i];
}
clearNotes(MODELVARS[i]);
} /*for (i = 0; i <= nvars; i++)*/
/* set up Y and X */
/* response and factors are known to be matrix or vector */
for (i = 0; i <= nvars; i++)
{
symh = MODELVARS[i];
(void) isMatrix(symh,dim); /* get dimensions */
if (HASLABELS(symh) && NDIMS(symh) != 2)
{
if (!fixupMatLabels(symh, USEBOTHLABELS))
{
goto errorExit;
}
} /*if (HASLABELS(symh) && NDIMS(symh) != 2)*/
else
{
Setdims(symh, 2, dim);
}
if(i == 0)
{
Y = DATA(symh);
ny = dim[1];
NDATA = (double) ndata;
NY = (double) ny;
/* make sure dimensions are correct, always 2 */
} /*if(i == 0)*/
else
{/* i > 0 */
X[i - 1] = DATA(symh);
if (isVariate(i-1))
{
GLMCONTROL |= UNBALANCED;
} /*if (isVariate(i-1))*/
} /*if(i == 0){}else{}*/
if(*OUTSTR)
{
goto errorExit;
}
} /*for (i = 0; i <= nvars; i++)*/
/* check for crossed variates */
for (i = 0; i < nvars-1; i++)
{
if (isVariate(i))
{
/* variable i is a variate */
for (j = 0; j < nterms; j++)
{ /*
find the terms it is in and check to see it is not crossed
with another variate
*/
kterm = modelterm(MODEL,j);
if(inTerm(i,kterm) && nvInTerm(kterm) > 1)
{
/*
j-th term has variable i and there are at least 2
variables or factors in the term.
Check to see if j-th term has another variate
*/
for (i2 = i+1; i2 < nvars; i2++)
{
if (isVariate(i2) && inTerm(i2,kterm))
{
sprintf(OUTSTR,
"ERROR: crossed variates in model are illegal for %s()",
FUNCNAME);
goto errorExit;
} /*if (isVariate(i2) && inTerm(i2,kterm))*/
} /*for (i2 = 0; i2 < nvars; i2++)*/
} /*if(inTerm(i,kterm))*/
} /*for (j = 0; j < nterms; j++)*/
} /*if (isVariate(i))*/
} /*for (i = 0; i < nvars; i++)*/
/* check for case weights, i.e., user specified weights */
if (caseweights)
{
if (symhWts == (Symbolhandle) 0)
{
sprintf(OUTSTR,
"ERROR: no weights given for %s()",FUNCNAME);
}
else if (TYPE(symhWts) != REAL || !isVector(symhWts) ||
symbolSize(symhWts) != ndata)
{
sprintf(OUTSTR,
"ERROR: weights for %s() not REAL vector with length = nrows(%s)",
FUNCNAME, NAME(MODELVARS[0]));
}
else
{
CASEWTS = (double **) mygethandle(ndata * sizeof(double));
if (CASEWTS == (double **) 0)
{
goto errorExit;
}
casewts = *CASEWTS;
doubleCopy( DATAPTR(symhWts), casewts, ndata);
for (i = 0; i < ndata; i++)
{
if (!isMissing(casewts[i]) && casewts[i] < 0)
{
sprintf(OUTSTR,"ERROR: negative case weights for %s()",
FUNCNAME);
break;
}
} /*for (i = 0; i < ndata; i++)*/
}
if(*OUTSTR)
{
goto errorExit;
}
} /* if(caseweights) */
/* check for logistic N */
if (GLMCONTROL & BINOMDIST)
{
if (symhN == (Symbolhandle) 0)
{
sprintf(OUTSTR,"ERROR: no N variable given for %s()", FUNCNAME);
}
else if(!isVector(symhN) || TYPE(symhN) != REAL ||
symbolSize(symhN) != ndata && symbolSize(symhN) != 1)
{
sprintf(OUTSTR,
"ERROR: %s() N not REAL scalar or vector of same length as response",
FUNCNAME);
}
else
{
LOGITN = (double **) mygethandle(ndata * sizeof(double));
if (LOGITN == (double **) 0)
{
goto errorExit;
}
}
if(*OUTSTR)
{
goto errorExit;
}
inc = (symbolSize(symhN) == 1) ? 0 : 1;
i2 = 0;
y = *Y;
logitn = *LOGITN;
ptmp = DATAPTR(symhN);
for (i = 0; i < ndata; i++)
{
yi = y[i];
logitni = logitn[i] = ptmp[i2];
if (!isMissing(yi) && !isMissing(logitni))
{
tmp = floor(logitni);
if (tmp <= 0.0)
{
sprintf(OUTSTR,
"ERROR: N values must be nonnegative for %s()",
FUNCNAME);
}
else if (yi < 0.0 || yi > logitni)
{
sprintf(OUTSTR,
"ERROR: response value out of range for %s()",
FUNCNAME);
}
if(*OUTSTR)
{
goto errorExit;
}
if (!foundNonIntY && yi != floor(yi))
{
foundNonIntY = 1;
}
if (!foundNonIntN && logitni != tmp)
{
foundNonIntN = 1;
}
} /*if (!isMissing(yi) && !isMissing(logitni))*/
i2 += inc;
}/* for (i = 0; i < ndata; i++) */
} /*if (GLMCONTROL & BINOMDIST)*/
else if (GLMCONTROL & POISSONDIST)
{/* check for nonnegative Y in Poisson distributed glm */
y = *Y;
for (i = 0; i < ndata; i++)
{
yi = y[i];
if (!isMissing(yi))
{
if (yi < 0.0)
{
sprintf(OUTSTR,
"ERROR: response variable negative for %s()",
FUNCNAME);
goto errorExit;
}
if (!foundNonIntY && floor(yi) != yi)
{
foundNonIntY = 1;
}
} /*if (!isMissing(yi))*/
} /*for (i = 0; i < ndata; i++)*/
} /*if (glmcontrol & POISSONDIST)*/
if (!silent)
{
if (foundNonIntY)
{
sprintf(OUTSTR,
"WARNING: non-integer value(s) of response variable for %s()",
FUNCNAME);
putErrorOUTSTR();
}
if (foundNonIntN)
{
sprintf(OUTSTR,
"WARNING: non-integer number N of trials for %s()",
FUNCNAME);
putErrorOUTSTR();
}
} /*if (!silent)*/
/* check for user defined glmoffset */
if (symhOffset != (Symbolhandle) 0)
{
if (TYPE(symhOffset) != REAL || !isVector(symhOffset) ||
symbolSize(symhOffset) != ndata)
{
sprintf(OUTSTR,
"ERROR: offsets for %s() not REAL vector nrows(offset) = nrows(response)",
FUNCNAME);
goto errorExit;
}
USEGLMOFFSET = 1;
GLMOFFSET = (double **) mygethandle(ndata * sizeof(double));
if (GLMOFFSET == (double **) 0)
{
goto errorExit;
}
doubleCopy(DATAPTR(symhOffset), *GLMOFFSET, ndata);
} /*if (symhOffset != (Symbolhandle) 0)*/
/* check for missing & fill MISSWTS if any are missing*/
nmissing = countMissing(MODELINFO, &MISSWTS);
if(nmissing < 0)
{
goto errorExit;
}
if(caseweights || GLMCONTROL & BINOMDIST || USEGLMOFFSET)
{
casewts = (caseweights) ? *CASEWTS : (double *) 0;
logitn = (GLMCONTROL & BINOMDIST) ? *LOGITN : (double *) 0;
glmoffset = (USEGLMOFFSET) ? *GLMOFFSET : (double *) 0;
misswts = (nmissing > 0) ? *MISSWTS : (double *) 0;
for (i = 0; i < ndata; i++)
{
if (caseweights && isMissing(casewts[i]) ||
(GLMCONTROL & BINOMDIST) && isMissing(logitn[i]) ||
USEGLMOFFSET && isMissing(glmoffset[i]))
{
if(nmissing == 0)
{
MISSWTS = (double **) mygethandle(ndata * sizeof(double));
if (MISSWTS == (double **) 0)
{
goto errorExit;
}
misswts = *MISSWTS;
doubleFill(misswts, 1.0, ndata);
casewts = (caseweights) ? *CASEWTS : (double *) 0;
logitn = (GLMCONTROL & BINOMDIST) ? *LOGITN : (double *) 0;
glmoffset = (USEGLMOFFSET) ? *GLMOFFSET : (double *) 0;
} /*if(nmissing == 0)*/
if (misswts[i] != 0.0)
{
misswts[i] = 0.0;
nmissing++;
}
}
} /*for (i = 0; i < ndata; i++)*/
} /*if(caseweights || GLMCONTROL & BINOMDIST || USEGLMOFFSET)*/
if(nmissing > 0)
{
MODELTYPE |= MISSWEIGHTS;
GLMCONTROL |= UNBALANCED;
misswts = *MISSWTS;
} /*if(nmissing > 0)*/
/* find the actual maximum factor levels included */
if (nfactors > 0)
{
for (j = 0; j < nvars; j++)
{
if (!isVariate(j))
{
factorvar = *(X[j]);
maxlevel = 0;
for (i = 0;i < ndata; i++)
{
if (!isMissing(factorvar[i]) && factorvar[i] > maxlevel &&
(nmissing == 0 || misswts[i] > 0.0))
{
maxlevel = factorvar[i];
}
} /*for (i = 0;i < ndata; i++)*/
NCLASSES[j] = (long) maxlevel;
} /*if (!isVariate(j))*/
} /*for (j = 0; j < nvars; j++)*/
} /*if (nfactors > 0)*/
if (nmissing > 0 && !silent)
{
putOutErrorMsg("WARNING: cases with missing values deleted");
}
/* check for zero case weights, i.e., user specified weights */
if (caseweights)
{
casewts = *CASEWTS;
misswts = (MODELTYPE & MISSWEIGHTS) ? *MISSWTS : (double *) 0;
nzerowt = 0;
for (i = 0; i < ndata; i++)
{
if ((!(MODELTYPE & MISSWEIGHTS) || misswts[i] > 0.0) &&
casewts[i] == 0)
{
nzerowt++;
}
}
if (nzerowt != 0 && !silent)
{
putOutErrorMsg("WARNING: cases with zero weight completely removed");
}
nmissing += nzerowt;
} /*if (caseweights)*/
NOTMISSING = NDATA - nmissing;
if(NOTMISSING == 0)
{
sprintf(OUTSTR,
"ERROR: no non-missing cases with non-zero weight");
goto errorExit;
}
/*
Check for possible Latin Square or other balanced main effect design
for which balanced computation is appropriate
In the future, we need code to recognize fractional factorials,
confounded factorials, etc
*/
balanced = (!(GLMCONTROL & UNBALANCED) && !(MODELTYPE & FASTANOVA) &&
isBalanced(ONEWAYBALANCE));
if (balanced && nvars > 1)
{
if (anovaEffectsOnly(1))
{
balanced = isBalanced(TWOWAYBALANCE);
}
else
{
balanced = isBalanced(COMPLETEBALANCE);
}
if (balanced < 0)
{
goto errorExit;
}
} /*if (balanced)*/
if(!balanced)
{
GLMCONTROL |= UNBALANCED;
if (MODELTYPE & IPF)
{
MODELTYPE &= ~IPF;
MODELTYPE |= POISSONREG;
if(!silent)
{
putOutErrorMsg(ipfwarning);
}
}
} /*if(!balanced)*/
/* check for incremental deviances specified by extra argument */
if (MODELTYPE & (ITERGLMS | IPF) && !INCREMENTAL &&
nargs > startKey && !isKeyword(COMPVALUE(list,nargs-1)))
{
INCREMENTAL = 1;
}
/*
990319 moved creation of side-effect variables DEPVNAME and
TERMNAMES to glm()
*/
/* save dependent variable name */
needed = strlen(VARNAME(0)) + 1;
DEPVNAME = mygethandle(needed);
if(DEPVNAME == (char **) 0)
{
goto errorExit;
}
/* re-dereference name after memory allocation */
strcpy(*DEPVNAME, VARNAME(0));
/* Create TERMNAMES */
needed = makeTermNames(0); /* get space requirement */
TERMNAMES = mygethandle(needed);
if (TERMNAMES == (char **) 0)
{
goto errorExit;
}
/* now fill in TERMNAMES */
(void) makeTermNames(needed);
emptyTrash();
return (0); /* normal (no error) return */
/* NOTE: cleanup of globals is done in glm after error return */
errorExit:
putErrorOUTSTR();
emptyTrash();
if(info != (modelInfoPointer) 0)
{
mydisphandle((char **) info->model);
MODEL = info->model = (modelHandle) 0;
}
return (1);
} /*getmodel()*/
void Message::setNote(const std::string& type, const std::string& text)
{
clearNotes();
addNote(type, text);
}
void pattern::clear()
{
clearNotes();
ensureBeatNotes();
}
gboolean readNotes(char *filename)
{
GtkWidget *dialog = NULL;
xmlDoc *doc = NULL;
xmlNode *root_element = NULL;
xmlNode *cur_node = NULL;
xmlChar *tmp = NULL;
int slideNum = 0;
/* Clear notes list. */
clearNotes();
/* Try to read the file. */
doc = xmlReadFile(filename, NULL, 0);
if (doc == NULL)
{
dialog = gtk_message_dialog_new(GTK_WINDOW(win_preview),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
"xml: Could not read file.");
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
xmlCleanupParser();
return FALSE;
}
/* Get the root element. */
root_element = xmlDocGetRootElement(doc);
if (root_element == NULL)
{
dialog = gtk_message_dialog_new(GTK_WINDOW(win_preview),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
"xml: Could not get root element.");
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
xmlFreeDoc(doc);
xmlCleanupParser();
return FALSE;
}
/* Traverse slide-elements. */
for (cur_node = root_element->children; cur_node;
cur_node = cur_node->next)
{
if (cur_node->type == XML_ELEMENT_NODE
&& !xmlStrcmp(cur_node->name, BAD_CAST "slide"))
{
/* Get slide number and content. */
tmp = xmlGetProp(cur_node, BAD_CAST "number");
if (tmp == NULL)
continue;
slideNum = atoi((char *)tmp);
xmlFree(tmp);
if (slideNum <= 0)
continue;
tmp = xmlNodeGetContent(cur_node);
if (tmp == NULL)
continue;
/* Replace note text. */
setNote_strdup(slideNum, (char *)tmp);
xmlFree(tmp);
}
}
xmlFreeDoc(doc);
xmlCleanupParser();
return TRUE;
}
void Cache::fireClearNotes() {
clearNotes();
}