From: Randy Baumgarte <randy@fbn.cx>
Date: Sun, 22 Aug 2010 11:15:14 +0000 (-0400)
Subject: Alter sync logic to examine new notes as they arrive rather than doing a full reload... 
X-Git-Tag: version0.1.1~400
X-Git-Url: http://git.osdn.net/view?a=commitdiff_plain;h=cb2b9e43c59e40558259d8179bb6c68a432d8a94;p=neighbornote%2FNeighborNote.git

Alter sync logic to examine new notes as they arrive rather than doing a full reload after a sync completes. This should improve performance.
---

diff --git a/src/cx/fbn/nevernote/NeverNote.java b/src/cx/fbn/nevernote/NeverNote.java
index 6b8615c..279e92b 100644
--- a/src/cx/fbn/nevernote/NeverNote.java
+++ b/src/cx/fbn/nevernote/NeverNote.java
@@ -803,15 +803,14 @@ public class NeverNote extends QMainWindow{
         syncRunner.noteIndexSignal.listChanged.connect(this, "noteIndexUpdated(boolean)");
         syncRunner.noteSignal.quotaChanged.connect(this, "updateQuotaBar()");
         
-//		syncRunner.syncSignal.setSequenceDate.connect(this,"setSequenceDate(long)");
 		syncRunner.syncSignal.saveUploadAmount.connect(this,"saveUploadAmount(long)");
-//		syncRunner.syncSignal.setUpdateSequenceNumber.connect(this,"setUpdateSequenceNumber(int)");
 		syncRunner.syncSignal.saveUserInformation.connect(this,"saveUserInformation(User)");
 		syncRunner.syncSignal.saveEvernoteUpdateCount.connect(this,"saveEvernoteUpdateCount(int)");
 		
 		syncRunner.noteSignal.guidChanged.connect(this, "noteGuidChanged(String, String)");
 		syncRunner.noteSignal.noteChanged.connect(this, "invalidateNoteCache(String, String)");
 		syncRunner.resourceSignal.resourceGuidChanged.connect(this, "noteResourceGuidChanged(String,String,String)");
+		syncRunner.noteSignal.noteDownloaded.connect(listManager, "noteDownloaded(Note)");
 		
 		syncRunner.syncSignal.refreshLists.connect(this, "refreshLists()");
 	}
@@ -2908,8 +2907,9 @@ public class NeverNote extends QMainWindow{
 				return;
 		}
 		
