void ScoreView::lyricsReturn()
{
Lyrics* lyrics = (Lyrics*)editObject;
Segment* segment = lyrics->segment();
endEdit();
_score->startCmd();
Lyrics* oldLyrics = lyrics;
lyrics = static_cast<Lyrics*>(Element::create(lyrics->type(), _score));
lyrics->setTrack(oldLyrics->track());
lyrics->setParent(segment->element(oldLyrics->track()));
lyrics->setNo(oldLyrics->no() + 1);
_score->undoAddElement(lyrics);
_score->select(lyrics, SELECT_SINGLE, 0);
startEdit(lyrics, -1);
mscore->changeState(mscoreState());
adjustCanvasPosition(lyrics, false);
_score->setLayoutAll(true);
_score->end2();
_score->end1();
}
void ScoreView::lyricsReturn()
{
Lyrics* lyrics = toLyrics(editData.element);
changeState(ViewState::NORMAL);
_score->startCmd();
int newVerse;
newVerse = lyrics->no() + 1;
Lyrics* oldLyrics = lyrics;
lyrics = new Lyrics(_score);
lyrics->setTrack(oldLyrics->track());
lyrics->setParent(oldLyrics->segment()->element(oldLyrics->track()));
lyrics->setPlacement(oldLyrics->placement());
lyrics->setPropertyFlags(Pid::PLACEMENT, oldLyrics->propertyFlags(Pid::PLACEMENT));
lyrics->setNo(newVerse);
_score->undoAddElement(lyrics);
_score->endCmd();
_score->select(lyrics, SelectType::SINGLE, 0);
startEdit(lyrics, Grip::NO_GRIP);
adjustCanvasPosition(lyrics, false);
}
bool setText(const QString& text) {
startEdit();
bool ret = m_document->setText(text);
endEdit();
ModificationRevision::clearModificationCache(m_url);
return ret;
}
void
TextBuffer::insertChar( char c, TextLoc& loc ) {
startEdit( loc,loc);
TextLoc p = loc;
loc.chr = _lines[loc.line].addChar(c, loc.chr);
endEdit( p, loc );
}
void ScoreView::startEdit(Element* element, int startGrip)
{
editObject = element;
startEdit();
if (startGrip == -1)
curGrip = grips-1;
else if (startGrip >= 0)
curGrip = startGrip;
}
void
TextBuffer::removeLineBreak( TextLoc &loc ) {
loc.line--;
loc.chr = _lines[loc.line].size();
startEdit ( loc, TextLoc( loc.line+1 , 0 ) );
_lines[loc.line].str() += _lines[loc.line+1].str();
_lines.erase(_lines.begin() + loc.line + 1 );
endEdit(loc, loc);
}
void ScoreView::lyricsUpDown(bool up, bool end)
{
Lyrics* lyrics = toLyrics(editData.element);
int track = lyrics->track();
ChordRest* cr = lyrics->chordRest();
int verse = lyrics->no();
Placement placement = lyrics->placement();
PropertyFlags pFlags = lyrics->propertyFlags(Pid::PLACEMENT);
if (up) {
if (verse == 0)
return;
--verse;
}
else {
++verse;
if (verse > cr->lastVerse(placement))
return;
}
changeState(ViewState::NORMAL);
lyrics = cr->lyrics(verse, placement);
if (!lyrics) {
lyrics = new Lyrics(_score);
lyrics->setTrack(track);
lyrics->setParent(cr);
lyrics->setNo(verse);
lyrics->setPlacement(placement);
lyrics->setPropertyFlags(Pid::PLACEMENT, pFlags);
_score->startCmd();
_score->undoAddElement(lyrics);
_score->endCmd();
}
_score->select(lyrics, SelectType::SINGLE, 0);
startEdit(lyrics, Grip::NO_GRIP);
mscore->changeState(mscoreState());
adjustCanvasPosition(lyrics, false);
lyrics = toLyrics(editData.element);
TextCursor* cursor = lyrics->cursor(editData);
if (end) {
cursor->movePosition(QTextCursor::Start, QTextCursor::MoveAnchor);
cursor->movePosition(QTextCursor::End, QTextCursor::KeepAnchor);
}
else {
cursor->movePosition(QTextCursor::End, QTextCursor::MoveAnchor);
cursor->movePosition(QTextCursor::Start, QTextCursor::KeepAnchor);
}
_score->setLayoutAll();
_score->update();
}
void ScoreView::startEdit(Element* element, Grip startGrip)
{
if (!element || !element->isEditable()) {
qDebug("The element cannot be edited");
return;
}
editObject = element;
startEdit();
if (startGrip == Grip::NO_GRIP)
curGrip = defaultGrip;
else
curGrip = startGrip;
}
void
TextBuffer::insertSpan( std::string s, TextSpan &span ) {
startEdit( span.begin, span.end );
if ( !span.empty() ) removeSpan(span);
for ( t_CKUINT i=0; i < s.size(); i++) {
if ( s[i] == '\n' ) insertLine( span.end );
else insertChar( s[i], span.end );
}
endEdit ( span.begin, span.end );
}
void
TextBuffer::removeChar(TextLoc &loc ) {
if ( loc.chr == 0 && loc.line == 0 ) {
return;
}
else if ( loc.chr == 0 && loc.line > 0 ) {
removeLineBreak(loc);
}
else {
startEdit( loc.shift(0,-1), loc);
_lines[loc.line].remChar(loc.chr--);
endEdit(loc,loc);
}
}
void ScoreView::lyricsUpDown(bool up, bool end)
{
Lyrics* lyrics = toLyrics(editObject);
int track = lyrics->track();
ChordRest* cr = lyrics->chordRest();
int verse = lyrics->no();
Element::Placement placement = lyrics->placement();
if (placement == Element::Placement::ABOVE)
up = !up;
if (up) {
if (verse == 0)
return;
--verse;
}
else {
++verse;
if (verse > cr->lastVerse(placement))
return;
}
endEdit();
_score->startCmd();
lyrics = cr->lyrics(verse, placement);
if (!lyrics) {
lyrics = new Lyrics(_score);
lyrics->setTrack(track);
lyrics->setParent(cr);
lyrics->setNo(verse);
lyrics->setPlacement(placement);
_score->undoAddElement(lyrics);
}
_score->select(lyrics, SelectType::SINGLE, 0);
startEdit(lyrics, Grip::NO_GRIP);
mscore->changeState(mscoreState());
adjustCanvasPosition(lyrics, false);
if (end) {
((Lyrics*)editObject)->movePosition(QTextCursor::Start, QTextCursor::MoveAnchor);
((Lyrics*)editObject)->movePosition(QTextCursor::End, QTextCursor::KeepAnchor);
}
else {
((Lyrics*)editObject)->movePosition(QTextCursor::End, QTextCursor::MoveAnchor);
((Lyrics*)editObject)->movePosition(QTextCursor::Start, QTextCursor::KeepAnchor);
}
_score->setLayoutAll();
_score->update();
}
bool replace(const KTextEditor::Range& range, const QString& oldText,
const QString& newText, bool ignoreOldText) {
QString old = m_document->text(range);
if(oldText != old && !ignoreOldText) {
return false;
}
startEdit();
bool ret = m_document->replaceText(range, newText);
endEdit();
ModificationRevision::clearModificationCache(m_url);
return ret;
}
// Works for HTML Documents, http links etc
// if it starts with file:, then fire off the filename
void ExecuteFile(LPSTR FileName)
{
if (strncmp(FileName, "file:", 5) == 0) {
//find the line number
char Buffer[MAX_PATH];
char* s = strrchr(FileName, ':');
int LineNo;
if (s != NULL) {
int i;
s++;
for (i = 0; s[i] != 0; i++) {
if (!isdigit(s[i])) {
s = NULL;
break;
}
}
}
if (s == NULL)
LineNo = 0; // the null line
else {
s[-1] = 0;
LineNo = atoi(s);
}
FileName += 5; /* skip over "file:" */
if (strncmp("{Hugs}", FileName, 6) == 0) {
strcpy(Buffer, hugsdir());
strcat(Buffer, &FileName[6]);
} else if (IsRelativeFile(FileName)) {
GetCurrentDirectory(MAX_PATH, Buffer);
if (!IsSeparatorChar(Buffer[strlen(Buffer) - 1]))
strcat(Buffer, "\\");
strcat(Buffer, FileName);
} else
strcpy(Buffer, FileName);
startEdit(LineNo, Buffer);
} else {
int Res = (int) ShellExecute(hThisWindow, NULL, FileName, NULL, NULL, SW_SHOWNORMAL);
if (Res <= 32) {
char Buffer[MAX_PATH*2];
strcpy(Buffer, "Failed to launch file:\n");
strcat(Buffer, FileName);
MessageBox(hThisWindow, Buffer, "Hugs98", MB_ICONWARNING);
}
}
}
void
RecurringMaster::slotPost()
{
if (!saveItem(true)) return;
Gltx gltx;
if (!_quasar->db()->lookup(_curr.gltxId(), gltx)) {
QMessageBox::critical(this, tr("Error"), tr("Can't read transaction"));
return;
}
QDate nextDue = _curr.nextDue();
if (nextDue > QDate::currentDate()) {
QString message = tr("The next due date is in the future\n"
"so this will post a future transaction.\n"
"Are you sure you want to do this?");
int choice = QMessageBox::warning(this, tr("Warning"), message,
tr("Yes"), tr("No"));
if (choice != 0) return;
}
if (_curr.cardGroup() != INVALID_ID) {
CardSelect conditions;
conditions.group_id = _curr.cardGroup();
vector<Card> cards;
_quasar->db()->select(cards, conditions);
for (unsigned int i = 0; i < cards.size(); ++i)
if (!postOne(gltx, cards[i].id()))
return;
} else {
if (!postOne(gltx, gltx.cardId()))
return;
}
int postingCnt = _curr.postingCount();
int maxPostings = _curr.maxPostings();
Recurring old = _curr;
_curr.setLastPosted(nextDue);
_curr.setPostingCount(++postingCnt);
if (maxPostings > 0 && postingCnt >= maxPostings)
_quasar->db()->setActive(_curr, false);
_quasar->db()->update(old, _curr);
_id = _curr.id();
startEdit();
}
void ScoreView::lyricsReturn()
{
Lyrics* lyrics = (Lyrics*)editObject;
Segment* segment = lyrics->segment();
endEdit();
_score->startCmd();
Lyrics* oldLyrics = lyrics;
int newVerse;
if (lyrics->placeAbove()) {
newVerse = oldLyrics->no() - 1;
if (newVerse == -1) {
// raise all lyrics above
newVerse = 0;
for (Segment* s = _score->firstSegment(Segment::Type::ChordRest); s; s = s->next1(Segment::Type::ChordRest)) {
ChordRest* cr = s->cr(lyrics->track());
if (cr) {
for (Lyrics* l : cr->lyrics()) {
if (l->placement() == oldLyrics->placement())
l->undoChangeProperty(P_ID::VERSE, l->no() + 1);
}
}
}
}
}
else
newVerse = oldLyrics->no() + 1;
lyrics = static_cast<Lyrics*>(Element::create(lyrics->type(), _score));
lyrics->setTrack(oldLyrics->track());
lyrics->setParent(segment->element(oldLyrics->track()));
lyrics->setPlacement(oldLyrics->placement());
lyrics->setNo(newVerse);
_score->undoAddElement(lyrics);
_score->select(lyrics, SelectType::SINGLE, 0);
startEdit(lyrics, Grip::NO_GRIP);
mscore->changeState(mscoreState());
adjustCanvasPosition(lyrics, false);
_score->setLayoutAll();
_score->update();
}
void ScoreView::lyricsUpDown(bool up, bool end)
{
Lyrics* lyrics = static_cast<Lyrics*>(editObject);
int track = lyrics->track();
ChordRest* cr = lyrics->chordRest();
int verse = lyrics->no();
const QList<Lyrics*>* ll = &lyrics->chordRest()->lyricsList();
if (up) {
if (verse == 0)
return;
--verse;
}
else {
++verse;
if (verse >= ll->size())
return;
}
endEdit();
_score->startCmd();
lyrics = ll->value(verse);
if (!lyrics) {
lyrics = new Lyrics(_score);
lyrics->setTrack(track);
lyrics->setParent(cr);
lyrics->setNo(verse);
_score->undoAddElement(lyrics);
}
_score->select(lyrics, SELECT_SINGLE, 0);
startEdit(lyrics, -1);
mscore->changeState(mscoreState());
adjustCanvasPosition(lyrics, false);
if (end)
((Lyrics*)editObject)->moveCursorToEnd();
else
((Lyrics*)editObject)->moveCursorToStart();
_score->setLayoutAll(true);
_score->end2();
_score->end1();
}
void
TextBuffer::insertLine( TextLoc &loc ) {
TextLoc p = loc;
// fprintf(stderr, "inserting line break\n");
startEdit( loc,loc );
addLine("", loc.line + 1);
if ( loc.chr < _lines[loc.line].size() ) {
std::string l1 = _lines[loc.line].str();
std::string l2 = _lines[loc.line+1].str();
_lines[loc.line+1].str() = l1.substr( loc.chr, l1.size() - loc.chr );
_lines[loc.line].str() = l1.substr( 0, loc.chr );
}
loc.chr = 0;
loc.line++;
endEdit(p, loc);
// _viewportDirty = true;
// _canvasDirty = true;
}
void
TextBuffer::removeSpan( TextSpan &span ) {
checkSpan(span); //also checks
//start new edit
startEdit( span.begin, span.end );
if ( span.begin.line == span.end.line ) {
std::string orig = _lines[span.begin.line].str();
_lines[span.begin.line].str() = orig.substr(0, span.begin.chr) + orig.substr( span.end.chr, orig.size() );
}
else {
//concatenate first to last;
_lines[span.begin.line].str() = _lines[span.begin.line].substr(0, span.begin.chr) \
+ _lines[span.end.line].substr( span.end.chr, _lines[span.end.line].size() );
for ( int i = span.end.line; i > span.begin.line; i-- )
//if pointers - delete _lines[i];
_lines.erase(_lines.begin()+i);
}
span.end = span.begin;
endEdit( span.begin, span.end );
}
void RendererWidget::enableTransformationMode(int mode)
{
if(_editMode == SCENE_EDITOR && _stateReady == NO_INTERACTION)
{
switch(mode)
{
case 0:
_stateReady = TRANSLATE_MODE;
break;
case 1:
_stateReady = SCALE_MODE;
break;
case 2:
_stateReady = ROTATE_MODE;
break;
}
emit startEdit();
emit stateChanged(_stateReady);
}
}
LogViewer::LogViewer(QWidget *parent) :
QWidget(parent),
ui(new Ui::LogViewer),
logModel(log::QsoLog::getModel())
{
ui->setupUi(this);
if(logModel == NULL) {
qCritical() << "Log Viewer: don't have valid QSO log data model";
} else {
ui->qsoLogTable->setModel(logModel);
}
ui->qsoLogTable->verticalHeader()->setVisible(false);
refreshLog();
// set correct sizing
setMinimumSize(minimumSizeHint());
resize(minimumSizeHint());
// setup the qso form
ui->qsoForm->setTitle("Edit QSO Record");
ui->qsoForm->hide();
// init correct button states
ui->cancelBtn->hide();
ui->deleteBtn->hide();
ui->saveBtn->hide();
ui->editBtn->setEnabled(false);
// TODO figure out how to show number of records
// double-clicks start an edit
connect(ui->qsoLogTable, SIGNAL(doubleClicked(QModelIndex)), this, SLOT(startEdit(QModelIndex)));
}
void ScoreView::elementPropertyAction(const QString& cmd, Element* e)
{
if (cmd == "a-props") {
ArticulationProperties rp(static_cast<Articulation*>(e));
rp.exec();
}
else if (cmd == "b-props") {
Bend* bend = static_cast<Bend*>(e);
BendProperties bp(bend, 0);
if (bp.exec())
score()->undo(new ChangeBend(bend, bp.points()));
}
else if (cmd == "f-props") {
BoxProperties vp(static_cast<Box*>(e), 0);
vp.exec();
}
else if (cmd == "measure-props") {
MeasureProperties vp(static_cast<Note*>(e)->chord()->segment()->measure());
vp.exec();
}
else if (cmd == "frame-text") {
Text* s = new Text(score());
// s->setSubtype(TEXT_FRAME);
s->setTextStyleType(TEXT_STYLE_FRAME);
s->setParent(e);
score()->undoAddElement(s);
score()->select(s, SELECT_SINGLE, 0);
startEdit(s);
score()->setLayoutAll(true);
}
else if (cmd == "picture") {
mscore->addImage(score(), static_cast<HBox*>(e));
}
else if (cmd == "frame-text") {
Text* t = new Text(score());
t->setTextStyleType(TEXT_STYLE_FRAME);
t->setParent(e);
score()->undoAddElement(t);
score()->select(t, SELECT_SINGLE, 0);
startEdit(t);
}
else if (cmd == "title-text") {
Text* t = new Text(score());
t->setTextStyleType(TEXT_STYLE_TITLE);
t->setParent(e);
score()->undoAddElement(t);
score()->select(t, SELECT_SINGLE, 0);
startEdit(t);
}
else if (cmd == "subtitle-text") {
Text* t = new Text(score());
t->setTextStyleType(TEXT_STYLE_SUBTITLE);
t->setParent(e);
score()->undoAddElement(t);
score()->select(t, SELECT_SINGLE, 0);
startEdit(t);
}
else if (cmd == "composer-text") {
Text* t = new Text(score());
t->setTextStyleType(TEXT_STYLE_COMPOSER);
t->setParent(e);
score()->undoAddElement(t);
score()->select(t, SELECT_SINGLE, 0);
startEdit(t);
}
else if (cmd == "poet-text") {
Text* t = new Text(score());
t->setTextStyleType(TEXT_STYLE_POET);
t->setParent(e);
score()->undoAddElement(t);
score()->select(t, SELECT_SINGLE, 0);
startEdit(t);
}
else if (cmd == "insert-hbox") {
HBox* s = new HBox(score());
double w = width() - s->leftMargin() * MScore::DPMM - s->rightMargin() * MScore::DPMM;
s->setBoxWidth(Spatium(w / s->spatium()));
s->setParent(e);
score()->undoAddElement(s);
score()->select(s, SELECT_SINGLE, 0);
startEdit(s);
}
else if (cmd == "picture")
mscore->addImage(score(), e);
else if (cmd == "v-props") {
VoltaSegment* vs = static_cast<VoltaSegment*>(e);
VoltaProperties vp;
vp.setText(vs->volta()->text());
vp.setEndings(vs->volta()->endings());
int rv = vp.exec();
if (rv) {
QString txt = vp.getText();
QList<int> l = vp.getEndings();
if (txt != vs->volta()->text())
score()->undoChangeVoltaText(vs->volta(), txt);
if (l != vs->volta()->endings())
score()->undoChangeVoltaEnding(vs->volta(), l);
}
}
else if (cmd == "l-props") {
TextLineSegment* vs = static_cast<TextLineSegment*>(e);
TextLine* nTl = vs->textLine()->clone();
LineProperties lp(nTl);
if (lp.exec()) {
score()->undoChangeElement(vs->textLine(), nTl);
// force new text
foreach(SpannerSegment* l, nTl->spannerSegments())
static_cast<TextLineSegment*>(l)->clearText();
}
else
delete nTl;
}
else if (cmd == "tr-props") {
TremoloBar* tb = static_cast<TremoloBar*>(e);
TremoloBarProperties bp(tb, 0);
if (bp.exec())
score()->undo(new ChangeTremoloBar(tb, bp.points()));
}
if (cmd == "ts-courtesy") {
TimeSig* ts = static_cast<TimeSig*>(e);
score()->undo(new ChangeTimesig(static_cast<TimeSig*>(e), !ts->showCourtesySig(), ts->sig(),
ts->stretch(), ts->numeratorString(), ts->denominatorString(), ts->timeSigType()));
}
else if (cmd == "ts-props") {
TimeSig* ts = static_cast<TimeSig*>(e);
TimeSig r(*ts);
TimeSigProperties vp(&r);
int rv = vp.exec();
if (rv) {
bool stretchChanged = r.stretch() != ts->stretch();
if (r.numeratorString() != ts->numeratorString()
|| r.denominatorString() != ts->denominatorString()
|| r.sig() != ts->sig()
|| stretchChanged
|| r.timeSigType() != ts->timeSigType()) {
score()->undo(new ChangeTimesig(ts, r.showCourtesySig(), r.sig(), r.stretch(),
r.numeratorString(), r.denominatorString(), r.timeSigType()));
if (stretchChanged)
score()->timesigStretchChanged(ts, ts->measure(), ts->staffIdx());
}
}
}
else if (cmd == "smallAcc")
score()->undoChangeProperty(e, P_SMALL, !static_cast<Accidental*>(e)->small());
else if (cmd == "smallNote")
score()->undoChangeProperty(e, P_SMALL, !static_cast<Note*>(e)->small());
else if (cmd == "clef-courtesy") {
bool show = !static_cast<Clef*>(e)->showCourtesy();
score()->undoChangeProperty(e, P_SHOW_COURTESY, show);
}
else if (cmd == "d-props") {
Dynamic* dynamic = static_cast<Dynamic*>(e);
Dynamic* nText = new Dynamic(*dynamic);
TextProperties tp(nText, 0);
int rv = tp.exec();
if (rv)
score()->undoChangeElement(dynamic, nText);
else
delete nText;
}
else if (cmd == "st-props") {
StaffTextProperties rp(static_cast<StaffText*>(e));
rp.exec();
}
else if (cmd == "d-dynamics") {
Dynamic* dynamic = static_cast<Dynamic*>(e);
int oldVelo = dynamic->velocity();
Element::DynamicRange ot = dynamic->dynRange();
DynamicProperties dp(dynamic);
int rv = dp.exec();
if (rv) {
int newVelo = dynamic->velocity();
Element::DynamicRange nt = dynamic->dynRange();
dynamic->setVelocity(oldVelo);
dynamic->setDynRange(ot);
if (newVelo != oldVelo)
score()->undoChangeProperty(dynamic, P_VELOCITY, newVelo);
if (nt != ot)
score()->undoChangeProperty(dynamic, P_DYNAMIC_RANGE, nt);
}
}
else if (cmd == "text-props") {
Text* ot = static_cast<Text*>(e);
Text* nText = static_cast<Text*>(ot->clone());
TextProperties tp(nText);
int rv = tp.exec();
if (rv) {
QList<Element*> sl = score()->selection().elements();
QList<Element*> selectedElements;
foreach(Element* e, sl) {
if (e->type() != ot->type())
continue;
Text* t = static_cast<Text*>(e);
Text* tt = t->clone();
if (nText->styled() != ot->styled() || nText->styled()) {
if (nText->styled())
tt->setTextStyleType(nText->textStyleType());
else
tt->setUnstyled();
tt->setModified(true);
}
if (!nText->styled() && (nText->textStyle() != ot->textStyle())) {
tt->setTextStyle(nText->textStyle());
tt->styleChanged();
tt->setModified(true);
}
if (t->selected())
selectedElements.append(tt);
score()->undoChangeElement(t, tt);
}
score()->select(0, SELECT_SINGLE, 0);
foreach(Element* e, selectedElements)
score()->select(e, SELECT_ADD, 0);
}
delete nText;
}
MaterialGeneratorNode::MaterialGeneratorNode(MaterialGraph* const parent):
NodeGraphNode(parent),
m_Evaluating(false), m_CompileState(true)
{
startEdit();
}
void ScoreView::lyricsUnderscore()
{
Lyrics* lyrics = toLyrics(editData.element);
int track = lyrics->track();
Segment* segment = lyrics->segment();
int verse = lyrics->no();
Placement placement = lyrics->placement();
PropertyFlags pFlags = lyrics->propertyFlags(Pid::PLACEMENT);
int endTick = segment->tick(); // a previous melisma cannot extend beyond this point
changeState(ViewState::NORMAL);
// search next chord
Segment* nextSegment = segment;
while ((nextSegment = nextSegment->next1(SegmentType::ChordRest))) {
Element* el = nextSegment->element(track);
if (el && el->isChord())
break;
}
// look for the lyrics we are moving from; may be the current lyrics or a previous one
// we are extending with several underscores
Lyrics* fromLyrics = 0;
while (segment) {
ChordRest* cr = toChordRest(segment->element(track));
if (cr) {
fromLyrics = cr->lyrics(verse, placement);
if (fromLyrics)
break;
}
segment = segment->prev1(SegmentType::ChordRest);
// if the segment has a rest in this track, stop going back
Element* e = segment ? segment->element(track) : 0;
if (e && !e->isChord())
break;
}
// one-chord melisma?
// if still at melisma initial chord and there is a valid next chord (if not,
// there will be no melisma anyway), set a temporary melisma duration
if (fromLyrics == lyrics && nextSegment) {
_score->startCmd();
lyrics->undoChangeProperty(Pid::LYRIC_TICKS, Lyrics::TEMP_MELISMA_TICKS);
_score->setLayoutAll();
_score->endCmd();
}
if (nextSegment == 0) {
_score->startCmd();
if (fromLyrics) {
switch(fromLyrics->syllabic()) {
case Lyrics::Syllabic::SINGLE:
case Lyrics::Syllabic::END:
break;
default:
fromLyrics->undoChangeProperty(Pid::SYLLABIC, int(Lyrics::Syllabic::END));
break;
}
if (fromLyrics->segment()->tick() < endTick)
fromLyrics->undoChangeProperty(Pid::LYRIC_TICKS, endTick - fromLyrics->segment()->tick());
}
// leave edit mode, select something (just for user feedback) and update to show extended melisam
mscore->changeState(STATE_NORMAL);
if (fromLyrics)
_score->select(fromLyrics, SelectType::SINGLE, 0);
_score->setLayoutAll();
_score->endCmd();
return;
}
// if a place for a new lyrics has been found, create a lyrics there
ChordRest* cr = toChordRest(nextSegment->element(track));
Lyrics* toLyrics = cr->lyrics(verse, placement);
bool newLyrics = (toLyrics == 0);
if (!toLyrics) {
toLyrics = new Lyrics(_score);
toLyrics->setTrack(track);
toLyrics->setParent(nextSegment->element(track));
toLyrics->setNo(verse);
toLyrics->setPlacement(placement);
toLyrics->setPropertyFlags(Pid::PLACEMENT, pFlags);
toLyrics->setSyllabic(Lyrics::Syllabic::SINGLE);
}
// as we arrived at toLyrics by an underscore, it cannot have syllabic dashes before
else if (toLyrics->syllabic() == Lyrics::Syllabic::MIDDLE)
toLyrics->undoChangeProperty(Pid::SYLLABIC, int(Lyrics::Syllabic::BEGIN));
else if (toLyrics->syllabic() == Lyrics::Syllabic::END)
toLyrics->undoChangeProperty(Pid::SYLLABIC, int(Lyrics::Syllabic::SINGLE));
if (fromLyrics) {
// as we moved away from fromLyrics by an underscore,
// it can be isolated or terminal but cannot have dashes after
switch(fromLyrics->syllabic()) {
case Lyrics::Syllabic::SINGLE:
case Lyrics::Syllabic::END:
break;
default:
fromLyrics->undoChangeProperty(Pid::SYLLABIC, int(Lyrics::Syllabic::END));
break;
}
// for the same reason, if it has a melisma, this cannot extend beyond toLyrics
if (fromLyrics->segment()->tick() < endTick)
fromLyrics->undoChangeProperty(Pid::LYRIC_TICKS, endTick - fromLyrics->segment()->tick());
}
if (newLyrics)
_score->undoAddElement(toLyrics);
_score->endCmd();
_score->select(toLyrics, SelectType::SINGLE, 0);
startEdit(toLyrics, Grip::NO_GRIP);
adjustCanvasPosition(toLyrics, false);
TextCursor* cursor = Ms::toLyrics(editData.element)->cursor(editData);
Ms::toLyrics(editData.element)->selectAll(cursor);
}
void ScoreView::lyricsMinus()
{
Lyrics* lyrics = toLyrics(editData.element);
int track = lyrics->track();
Segment* segment = lyrics->segment();
int verse = lyrics->no();
Placement placement = lyrics->placement();
PropertyFlags pFlags = lyrics->propertyFlags(Pid::PLACEMENT);
changeState(ViewState::NORMAL);
// search next chord
Segment* nextSegment = segment;
while ((nextSegment = nextSegment->next1(SegmentType::ChordRest))) {
Element* el = nextSegment->element(track);
if (el && el->isChord())
break;
}
if (nextSegment == 0)
return;
// look for the lyrics we are moving from; may be the current lyrics or a previous one
// we are extending with several dashes
Lyrics* fromLyrics = 0;
while (segment) {
ChordRest* cr = toChordRest(segment->element(track));
if (!cr) {
segment = segment->prev1(SegmentType::ChordRest);
continue;
}
fromLyrics = cr->lyrics(verse, placement);
if (fromLyrics)
break;
segment = segment->prev1(SegmentType::ChordRest);
}
_score->startCmd();
ChordRest* cr = toChordRest(nextSegment->element(track));
Lyrics* toLyrics = cr->lyrics(verse, placement);
bool newLyrics = (toLyrics == 0);
if (!toLyrics) {
toLyrics = new Lyrics(_score);
toLyrics->setTrack(track);
toLyrics->setParent(nextSegment->element(track));
toLyrics->setNo(verse);
toLyrics->setPlacement(placement);
toLyrics->setPropertyFlags(Pid::PLACEMENT, pFlags);
toLyrics->setSyllabic(Lyrics::Syllabic::END);
}
else {
// as we arrived at toLyrics by a dash, it cannot be initial or isolated
if (toLyrics->syllabic() == Lyrics::Syllabic::BEGIN)
toLyrics->undoChangeProperty(Pid::SYLLABIC, int(Lyrics::Syllabic::MIDDLE));
else if (toLyrics->syllabic() == Lyrics::Syllabic::SINGLE)
toLyrics->undoChangeProperty(Pid::SYLLABIC, int(Lyrics::Syllabic::END));
}
if (fromLyrics) {
// as we moved away from fromLyrics by a dash,
// it can have syll. dashes before and after but cannot be isolated or terminal
switch(fromLyrics->syllabic()) {
case Lyrics::Syllabic::BEGIN:
case Lyrics::Syllabic::MIDDLE:
break;
case Lyrics::Syllabic::SINGLE:
fromLyrics->undoChangeProperty(Pid::SYLLABIC, int(Lyrics::Syllabic::BEGIN));
break;
case Lyrics::Syllabic::END:
fromLyrics->undoChangeProperty(Pid::SYLLABIC, int(Lyrics::Syllabic::MIDDLE));
break;
}
// for the same reason, it cannot have a melisma
fromLyrics->undoChangeProperty(Pid::LYRIC_TICKS, 0);
}
if (newLyrics)
_score->undoAddElement(toLyrics);
_score->endCmd();
_score->select(toLyrics, SelectType::SINGLE, 0);
startEdit(toLyrics, Grip::NO_GRIP);
adjustCanvasPosition(toLyrics, false);
TextCursor* cursor = Ms::toLyrics(editData.element)->cursor(editData);
Ms::toLyrics(editData.element)->selectAll(cursor);
_score->setLayoutAll();
}
void ScoreView::lyricsTab(bool back, bool end, bool moveOnly)
{
Lyrics* lyrics = toLyrics(editData.element);
int track = lyrics->track();
Segment* segment = lyrics->segment();
int verse = lyrics->no();
Placement placement = lyrics->placement();
PropertyFlags pFlags = lyrics->propertyFlags(Pid::PLACEMENT);
Segment* nextSegment = segment;
if (back) {
// search prev chord
while ((nextSegment = nextSegment->prev1(SegmentType::ChordRest))) {
Element* el = nextSegment->element(track);
if (el && el->isChord())
break;
}
}
else {
// search next chord
while ((nextSegment = nextSegment->next1(SegmentType::ChordRest))) {
Element* el = nextSegment->element(track);
if (el && el->isChord())
break;
}
}
if (nextSegment == 0)
return;
changeState(ViewState::NORMAL);
// look for the lyrics we are moving from; may be the current lyrics or a previous one
// if we are skipping several chords with spaces
Lyrics* fromLyrics = 0;
if (!back) {
while (segment) {
ChordRest* cr = toChordRest(segment->element(track));
if (cr) {
fromLyrics = cr->lyrics(verse, placement);
if (fromLyrics)
break;
}
segment = segment->prev1(SegmentType::ChordRest);
}
}
ChordRest* cr = toChordRest(nextSegment->element(track));
if (!cr) {
qDebug("no next lyrics list: %s", nextSegment->element(track)->name());
return;
}
Lyrics* _toLyrics = cr->lyrics(verse, placement);
bool newLyrics = false;
if (!_toLyrics) {
_toLyrics = new Lyrics(_score);
_toLyrics->setTrack(track);
ChordRest* cr = toChordRest(nextSegment->element(track));
_toLyrics->setParent(cr);
_toLyrics->setNo(verse);
_toLyrics->setPlacement(placement);
_toLyrics->setPropertyFlags(Pid::PLACEMENT, pFlags);
_toLyrics->setSyllabic(Lyrics::Syllabic::SINGLE);
newLyrics = true;
}
_score->startCmd();
if (fromLyrics && !moveOnly) {
switch (_toLyrics->syllabic()) {
// as we arrived at toLyrics by a [Space], it can be the beginning
// of a multi-syllable, but cannot have syllabic dashes before
case Lyrics::Syllabic::SINGLE:
case Lyrics::Syllabic::BEGIN:
break;
case Lyrics::Syllabic::END:
_toLyrics->undoChangeProperty(Pid::SYLLABIC, int(Lyrics::Syllabic::SINGLE));
break;
case Lyrics::Syllabic::MIDDLE:
_toLyrics->undoChangeProperty(Pid::SYLLABIC, int(Lyrics::Syllabic::BEGIN));
break;
}
// as we moved away from fromLyrics by a [Space], it can be
// the end of a multi-syllable, but cannot have syllabic dashes after
switch (fromLyrics->syllabic()) {
case Lyrics::Syllabic::SINGLE:
case Lyrics::Syllabic::END:
break;
case Lyrics::Syllabic::BEGIN:
fromLyrics->undoChangeProperty(Pid::SYLLABIC, int(Lyrics::Syllabic::SINGLE));
break;
case Lyrics::Syllabic::MIDDLE:
fromLyrics->undoChangeProperty(Pid::SYLLABIC, int(Lyrics::Syllabic::END));
break;
}
// for the same reason, it cannot have a melisma
fromLyrics->undoChangeProperty(Pid::LYRIC_TICKS, 0);
}
if (newLyrics)
_score->undoAddElement(_toLyrics);
_score->endCmd();
_score->select(_toLyrics, SelectType::SINGLE, 0);
startEdit(_toLyrics, Grip::NO_GRIP);
adjustCanvasPosition(_toLyrics, false);
TextCursor* cursor = toLyrics(editData.element)->cursor(editData);
if (end) {
cursor->movePosition(QTextCursor::Start, QTextCursor::MoveAnchor);
cursor->movePosition(QTextCursor::End, QTextCursor::KeepAnchor);
}
else {
cursor->movePosition(QTextCursor::End, QTextCursor::MoveAnchor);
cursor->movePosition(QTextCursor::Start, QTextCursor::KeepAnchor);
}
_score->setLayoutAll();
}
void RendererWidget::keyPressEvent(QKeyEvent* event)
{
if(event->key() == Qt::Key_F11)
emit F11_pressed();
if(event->key() == Qt::Key_Shift)
_shiftPressed=true;
if(_editMode == SCENE_EDITOR && _rightMouse && _stateReady == NO_INTERACTION)
{
if(event->key() == Qt::Key_W) _renderer->setMoveDirection(0, true);
else if(event->key() == Qt::Key_A) _renderer->setMoveDirection(1, true);
else if(event->key() == Qt::Key_S) _renderer->setMoveDirection(2, true);
else if(event->key() == Qt::Key_D) _renderer->setMoveDirection(3, true);
else if(event->key() == Qt::Key_Shift) _renderer->setSpeedBoost(true);
// else if(event->key() == Qt::Key_G)
// {
// _stateReady = TRANSLATE_MODE;
// emit startEdit();
// emit stateChanged(_stateReady);
// }
// else if(event->key() == Qt::Key_F)
// {
// _stateReady = SCALE_MODE;
// emit startEdit();
// emit stateChanged(_stateReady);
// }
// else if(event->key() == Qt::Key_R)
// {
// _stateReady = ROTATE_MODE;
// emit startEdit();
// emit stateChanged(_stateReady);
// }
event->accept();
}
else if(_editMode == SCENE_EDITOR && _stateReady == NO_INTERACTION)
{
if(event->key() == Qt::Key_G && _stateReady != TRANSLATE_MODE)
{
_stateReady = TRANSLATE_MODE;
emit startEdit();
emit stateChanged(_stateReady);
}
else if(event->key() == Qt::Key_F && _stateReady != SCALE_MODE)
{
_stateReady = SCALE_MODE;
emit startEdit();
emit stateChanged(_stateReady);
}
else if(event->key() == Qt::Key_R && _stateReady != ROTATE_MODE)
{
_stateReady = ROTATE_MODE;
emit startEdit();
emit stateChanged(_stateReady);
}
else if(event->key() == Qt::Key_Shift) _renderer->setSpeedBoost(true);
else if(event->key() == Qt::Key_Escape) emit escapePressed();
else if(event->key() == Qt::Key_Delete) emit deleteCurrent();
event->accept();
}
else if(_editMode == SCENE_EDITOR && _stateReady >= TRANSLATE_MODE && _stateReady <= TRANSLATE_Z_MODE)
{
int newState = _stateReady;
if(event->key() == Qt::Key_X)
newState = TRANSLATE_X_MODE;
else if(event->key() == Qt::Key_Y)
newState = TRANSLATE_Y_MODE;
else if(event->key() == Qt::Key_Z)
newState = TRANSLATE_Z_MODE;
if(newState != _stateReady)
{
_stateReady = newState;
emit stateChanged(_stateReady);
}
event->accept();
}
else if(_editMode == SCENE_EDITOR && _stateReady >= SCALE_MODE && _stateReady <= SCALE_Z_MODE)
{
int newState = _stateReady;
if(event->key() == Qt::Key_X)
newState = SCALE_X_MODE;
else if(event->key() == Qt::Key_Y)
newState = SCALE_Y_MODE;
else if(event->key() == Qt::Key_Z)
newState = SCALE_Z_MODE;
if(newState != _stateReady)
{
_stateReady = newState;
emit stateChanged(_stateReady);
}
event->accept();
}
else if(_editMode == SCENE_EDITOR && _stateReady >= ROTATE_MODE && _stateReady <= ROTATE_Z_MODE)
{
int newState = _stateReady;
if(event->key() == Qt::Key_X)
newState = ROTATE_X_MODE;
else if(event->key() == Qt::Key_Y)
newState = ROTATE_Y_MODE;
else if(event->key() == Qt::Key_Z)
newState = ROTATE_Z_MODE;
if(newState != _stateReady)
{
_stateReady = newState;
emit stateChanged(_stateReady);
}
event->accept();
}
}
void LogViewer::on_editBtn_clicked()
{
QModelIndex i = ui->qsoLogTable->currentIndex();
startEdit(i);
}
void InlinePalette::handleDoubleClick(QListWidgetItem *item)
{
if (item)
emit startEdit(item->data(Qt::UserRole).toInt());
}
void InlinePalette::handleEditItem()
{
emit startEdit(actItem);
}
void MainWindowTask::setup()
{
ui->setupUi(this);
ui->treeView->setContextMenuPolicy(Qt::CustomContextMenu);
settings = new QSettings("NIISI RAS","Kumir 1.9");
setWindowIcon(QIcon(":/taskEdit.ico"));
settings->setIniCodec("UTF-8");
lastFiles=settings->value("RescentFiles").toStringList();
customMenu.hide();
connect(ui->loadCurs,SIGNAL(activated()),this,SLOT(loadCourse()));
connect(ui->actionSave,SIGNAL(activated()),this,SLOT(saveCourse()));
connect(ui->treeView,SIGNAL(clicked(QModelIndex)),this,SLOT(showText(QModelIndex)));
connect(ui->treeView,SIGNAL(doubleClicked(QModelIndex)),this,SLOT(startEdit(QModelIndex)));
// connect(ui->do_task,SIGNAL(triggered()),this,SLOT(startTask()));
qDebug()<<"Check Connect tttttttttttttttttt";
//connect(ui->checkTask,SIGNAL(triggered()),this,SLOT(checkTask()));
//connect(ui->actionReset,SIGNAL(triggered()),this,SLOT(resetTask()));
connect(ui->actionClose,SIGNAL(triggered()),this,SLOT(Close()));
// connect(ui->actionTested,SIGNAL(triggered()),this,SLOT(returnTested()));
connect(ui->treeView,SIGNAL(customContextMenuRequested(QPoint)),this,SLOT(customContextMenuRequested(QPoint)));
customMenu.addAction(ui->actionAdd);
customMenu.addAction(ui->actionRemove);
customMenu.addAction(ui->actionEdit);
customMenu.addAction(ui->addDeep);
customMenu.addSeparator();
customMenu.addAction(ui->actionup);
customMenu.addAction(ui->actionDown);
customMenu.addAction(ui->actionMakeSection);
customMenu.addMenu(ui->menuMove);
connect(ui->zadRb,SIGNAL(clicked(bool)),this,SLOT(setType()));
connect(ui->nodeRb,SIGNAL(clicked(bool)),this,SLOT(setType()));
connect(ui->actionup,SIGNAL(triggered()),this,SLOT(moveUp()));
connect(ui->actionDown,SIGNAL(triggered()),this,SLOT(moveDown()));
connect(ui->actionAdd,SIGNAL(triggered()),this,SLOT(addTask()));
connect(ui->addDeep,SIGNAL(triggered()),this,SLOT(addDeepTask()));
connect(ui->actionSaveK,SIGNAL(triggered()),this,SLOT(saveKurs()));
connect(ui->actionSave,SIGNAL(triggered()),this,SLOT(saveKursAs()));
connect(ui->actionRemove,SIGNAL(triggered()),this,SLOT(deleteTask()));
connect(ui->actionMakeSection,SIGNAL(triggered()),this,SLOT(makeSection()));
newDialog=new newKursDialog();
connect(ui->actionNewK,SIGNAL(triggered()),this,SLOT(newKurs()));
editDialog = new EditDialog(this);
connect(ui->actionEdit,SIGNAL(triggered()),this,SLOT(editTask()));
//ui->menuKurs->menuAction()->setVisible(false);
// ui->menuKurs->menuAction()->setEnabled(false);
setEditTaskEnabled(false);
ui->treeView->setSelectionMode(QAbstractItemView::SingleSelection);
editRoot=new QLineEdit(ui->treeView);
editRoot->hide();
connect(editRoot,SIGNAL(editingFinished ()),this,SLOT(endRootEdit()));
connect(ui->remIspButt,SIGNAL(pressed()),this,SLOT(remSelIsp()));
connect(ui->addIspButt,SIGNAL(pressed()),this,SLOT(addIsp()));
connect(ui->ispList,SIGNAL(clicked(QModelIndex)),this,SLOT(showFields()));
connect(ui->fieldsList,SIGNAL(clicked(QModelIndex)),this,SLOT(fieldClick()));
connect(ui->remFieldButt,SIGNAL(pressed()),this,SLOT(remField()));
connect(ui->addFieldButt,SIGNAL(pressed()),this,SLOT(addField()));
connect(ui->actionS,SIGNAL(triggered()),this,SLOT(saveBaseKurs()));
connect(ui->selFileButt,SIGNAL(pressed()),this,SLOT(setPrg()));
connect(ui->prgEdit,SIGNAL(textChanged(QString)),this,SLOT(prgLineChange()));
connect(ui->editFButt,SIGNAL(pressed()),this,SLOT(editFile()));
connect(ui->menuMove,SIGNAL(aboutToShow()),this,SLOT(createMoveMenu()));
// QMessageBox::information( 0, "", trUtf8("Setup add "), 0,0,0);
ui->ispSel->addItem("Robot");
ui->ispSel->addItem(trUtf8("Водолей"));
ui->actionup->setIcon(QIcon(":/arrow_up.png"));
ui->actionDown->setIcon(QIcon(":/arrow_down.png"));
changed=false;
isTeacher=true;
onTask=false;
cursFile="";
createRescentMenu();
//ui->textBrowser->setVisible(false);
};
