//******************************************************* //* Reset the tag editor to the default text //******************************************************* void TagEditorNewTag::resetText() { QLOG_TRACE_IN() << typeid(*this).name(); blockSignals(true); setText(""); blockSignals(false); QLOG_TRACE_OUT() << typeid(*this).name(); }
//**************************************************** //* Constructor //**************************************************** TagEditorNewTag::TagEditorNewTag(QWidget *parent) : QLineEdit(parent) { QLOG_TRACE_IN() << typeid(*this).name(); account = 0; this->setCursor(Qt::PointingHandCursor); // Setup the note title editor QPalette pal; pal.setColor(backgroundRole(), QPalette::Base); setPalette(pal); this->setFont(global.getGuiFont(font())); inactiveColor = "QLineEdit {background-color: transparent; border-radius: 0px;} "; activeColor = "QLineEdit {border: 1px solid #808080; background-color: white; border-radius: 4px;} "; this->setStyleSheet(inactiveColor); this->setPlaceholderText(tr("Click to add tag...")); connect(this, SIGNAL(textChanged(QString)), this, SLOT(textModified(QString))); // connect(this, SIGNAL(focussed(bool)), this, SLOT(gainedFocus(bool))); completer = new QCompleter(this); connect(completer, SIGNAL(activated(QString)), this, SLOT(mouseCompleterSelection(QString))); loadCompleter(); connect(this, SIGNAL(returnPressed()), this, SLOT(enterPressed())); hide(); QLOG_TRACE_OUT() << typeid(*this).name(); }
//*********************************************************** //* Load the completer with the list of valid tag names //*********************************************************** void TagEditorNewTag::loadCompleter() { QLOG_TRACE_IN() << typeid(*this).name(); QList<int> tagList; TagTable tagTable(global.db); QStringList tagNames; tagTable.getAll(tagList); for (qint32 i=0; i<tagList.size(); i++) { Tag t; QString guid; tagTable.getGuid(guid, tagList[i]); tagTable.get(t, guid); QString name = t.name; qint32 tagAccount = tagTable.owningAccount(tagList[i]); if (!currentTags.contains(name) && tagAccount == account) tagNames << name; } qSort(tagNames.begin(), tagNames.end(), caseInsensitiveLessThan); completer->setModelSorting(QCompleter::CaseInsensitivelySortedModel); completer->setCaseSensitivity(Qt::CaseInsensitive); setCompleter(completer); QStringListModel *model; model = (QStringListModel*)(completer->model()); if(model==NULL) model = new QStringListModel(); model->setStringList(tagNames); completer->setModel(model); QLOG_TRACE_OUT() << typeid(*this).name(); }
//******************************************************* //* Focus event. The editor has lost focus //******************************************************* void TagEditorNewTag::focusOutEvent(QFocusEvent *e) { QLOG_TRACE_IN() << typeid(*this).name(); this->setCursor(Qt::PointingHandCursor); QLineEdit::focusOutEvent(e); setStyleSheet(inactiveColor); emit(focussed(false)); QLOG_TRACE_OUT() << typeid(*this).name(); }
//******************************************************* //* Focus event. The editor has gained focus //******************************************************* void TagEditorNewTag::focusInEvent(QFocusEvent *e) { QLOG_TRACE_IN() << typeid(*this).name(); this->setCursor(Qt::ArrowCursor); QLineEdit::focusInEvent(e); setStyleSheet(activeColor); emit(focussed(true)); QLOG_TRACE_OUT() << typeid(*this).name(); }
//******************************************************* //* The current text has changed //******************************************************* void TagEditorNewTag::textModified(QString text) { QLOG_TRACE_IN() << typeid(*this).name(); if (this->hasFocus()) { QLOG_TRACE_OUT() << typeid(*this).name(); return; } this->blockSignals(true); setText(text); this->blockSignals(false); QLOG_TRACE_OUT() << typeid(*this).name(); }
// Synchronize remote linked notebooks void SyncRunner::syncRemoteLinkedNotebooksChunk(QList<LinkedNotebook> books) { QLOG_TRACE_IN(); LinkedNotebookTable ltable(db); for (int i = 0; i < books.size(); i++) { qint32 lid = ltable.sync(books[i]); LinkedNotebook lbk = books[i]; QString sharename = ""; QString username = ""; if (lbk.shareName.isSet()) sharename = lbk.shareName; if (lbk.username.isSet()) username = lbk.username; if (!finalSync) emit notebookUpdated(lid, sharename, username, true, false); } QLOG_TRACE_OUT(); }
// Upload any saved searchs qint32 SyncRunner::uploadSavedSearches() { QLOG_TRACE_IN(); qint32 usn; qint32 maxUsn = 0; SearchTable stable(db); QList<qint32> lids; stable.getAllDirty(lids); if (lids.size() == 0) { QLOG_TRACE_OUT(); return 0; } for (int i = 0; i < lids.size(); i++) { SavedSearch search; stable.get(search, lids[i]); if (!stable.isDeleted(lids[i])) { qint32 oldUsn = search.updateSequenceNum; usn = comm->uploadSavedSearch(search); if (usn == 0) { this->communicationErrorHandler(); error = true; QLOG_TRACE_OUT(); return maxUsn; } if (usn > maxUsn) { maxUsn = usn; if (oldUsn == 0) stable.updateGuid(lids[i], search.guid); stable.setUpdateSequenceNumber(lids[i], usn); } else { error = true; } } else { QString guid = stable.getGuid(lids[i]); stable.expunge(lids[i]); if (search.updateSequenceNum > 0) { usn = comm->expungeSavedSearch(guid); if (usn > maxUsn) maxUsn = usn; } } } QLOG_TRACE_OUT(); return maxUsn; }
//******************************************************* //* Override the event loop. If the user presses "TAB" //* and there is a valid tag entered, we signal the parent //* that a new tag is needed. //******************************************************* bool TagEditorNewTag::event(QEvent *event) { QLOG_TRACE_IN() << typeid(*this).name(); if (event->type() == QEvent::KeyPress) { QKeyEvent *ke = (QKeyEvent*)event; if (ke->key() == Qt::Key_Tab) { if (getText().trimmed() != "") { emit(tabPressed()); QLOG_TRACE_OUT() << typeid(*this).name(); return true; } QLOG_TRACE_OUT() << typeid(*this).name(); return QLineEdit::event(event); } } QLOG_TRACE_OUT() << typeid(*this).name(); return QLineEdit::event(event); }
// Upload any saved searchs qint32 SyncRunner::uploadNotebooks() { QLOG_TRACE_IN(); qint32 usn; qint32 maxUsn = 0; NotebookTable table(db); QList<qint32> lids; table.resetDirtyLocalNotebooks(); table.resetLinkedNotebooksDirty(); table.getAllDirty(lids); for (int i = 0; i < lids.size(); i++) { Notebook notebook; table.get(notebook, lids[i]); if (!table.isDeleted(lids[i])) { qint32 oldUsn = notebook.updateSequenceNum; usn = comm->uploadNotebook(notebook); if (usn == 0) { this->communicationErrorHandler(); error = true; QLOG_TRACE_OUT(); return maxUsn; } if (usn > maxUsn) { maxUsn = usn; if (oldUsn == 0) table.updateGuid(lids[i], notebook.guid); table.setUpdateSequenceNumber(lids[i], usn); } else { error = true; } } else { QString guid; table.getGuid(guid, lids[i]); table.expunge(lids[i]); if (notebook.updateSequenceNum > 0) { usn = comm->expungeNotebook(guid); if (usn > maxUsn) maxUsn = usn; } } } QLOG_TRACE_OUT(); return maxUsn; }
bool SyncRunner::syncRemoteToLocal(qint32 updateCount) { QLOG_TRACE_IN(); // The sync is run in several parts. // Part #1: Get all remote tags, notebooks, & saved searches for // a user's account. We do this first because we want // the tag & notebook naems for filling out the note table. // It is just easier this way. // Part #2: Get all changed notes & resources. If it is a full sync // then we get the resources & notes together as one entity // (the resource chunk won't have anything). We also do not // get deleted notes on a full sync. If it is a partial sync // then we get resources & notes separately (i.e. the notes chunk // may reference a resource guid, but it won't have the detail and // the chunk resources will have valid data. We get deleted notes // on a partial sync. // Part #3: Upload anything local to the user's account. // Part #4: Do linked notebook stuff. Basically the same as // this except we do it across multiple accounts. int chunkSize = 5000; bool more = true; bool rc; int startingSequenceNumber = updateSequenceNumber; while (more && keepRunning) { SyncChunk chunk; rc = comm->getSyncChunk(chunk, updateSequenceNumber, chunkSize, SYNC_CHUNK_LINKED_NOTEBOOKS | SYNC_CHUNK_NOTEBOOKS | SYNC_CHUNK_TAGS | SYNC_CHUNK_SEARCHES | SYNC_CHUNK_EXPUNGED, fullSync); if (!rc) { QLOG_ERROR() << "Error retrieving chunk"; error = true; this->communicationErrorHandler(); QLOG_TRACE_OUT(); return false; } QLOG_DEBUG() << "-(Pass 1)->>>> Old USN:" << updateSequenceNumber << " New USN:" << chunk.chunkHighUSN; int pct = (updateSequenceNumber - startingSequenceNumber) * 100 / (updateCount - startingSequenceNumber); emit setMessage(tr("Download ") + QString::number(pct) + tr("% complete for notebooks, tags, & searches."), defaultMsgTimeout); processSyncChunk(chunk); updateSequenceNumber = chunk.chunkHighUSN; if (!chunk.chunkHighUSN.isSet() || chunk.chunkHighUSN >= chunk.updateCount) more = false; } emit setMessage(tr("Download complete for notebooks, tags, & searches. Downloading notes."), defaultMsgTimeout); comm->loadTagGuidMap(); more = true; chunkSize = 50; updateSequenceNumber = startingSequenceNumber; UserTable userTable(db); while (more && keepRunning) { SyncChunk chunk; rc = comm->getSyncChunk(chunk, updateSequenceNumber, chunkSize, SYNC_CHUNK_NOTES | SYNC_CHUNK_RESOURCES, fullSync); if (!rc) { QLOG_ERROR() << "Error retrieving chunk"; error = true; this->communicationErrorHandler(); QLOG_TRACE_OUT(); return false; } QLOG_DEBUG() << "-(Pass 2) ->>>> Old USN:" << updateSequenceNumber << " New USN:" << chunk.chunkHighUSN; int pct = (updateSequenceNumber - startingSequenceNumber) * 100 / (updateCount - startingSequenceNumber); emit setMessage(tr("Download ") + QString::number(pct) + tr("% complete."), defaultMsgTimeout); processSyncChunk(chunk); userTable.updateLastSyncNumber(chunk.chunkHighUSN); userTable.updateLastSyncDate(chunk.currentTime); updateSequenceNumber = chunk.chunkHighUSN; if (!chunk.chunkHighUSN.isSet() || chunk.chunkHighUSN >= chunk.updateCount) { more = false; userTable.updateLastSyncNumber(updateCount); } } emit setMessage(tr("Download complete."), defaultMsgTimeout); QLOG_TRACE_OUT(); return true; }
void TagEditorNewTag::notebookSelectionChanged(qint32 notebook) { QLOG_TRACE_IN() << typeid(*this).name(); account = notebook; loadCompleter(); QLOG_TRACE_OUT() << typeid(*this).name(); }
//******************************************************* //* Add a new tag to the completer list //******************************************************* void TagEditorNewTag::addTag(QString s) { QLOG_TRACE_IN() << typeid(*this).name(); currentTags.append(s); loadCompleter(); QLOG_TRACE_OUT() << typeid(*this).name(); }
//******************************************************* //* Set the list of valid tags for the completer //******************************************************* void TagEditorNewTag::setTags(QStringList s) { QLOG_TRACE_IN() << typeid(*this).name(); currentTags = s; loadCompleter(); QLOG_TRACE_OUT() << typeid(*this).name(); }
//******************************************************* //* Get the current text. If the text is the default //* text, the n return an empty string. //******************************************************* QString TagEditorNewTag::getText() { QLOG_TRACE_IN() << typeid(*this).name(); QString retval = text().trimmed(); QLOG_TRACE_OUT() << typeid(*this).name(); return retval; }
// Upload notes that belong to me qint32 SyncRunner::uploadPersonalNotes() { QLOG_TRACE_IN(); qint32 usn; qint32 maxUsn = 0; NotebookTable notebookTable(db); LinkedNotebookTable linkedNotebookTable(db); NoteTable noteTable(db); QList<qint32> lids, validLids, deletedLids, movedLids; QStringList deleteQueueGuids; noteTable.getAllDirty(lids); // Get all of the notes that were deleted, and then removed from the trash noteTable.getAllDeleteQueue(deleteQueueGuids); // Get a list of all notes that are both dirty and in an account we own and isn't deleted for (int i = 0; i < lids.size(); i++) { qint32 notebookLid = noteTable.getNotebookLid(lids[i]); if (!linkedNotebookTable.exists(notebookLid)) { if (!notebookTable.isLocal(notebookLid)) { if (noteTable.isDeleted(lids[i])) deletedLids.append(lids[i]); else validLids.append(lids[i]); } else { // We have a note that is local. Check if it was once // synchronized. If so, it was moved to a local notebook // and now needs to be deleted on the remote end Note n; noteTable.get(n, lids[i], false, false); if (n.updateSequenceNum.isSet() && n.updateSequenceNum > 0) { movedLids.append(lids[i]); } } } } // Start deleting notes for (int i = 0; i < deletedLids.size(); i++) { QString guid = noteTable.getGuid(deletedLids[i]); noteTable.setDirty(lids[i], false); usn = comm->deleteNote(guid); if (usn > maxUsn) { maxUsn = usn; noteTable.setUpdateSequenceNumber(deletedLids[i], usn); noteTable.setDirty(deletedLids[i], false); if (!finalSync) emit(noteSynchronized(deletedLids[i], false)); } } // Start handling notes moved to a local notebook. What // we do is to delete the note on Evernote, then give the // note in the local notebook a new GUID & set the // update sequence number to 0. for (int i = 0; i < movedLids.size(); i++) { QUuid uuid; Guid newGuid = uuid.createUuid().toString().replace("{", "").replace("}", ""); QString guid = noteTable.getGuid(movedLids[i]); noteTable.setDirty(movedLids[i], false); noteTable.updateGuid(movedLids[i], newGuid); noteTable.setUpdateSequenceNumber(movedLids[0], 0); usn = comm->deleteNote(guid); if (usn > maxUsn) { maxUsn = usn; } if (!finalSync) emit(noteSynchronized(movedLids[i], false)); } // Delete any notes that were deleted, but emptied from the trash for (int i = 0; i < deleteQueueGuids.size(); i++) { QString guid = deleteQueueGuids[i]; usn = comm->deleteNote(guid); if (usn > maxUsn) { maxUsn = usn; } noteTable.expungeFromDeleteQueue(guid); } // Start uploading notes for (int i = 0; i < validLids.size(); i++) { Note note; noteTable.get(note, validLids[i], true, true); qint32 oldUsn = 0; if (note.updateSequenceNum.isSet()) oldUsn = note.updateSequenceNum; usn = comm->uploadNote(note); if (usn == 0) { this->communicationErrorHandler(); if (note.title.isSet()) QLOG_ERROR() << tr("Error uploading note:") + note.title; else QLOG_ERROR() << tr("Error uploading note with a missing title!"); error = true; //return maxUsn; } if (usn > maxUsn) { maxUsn = usn; if (oldUsn == 0) noteTable.updateGuid(validLids[i], note.guid); noteTable.setUpdateSequenceNumber(validLids[i], usn); noteTable.setDirty(validLids[i], false); if (!finalSync) emit(noteSynchronized(validLids[i], false)); } else { error = true; } } QLOG_TRACE_OUT(); return maxUsn; }
//****************************************************** //* Set the color whe the editor has a good focus //****************************************************** void TagEditorNewTag::setActiveColor() { QLOG_TRACE_IN() << typeid(*this).name(); setStyleSheet(activeColor); QLOG_TRACE_OUT() << typeid(*this).name(); }
// Upload any tags qint32 SyncRunner::uploadTags() { QLOG_TRACE_IN(); qint32 usn; qint32 maxUsn = 0; TagTable table(db); QList<qint32> lids, deletedLids, updatedLids; table.resetLinkedTagsDirty(); table.getAllDirty(lids); if (lids.size() == 0) { QLOG_TRACE_OUT(); return 0; } // Split the lids into lids to be updated, and lids to be deleted for (int i = 0; i < lids.size(); i++) { if (table.isDeleted(lids[i])) deletedLids.append(lids[i]); else updatedLids.append(lids[i]); } // Get existing tags in case there is a duplicate name QList<Tag> existingTags; comm->getTagList(existingTags); // Update any lids QLOG_DEBUG() << "Beginning to upload new & altered tags"; int i = 0; while (updatedLids.size() > 0) { Tag tag; table.get(tag, updatedLids[i]); if (tag.name.isSet()) { QLOG_DEBUG() << "Found changed tag " << tag.name; } qint32 parentLid = 0; QString parentGuid = ""; if (tag.parentGuid.isSet()) parentGuid = tag.parentGuid; if (parentGuid != "") parentLid = table.getLid(tag.parentGuid); // If the parent is either not dirty, or there is no parent we can update this lid. if (parentLid <= 0 || !table.isDirty(parentLid)) { QLOG_DEBUG() << "Tag has no parent or parent is unaltered"; // Check if a tag with this name already exists. // In reality this should never happen, but there was a bug // where a tag was uploaded but the USN & GUID wasn't // updated. This is a workaround for people who // have that bug. Tag foundTag; bool matchFound = false; for (int j = 0; j < existingTags.size(); j++) { QString tempTagName = existingTags[j].name; if (tempTagName == tag.name) { matchFound = true; foundTag = existingTags[j]; j = existingTags.size(); } } if (!matchFound) { qint32 oldUsn = 0; if (tag.updateSequenceNum.isSet()) oldUsn = tag.updateSequenceNum; QLOG_DEBUG() << "Uploaing tag " << tag.name; usn = comm->uploadTag(tag); if (usn == 0) { this->communicationErrorHandler(); error = true; QLOG_TRACE_OUT(); return maxUsn; } if (usn > 0) { maxUsn = usn; QLOG_DEBUG() << "Tag USN: " << usn; if (oldUsn == 0) { QLOG_DEBUG() << "New USN: " << tag.guid; table.updateGuid(updatedLids[i], tag.guid); } table.setUpdateSequenceNumber(updatedLids[i], usn); table.setDirty(tag.guid, false); updatedLids.removeAt(i); i = -1; // Reset for the next time through the loop } else { error = true; updatedLids.clear(); } } else { QLOG_DEBUG() << "Tag with this name exists."; table.updateGuid(updatedLids[i], foundTag.guid); table.setUpdateSequenceNumber(updatedLids[i], foundTag.updateSequenceNum); updatedLids.removeAt(i); i = -1; // Reset for the next time through the loop } } i++; } QLOG_DEBUG() << "Deleting LIDS"; // delete any lids for (int i = 0; i < deletedLids.size(); i++) { Tag tag; table.get(tag, deletedLids[i]); table.expunge(lids[i]); if (tag.updateSequenceNum > 0) { usn = comm->expungeTag(tag.guid); if (usn > maxUsn) maxUsn = usn; } } QLOG_TRACE_OUT(); return maxUsn; }
// Upload notes that belong to me qint32 SyncRunner::uploadLinkedNotes(qint32 notebookLid) { QLOG_TRACE_IN(); qint32 usn; qint32 maxUsn = 0; NoteTable noteTable(db); QList<qint32> lids, validLids, deletedLids; noteTable.getAllDirty(lids, notebookLid); // Split the list into deleted and updated notes for (int i = 0; i < lids.size(); i++) { if (noteTable.isDeleted(lids[i])) deletedLids.append(lids[i]); else validLids.append(lids[i]); } // Start deleting notes for (int i = 0; i < deletedLids.size(); i++) { QString guid = noteTable.getGuid(deletedLids[i]); noteTable.setDirty(lids[i], false); usn = comm->deleteLinkedNote(guid); if (usn > maxUsn) { maxUsn = usn; noteTable.setUpdateSequenceNumber(deletedLids[i], usn); noteTable.setDirty(deletedLids[i], false); if (!finalSync) emit(noteSynchronized(deletedLids[i], false)); } } // Start deleting notes that were in the trash, but the trash was // emptied. NotebookTable bookTable(db); QString notebookGuid = ""; bookTable.getGuid(notebookGuid, notebookLid); // Get all of the notes QStringList deleteQueueGuids; noteTable.getAllDeleteQueue(deleteQueueGuids, notebookGuid); // Do the actual deletes for (int i = 0; i < deleteQueueGuids.size(); i++) { QString guid = deleteQueueGuids[i]; usn = comm->deleteLinkedNote(guid); if (usn > maxUsn) { maxUsn = usn; } noteTable.expungeFromDeleteQueue(guid); } // Start uploading notes for (int i = 0; i < validLids.size(); i++) { Note note; noteTable.get(note, validLids[i], true, true); qint32 oldUsn = note.updateSequenceNum; usn = comm->uploadLinkedNote(note); if (usn == 0) { this->communicationErrorHandler(); error = true; QLOG_TRACE_OUT(); return maxUsn; } if (usn > maxUsn) { maxUsn = usn; if (oldUsn == 0) noteTable.updateGuid(validLids[i], note.guid); noteTable.setUpdateSequenceNumber(validLids[i], usn); noteTable.setDirty(validLids[i], false); if (!finalSync) emit(noteSynchronized(validLids[i], false)); } else { error = true; } } QLOG_TRACE_OUT(); return maxUsn; }
// Synchronize remote linked notebooks bool SyncRunner::syncRemoteLinkedNotebooksActual() { QLOG_TRACE_IN(); LinkedNotebookTable ltable(db); QList<qint32> lids; ltable.getAll(lids); bool fs; for (int i = 0; i < lids.size(); i++) { LinkedNotebook book; qint32 usn = ltable.getLastUpdateSequenceNumber(lids[i]); qint32 startingUSN = usn; ltable.get(book, lids[i]); int chunkSize = 5000; // If the share key is set, we need to authenticate if (!comm->authenticateToLinkedNotebookShard(book)) { // If we can't authenticate, we just gid of the notebook // because the user probably stopped sharing. qint32 linkedLid = 0; LinkedNotebookTable ntable(db); linkedLid = ntable.getLid(book.guid); ntable.expunge(book.guid); emit notebookExpunged(linkedLid); return true; //this->communicationErrorHandler(); //error = true; //return false; } bool more = true; SyncState syncState; if (!comm->getLinkedNotebookSyncState(syncState, book)) { this->communicationErrorHandler(); error = true; return false; } if (syncState.updateCount <= usn) more = false; qint32 startingSequenceNumber = usn; if (usn == 0) fs = true; else fs = false; // ***** STARTING PASS #1 while (more && keepRunning) { SyncChunk chunk; if (!comm->getLinkedNotebookSyncChunk(chunk, book, usn, chunkSize, fs)) { more = false; if (comm->getLastErrorType() == CommunicationError::EDAMNotFoundException) { ltable.expunge(lids[i]); if (!finalSync) emit(notebookExpunged(lids[i])); } else { this->communicationErrorHandler(); error = true; QLOG_TRACE_OUT(); return false; } } else { processSyncChunk(chunk, lids[i]); usn = chunk.chunkHighUSN; if (chunk.updateCount > 0 && chunk.updateCount > startingSequenceNumber) { int pct = (usn - startingSequenceNumber) * 100 / (chunk.updateCount - startingSequenceNumber); QString sharename = ""; if (book.shareName.isSet()) sharename = book.shareName; emit setMessage( tr("Downloading ") + QString::number(pct) + tr("% complete for tags in shared notebook ") + sharename + tr("."), defaultMsgTimeout); } if (!chunk.chunkHighUSN.isSet() || chunk.chunkHighUSN >= chunk.updateCount) more = false; } } //************* STARTING PASS 2 usn = startingUSN; more = true; chunkSize = 50; if (error == true) more = false; QString sharename = ""; if (book.shareName.isSet()) sharename = book.shareName; emit setMessage(tr("Downloading notes for shared notebook ") + sharename + tr("."), defaultMsgTimeout); while (more && keepRunning) { SyncChunk chunk; if (!comm->getLinkedNotebookSyncChunk(chunk, book, usn, chunkSize, fs)) { more = false; if (comm->getLastErrorType()== CommunicationError::EDAMNotFoundException) { ltable.expunge(lids[i]); if (!finalSync) emit(notebookExpunged(lids[i])); } else { this->communicationErrorHandler(); error = true; return false; } } else { processSyncChunk(chunk, lids[i]); usn = chunk.chunkHighUSN; if (chunk.updateCount > 0 && chunk.updateCount > startingSequenceNumber) { int pct = (usn - startingSequenceNumber) * 100 / (chunk.updateCount - startingSequenceNumber); QString sharename = ""; if (book.shareName.isSet()) sharename = book.shareName; emit setMessage( tr("Downloading ") + QString::number(pct) + tr("% complete for shared notebook ") + sharename + tr("."), defaultMsgTimeout); } if (!chunk.chunkHighUSN.isSet() || chunk.chunkHighUSN >= chunk.updateCount) { more = false; ltable.setLastUpdateSequenceNumber(lids[i], syncState.updateCount); } } } qint32 noteUSN = uploadLinkedNotes(lids[i]); if (noteUSN > usn) ltable.setLastUpdateSequenceNumber(lids[i], noteUSN); } TagTable tagTable(db); tagTable.cleanupLinkedTags(); QLOG_TRACE_OUT(); return true; }