-		// If tihs wasn't already marked as unsynchronized, then we need to update the table
-    	listManager.getUnsynchronizedNotes().add(currentNoteGuid);
+		// If this wasn't already marked as unsynchronized, then we need to update the table
+		listManager.getNoteTableModel().updateNoteSyncStatus(currentNoteGuid, false);
+/*    	listManager.getUnsynchronizedNotes().add(currentNoteGuid);
     	for (int i=0; i<listManager.getNoteTableModel().rowCount(); i++) {
     		QModelIndex modelIndex =  listManager.getNoteTableModel().index(i, Global.noteTableGuidPosition);
     		if (modelIndex != null) {
@@ -2921,7 +2921,7 @@ public class NeverNote extends QMainWindow{
     			}
     		}
     	}
-    	
+ */   	
 		logger.log(logger.EXTREME, "Leaving NeverNote.setNoteDirty()");
     }
     private void saveNote() {
@@ -3290,11 +3290,11 @@ public class NeverNote extends QMainWindow{
     	na.setLongitude(0.0);
     	na.setAltitude(0.0);
     	newNote.setAttributes(new NoteAttributes());
-
+		newNote.setTagGuids(new ArrayList<String>());
+		newNote.setTagNames(new ArrayList<String>());
+    	
     	// If new notes are to be created based upon the selected tags, then we need to assign the tags
     	if (Global.newNoteWithSelectedTags()) {	
-    		newNote.setTagGuids(new ArrayList<String>());
-    		newNote.setTagNames(new ArrayList<String>());
     		List<QTreeWidgetItem> selections = tagTree.selectedItems();
         	QTreeWidgetItem currentSelection;
         	for (int i=0; i<selections.size(); i++) {
@@ -3307,7 +3307,7 @@ public class NeverNote extends QMainWindow{
     	conn.getNoteTable().addNote(newNote, true);
     	listManager.getUnsynchronizedNotes().add(newNote.getGuid());
     	listManager.addNote(newNote);
-    	noteTableView.insertRow(newNote, true, -1);
+//    	noteTableView.insertRow(newNote, true, -1);
     	
     	currentNote = newNote;
     	currentNoteGuid = currentNote.getGuid();
@@ -4115,14 +4115,17 @@ public class NeverNote extends QMainWindow{
 		synchronizeAnimationTimer.stop();
 		synchronizeButton.setIcon(synchronizeAnimation.get(0));
 		saveNote();
+		if (currentNote == null) {
+			currentNote = conn.getNoteTable().getNote(currentNoteGuid, false, false, false, false, true);
+		}
 		listManager.setUnsynchronizedNotes(conn.getNoteTable().getUnsynchronizedGUIDs());
-		listManager.reloadIndexes();
-		noteIndexUpdated(true);
+		noteIndexUpdated(false);
 		noteTableView.selectionModel().blockSignals(true);
 		scrollToGuid(currentNoteGuid);
 		noteTableView.selectionModel().blockSignals(false);
 		refreshEvernoteNote(false);
 		scrollToGuid(currentNoteGuid);
+		waitCursor(false);
 		setMessage(tr("Synchronization Complete"));
 		logger.log(logger.MEDIUM, "Sync complete.");
 	}   
diff --git a/src/cx/fbn/nevernote/gui/NoteTableModel.java b/src/cx/fbn/nevernote/gui/NoteTableModel.java
index 95c64a0..195d019 100644
--- a/src/cx/fbn/nevernote/gui/NoteTableModel.java
+++ b/src/cx/fbn/nevernote/gui/NoteTableModel.java
@@ -299,7 +299,7 @@ public class NoteTableModel extends QAbstractTableModel {
 			if (getMasterNoteIndex().get(i).getGuid() != null && getMasterNoteIndex().get(i).getGuid().equals(oldGuid)) {
 				getMasterNoteIndex().get(i).setGuid(newGuid);
 				QModelIndex idx = createIndex(i, Global.noteTableGuidPosition, nativePointer());
-				setData(idx, new Long(getMasterNoteIndex().get(i).getGuid()), Qt.ItemDataRole.EditRole); 
+				setData(idx, new String(getMasterNoteIndex().get(i).getGuid()), Qt.ItemDataRole.EditRole); 
 				i=getMasterNoteIndex().size()+1;
 			}
 		}
@@ -341,7 +341,6 @@ public class NoteTableModel extends QAbstractTableModel {
 				getMasterNoteIndex().get(i).getAttributes().setAltitudeIsSet(true);
 				QModelIndex idx = createIndex(i, Global.noteTableAuthorPosition, nativePointer());
 				setData(idx, author, Qt.ItemDataRole.EditRole); 
-
 				i = getMasterNoteIndex().size();
 			}	
 		}
@@ -375,13 +374,50 @@ public class NoteTableModel extends QAbstractTableModel {
 		}
 	}
 
+	public void updateNoteSyncStatus(String guid, boolean sync) {
+		
+		boolean found = false;
+		for (int i=0; i<unsynchronizedNotes.size(); i++) {			
+			// If the note is now synchronized, but it is in the unsynchronized list, remove it
+			if (unsynchronizedNotes.get(i).equalsIgnoreCase(guid) && sync) {
+				unsynchronizedNotes.remove(i);
+				found = true;
+				i=unsynchronizedNotes.size();
+			}
+			
+			// If the note is not synchronized, but it is already in the unsynchronized list, do nothing
+			if (unsynchronizedNotes.get(i).equalsIgnoreCase(guid) && sync) {
+				found = true;
+				i=unsynchronizedNotes.size();
+			}
+		}
+		
+		// If we've gotten through the entire list, then we consider it synchronized.  If this is 
+		// wrong, add it to the list.
+		if (!sync && !found) 
+			unsynchronizedNotes.add(guid);
+		
+		// Now we need to go through the table & update it
+		for (int i=0; i<getMasterNoteIndex().size(); i++) {
+			if (getMasterNoteIndex().get(i).getGuid().equals(guid)) {
+				QModelIndex idx = createIndex(i, Global.noteTableSynchronizedPosition, nativePointer());
+				String value;
+				if (!sync)
+					value = tr("false");
+				else
+					value = tr("true");
+				setData(idx, value, Qt.ItemDataRole.EditRole); 
+				return;
+			}	
+		}
+	}
 	
 	public void addNote(Note n) {
-		beginInsertRows(null, 0, 1);
 		getNoteIndex().add(n);
 		getMasterNoteIndex().add(n);
 		proxyModel.addGuid(n.getGuid());
-		endInsertRows();
+		proxyModel.invalidate();
+//		proxyModel.filter();
 	}
 	
 	
diff --git a/src/cx/fbn/nevernote/signals/NoteSignal.java b/src/cx/fbn/nevernote/signals/NoteSignal.java
index 4c2016f..fad4b2b 100644
--- a/src/cx/fbn/nevernote/signals/NoteSignal.java
+++ b/src/cx/fbn/nevernote/signals/NoteSignal.java
@@ -43,6 +43,7 @@ public class NoteSignal extends QSignalEmitter {
 	public Signal1<Note>				noteAdded = new Signal1<Note>();
 	public Signal2<String, String>		guidChanged = new Signal2<String, String>();
 	public Signal1<Integer>				titleColorChanged = new Signal1<Integer>();
+	public Signal2<Note, Boolean>		noteDownloaded = new Signal2<Note, Boolean>();
 }
 
 
diff --git a/src/cx/fbn/nevernote/threads/SyncRunner.java b/src/cx/fbn/nevernote/threads/SyncRunner.java
index 5ed5137..9b21fc1 100644
--- a/src/cx/fbn/nevernote/threads/SyncRunner.java
+++ b/src/cx/fbn/nevernote/threads/SyncRunner.java
@@ -488,9 +488,6 @@ public class SyncRunner extends QObject implements Runnable {
 					logger.log(logger.EXTREME, "Active dirty note found - non new");
 					if (enNote.getUpdateSequenceNum() > 0) {
 						enNote = getNoteContent(enNote);
-						System.out.println("--------");
-						System.out.println("Note:" +enNote);
-						System.out.println("--------");
 						logger.log(logger.MEDIUM, "Updating note : "+ enNote.getGuid() +" <title>" +enNote.getTitle()+"</title>");
 						enNote = noteStore.updateNote(authToken, enNote);
 					} else { 
@@ -1043,6 +1040,7 @@ public class SyncRunner extends QObject implements Runnable {
 						logger.log(logger.EXTREME, "Saving Note");
 						conn.getNoteTable().syncNote(n, false);
 						noteSignal.noteChanged.emit(n.getGuid(), null);   // Signal to ivalidate note cache
+						noteSignal.noteDownloaded.emit(n, true);		// Signal to add note to index
  						logger.log(logger.EXTREME, "Note Saved");
 						if (fullSync && n.getResources() != null) {
 							for (int q=0; q<n.getResources().size() && keepRunning; q++) {
diff --git a/src/cx/fbn/nevernote/utilities/ListManager.java b/src/cx/fbn/nevernote/utilities/ListManager.java
index e580d5c..e46e398 100644
--- a/src/cx/fbn/nevernote/utilities/ListManager.java
+++ b/src/cx/fbn/nevernote/utilities/ListManager.java
@@ -802,6 +802,88 @@ public class ListManager  {
 	//**  Load and filter the note index
 	//************************************************************************************
 	//************************************************************************************
+	
+	public void noteDownloaded(Note n) {
+		boolean found = false;
+		for (int i=0; i<getMasterNoteIndex().size(); i++) {
+			if (getMasterNoteIndex().get(i).getGuid().equals(n.getGuid())) {
+				getMasterNoteIndex().set(i,n);
+				found = true;
+				i=getMasterNoteIndex().size();
+			}
+		}
+		
+		if (!found)
+			getMasterNoteIndex().add(n);
+		
+		for (int i=0; i<getNoteIndex().size(); i++) {
+			if (getNoteIndex().get(i).getGuid().equals(n.getGuid())) {
+				if (filterRecord(getNoteIndex().get(i)))
+					getNoteIndex().add(n);
+				getNoteIndex().remove(i);
+				i=getNoteIndex().size();
+			}
+		}
+		
+		if (filterRecord(n))
+			getNoteIndex().add(n);
+		
+	}
+	// Check if a note matches the currently selected notebooks, tags, or attribute searches.
+	public boolean filterRecord(Note n) {
+				
+		boolean goodNotebook = false;
+		boolean goodTag = false;
+		boolean goodStatus = false;
+			
+		// Check note status
+		if (!n.isActive() && Global.showDeleted)
+			return true;
+		else {
+			if (n.isActive() && !Global.showDeleted)
+				goodStatus = true;
+			// Begin filtering results
+			if (goodStatus)
+				goodNotebook = filterByNotebook(n.getNotebookGuid());
+			if (goodNotebook) 
+				goodTag = filterByTag(n.getTagGuids());
+			if (goodTag) {
+				boolean goodCreatedBefore = false;
+				boolean goodCreatedSince = false;
+				boolean goodChangedBefore = false;
+				boolean goodChangedSince = false;
+				boolean goodContains = false;
+					
+				if (!Global.createdBeforeFilter.hasSelection())
+					goodCreatedBefore = true;
+				else
+					goodCreatedBefore = Global.createdBeforeFilter.check(n);
+				
+				if (!Global.createdSinceFilter.hasSelection())
+					goodCreatedSince = true;
+				else
+					goodCreatedSince = Global.createdSinceFilter.check(n);
+				
+				if (!Global.changedBeforeFilter.hasSelection())
+					goodChangedBefore = true;
+				else
+					goodChangedBefore = Global.changedBeforeFilter.check(n);
+					if (!Global.changedSinceFilter.hasSelection())
+					goodChangedSince = true;
+				else
+					goodChangedSince = Global.changedSinceFilter.check(n);
+				if (!Global.containsFilter.hasSelection())
+					goodContains = true;
+				else
+					goodContains = Global.containsFilter.check(conn.getNoteTable(), n);
+					
+				if (goodCreatedSince && goodCreatedBefore && goodChangedSince && goodChangedBefore && goodContains)
+					return true;
+			}
+		}	
+		return false;
+	}
+	
 	// Load the note index based upon what the user wants.
 	public void loadNotesIndex() {
 		logger.log(logger.EXTREME, "Entering ListManager.loadNotesIndex()");
@@ -809,8 +891,6 @@ public class ListManager  {
 		notebookCounterRunner.abortCount = true;
 		trashCounterRunner.abortCount = true;
 		
-		List<Note> index = new ArrayList<Note>();
-		
 		List<Note> matches;
 		if (enSearchChanged || getMasterNoteIndex() == null)
 			matches = enSearch.matchWords();
@@ -820,65 +900,14 @@ public class ListManager  {
 		if (matches == null)
 			matches = getMasterNoteIndex();
 		
+		setNoteIndex(new ArrayList<Note>());
 		for (int i=0; i<matches.size(); i++) {
-			Note n = matches.get(i);
-			boolean goodNotebook = false;
-			boolean goodTag = false;
-			boolean goodStatus = false;
-			
-			// Check note status
-			if (!n.isActive() && Global.showDeleted)
-				index.add(n);
-			else {
-				if (n.isActive() && !Global.showDeleted)
-					goodStatus = true;
-				// Begin filtering results
-				if (goodStatus)
-					goodNotebook = filterByNotebook(n.getNotebookGuid());
-				if (goodNotebook) 
-					goodTag = filterByTag(n.getTagGuids());
-				if (goodTag) {
-					boolean goodCreatedBefore = false;
-					boolean goodCreatedSince = false;
-					boolean goodChangedBefore = false;
-					boolean goodChangedSince = false;
-					boolean goodContains = false;
-					
-					if (!Global.createdBeforeFilter.hasSelection())
-						goodCreatedBefore = true;
-					else
-						goodCreatedBefore = Global.createdBeforeFilter.check(n);
-					
-					if (!Global.createdSinceFilter.hasSelection())
-						goodCreatedSince = true;
-					else
-						goodCreatedSince = Global.createdSinceFilter.check(n);
-					
-					if (!Global.changedBeforeFilter.hasSelection())
-						goodChangedBefore = true;
-					else
-						goodChangedBefore = Global.changedBeforeFilter.check(n);
-
-					if (!Global.changedSinceFilter.hasSelection())
-						goodChangedSince = true;
-					else
-						goodChangedSince = Global.changedSinceFilter.check(n);
-
-					if (!Global.containsFilter.hasSelection())
-						goodContains = true;
-					else
-						goodContains = Global.containsFilter.check(conn.getNoteTable(), n);
-					
-					if (goodCreatedSince && goodCreatedBefore && goodChangedSince && goodChangedBefore && goodContains)
-						index.add(n);
-				}
-			}
-
-		}	
-		countNotebookResults(index);
-		countTagResults(index);
+			if (filterRecord(matches.get(i)))
+				getNoteIndex().add(matches.get(i));
+		}
+		countNotebookResults(getNoteIndex());
+		countTagResults(getNoteIndex());
 		enSearchChanged = false;
-		setNoteIndex(index);
 		reloadTrashCount();
 		logger.log(logger.EXTREME, "Leaving ListManager.loadNotesIndex()");
 	}