import java.util.List;\r
import java.util.Vector;\r
\r
+import com.evernote.edam.type.LinkedNotebook;\r
import com.evernote.edam.type.Note;\r
import com.evernote.edam.type.Notebook;\r
import com.evernote.edam.type.SavedSearch;\r
import com.evernote.edam.type.Tag;\r
import com.trolltech.qt.QThread;\r
import com.trolltech.qt.core.QDateTime;\r
+import com.trolltech.qt.gui.QImage;\r
+import com.trolltech.qt.gui.QPixmap;\r
import com.trolltech.qt.sql.QSqlQuery;\r
import com.trolltech.qt.xml.QDomAttr;\r
import com.trolltech.qt.xml.QDomDocument;\r
import cx.fbn.nevernote.filters.EnSearch;\r
import cx.fbn.nevernote.filters.NotebookCounter;\r
import cx.fbn.nevernote.filters.TagCounter;\r
+import cx.fbn.nevernote.gui.NoteTableModel;\r
import cx.fbn.nevernote.signals.NotebookSignal;\r
import cx.fbn.nevernote.signals.StatusSignal;\r
import cx.fbn.nevernote.signals.TagSignal;\r
private List<Notebook> notebookIndex;\r
private List<Notebook> archiveNotebookIndex;\r
private List<String> localNotebookIndex;\r
- private List<Note> noteIndex;\r
+ \r
+ private List<LinkedNotebook> linkedNotebookIndex;\r
+\r
private List<SavedSearch> searchIndex;\r
\r
private List<String> selectedNotebooks;\r
+ private final NoteTableModel noteModel;\r
+ \r
\r
- private List<Note> masterNoteIndex;\r
- private List<String> unsynchronizedNotes;\r
private List<String> selectedTags;\r
private String selectedSearch;\r
ThreadSignal signals;\r
private final QThread tagThread;\r
\r
private final CounterRunner trashCounterRunner;\r
- private final QThread trashThread;\r
+ private final QThread trashThread;\r
public TrashSignal trashSignal;\r
- public HashMap<String,Integer> titleColors;\r
\r
private List<NotebookCounter> notebookCounter; // count of displayed notes in each notebook\r
private List<TagCounter> tagCounter; // count of displayed notes for each tag\r
public HashMap<String, String> wordMap;\r
public TagSignal tagSignal;\r
public NotebookSignal notebookSignal;\r
+ public boolean refreshCounters; // Used to control when to recount lists\r
private int trashCount;\r
- private final int id;\r
- SaveRunner saveRunner; // Thread used to save content. Used because the xml conversion is slowwwww\r
- QThread saveThread;\r
+ public SaveRunner saveRunner; // Thread used to save content. Used because the xml conversion is slowwwww\r
+ QThread saveThread;\r
\r
+// private final HashMap<String, QImage> thumbnailList;\r
+ \r
// Constructor\r
- public ListManager(DatabaseConnection d, ApplicationLogger l, int instance_id) {\r
+ public ListManager(DatabaseConnection d, ApplicationLogger l) {\r
conn = d;\r
logger = l;\r
- id = instance_id;\r
- \r
+ \r
+ conn.getTagTable().cleanupTags();\r
status = new StatusSignal();\r
signals = new ThreadSignal();\r
\r
enSearchChanged = false;\r
\r
// Setup arrays\r
- masterNoteIndex = null;\r
+ noteModel = new NoteTableModel(this);\r
selectedTags = new ArrayList<String>();\r
\r
notebookCounter = new ArrayList<NotebookCounter>();\r
tagCounter = new ArrayList<TagCounter>();\r
selectedNotebooks = new ArrayList<String>();\r
- unsynchronizedNotes = new ArrayList<String>();\r
- \r
+ \r
reloadIndexes();\r
\r
notebookSignal = new NotebookSignal();\r
- notebookCounterRunner = new CounterRunner("notebook_counter.log", CounterRunner.NOTEBOOK, Global.getDatabaseUrl(), Global.getDatabaseUserid(), Global.getDatabaseUserPassword(), Global.cipherPassword);\r
+ notebookCounterRunner = new CounterRunner("notebook_counter.log", CounterRunner.NOTEBOOK, \r
+ Global.getDatabaseUrl(), Global.getIndexDatabaseUrl(), Global.getResourceDatabaseUrl(),\r
+ Global.getDatabaseUserid(), Global.getDatabaseUserPassword(), Global.cipherPassword);\r
notebookCounterRunner.setNoteIndex(getNoteIndex());\r
notebookCounterRunner.notebookSignal.countsChanged.connect(this, "setNotebookCounter(List)");\r
notebookThread = new QThread(notebookCounterRunner, "Notebook Counter Thread");\r
notebookThread.start();\r
\r
tagSignal = new TagSignal();\r
- tagCounterRunner = new CounterRunner("tag_counter.log", CounterRunner.TAG, Global.getDatabaseUrl(), Global.getDatabaseUserid(), Global.getDatabaseUserPassword(), Global.cipherPassword);\r
+ tagCounterRunner = new CounterRunner("tag_counter.log", CounterRunner.TAG, \r
+ Global.getDatabaseUrl(), Global.getIndexDatabaseUrl(), Global.getResourceDatabaseUrl(),\r
+ Global.getDatabaseUserid(), Global.getDatabaseUserPassword(), Global.cipherPassword);\r
tagCounterRunner.setNoteIndex(getNoteIndex());\r
tagCounterRunner.tagSignal.countsChanged.connect(this, "setTagCounter(List)");\r
tagThread = new QThread(tagCounterRunner, "Tag Counter Thread");\r
tagThread.start();\r
\r
trashSignal = new TrashSignal();\r
- trashCounterRunner = new CounterRunner("trash_counter.log", CounterRunner.TRASH, Global.getDatabaseUrl(), Global.getDatabaseUserid(), Global.getDatabaseUserPassword(), Global.cipherPassword);\r
+ trashCounterRunner = new CounterRunner("trash_counter.log", CounterRunner.TRASH, \r
+ Global.getDatabaseUrl(), Global.getIndexDatabaseUrl(), Global.getResourceDatabaseUrl(),\r
+ Global.getDatabaseUserid(), Global.getDatabaseUserPassword(), Global.cipherPassword);\r
trashCounterRunner.trashSignal.countChanged.connect(this, "trashSignalReceiver(Integer)");\r
trashThread = new QThread(trashCounterRunner, "Trash Counter Thread");\r
trashThread.start();\r
- reloadTrashCount();\r
+// reloadTrashCount();\r
\r
wordMap = new HashMap<String, String>();\r
tagSignal = new TagSignal();\r
\r
logger.log(logger.EXTREME, "Setting save thread");\r
- saveRunner = new SaveRunner("saveRunner.log", Global.getDatabaseUrl(), Global.getDatabaseUserid(), Global.getDatabaseUserPassword(), Global.cipherPassword);\r
+ saveRunner = new SaveRunner("saveRunner.log", \r
+ Global.getDatabaseUrl(), Global.getIndexDatabaseUrl(), Global.getResourceDatabaseUrl(),\r
+ Global.getDatabaseUserid(), Global.getDatabaseUserPassword(), Global.cipherPassword);\r
saveThread = new QThread(saveRunner, "Save Runner Thread");\r
saveThread.start();\r
-\r
+ \r
+// thumbnailList = conn.getNoteTable().getThumbnails();\r
+// thumbnailList = new HashMap<String,QImage>();\r
+ \r
+ linkedNotebookIndex = conn.getLinkedNotebookTable().getAll();\r
loadNoteTitleColors();\r
+ refreshCounters = true;\r
+ refreshCounters();\r
\r
}\r
\r
e.printStackTrace();\r
}\r
\r
-\r
}\r
\r
//***************************************************************\r
for (int i=0; i<local.size(); i++)\r
localNotebookIndex.add(local.get(i).getGuid());\r
\r
- masterNoteIndex = conn.getNoteTable().getAllNotes();\r
+ noteModel.setMasterNoteIndex(conn.getNoteTable().getAllNotes());\r
// For performance reasons, we didn't get the tags for every note individually. We now need to \r
// get them\r
List<cx.fbn.nevernote.sql.NoteTagsRecord> noteTags = conn.getNoteTable().noteTagsTable.getAllNoteTags();\r
- for (int i=0; i<masterNoteIndex.size(); i++) {\r
+ for (int i=0; i<getMasterNoteIndex().size(); i++) {\r
List<String> tags = new ArrayList<String>();\r
List<String> names = new ArrayList<String>();\r
for (int j=0; j<noteTags.size(); j++) {\r
- if (masterNoteIndex.get(i).getGuid().equals(noteTags.get(j).noteGuid)) {\r
+ if (getMasterNoteIndex().get(i).getGuid().equals(noteTags.get(j).noteGuid)) {\r
tags.add(noteTags.get(j).tagGuid);\r
names.add(getTagNameByGuid(noteTags.get(j).tagGuid));\r
}\r
}\r
\r
- masterNoteIndex.get(i).setTagGuids(tags);\r
- masterNoteIndex.get(i).setTagNames(names);\r
+ getMasterNoteIndex().get(i).setTagGuids(tags);\r
+ getMasterNoteIndex().get(i).setTagNames(names);\r
}\r
\r
\r
setUnsynchronizedNotes(conn.getNoteTable().getUnsynchronizedGUIDs());\r
\r
+ linkedNotebookIndex = conn.getLinkedNotebookTable().getAll();\r
+ \r
enSearchChanged = true;\r
}\r
\r
+ public void reloadTagIndex() {\r
+ setTagIndex(conn.getTagTable().getAll()); \r
+ }\r
public void reloadIndexes() {\r
setUnsynchronizedNotes(conn.getNoteTable().getUnsynchronizedGUIDs());\r
\r
for (int i=0; i<local.size(); i++)\r
localNotebookIndex.add(local.get(i).getGuid());\r
\r
- // Load tags\r
- setTagIndex(conn.getTagTable().getAll());\r
+ reloadTagIndex();\r
// Load notebooks\r
setNotebookIndex(conn.getNotebookTable().getAll());\r
// load archived notebooks (if note using the EN interface)\r
// load saved search index\r
setSavedSearchIndex(conn.getSavedSearchTable().getAll());\r
// Load search helper utility\r
- enSearch = new EnSearch(conn, logger, "", getTagIndex(), Global.getMinimumWordLength(), Global.getRecognitionWeight());\r
+ enSearch = new EnSearch(conn, logger, "", getTagIndex(), Global.getRecognitionWeight());\r
logger.log(logger.HIGH, "Building note index");\r
\r
- if (masterNoteIndex == null) { \r
- masterNoteIndex = conn.getNoteTable().getAllNotes();\r
- }\r
+// if (getMasterNoteIndex() == null) { \r
+ noteModel.setMasterNoteIndex(conn.getNoteTable().getAllNotes());\r
+// }\r
// For performance reasons, we didn't get the tags for every note individually. We now need to \r
// get them\r
List<cx.fbn.nevernote.sql.NoteTagsRecord> noteTags = conn.getNoteTable().noteTagsTable.getAllNoteTags();\r
- for (int i=0; i<masterNoteIndex.size(); i++) {\r
+ for (int i=0; i<getMasterNoteIndex().size(); i++) {\r
List<String> tags = new ArrayList<String>();\r
List<String> names = new ArrayList<String>();\r
for (int j=0; j<noteTags.size(); j++) {\r
- if (masterNoteIndex.get(i).getGuid().equals(noteTags.get(j).noteGuid)) {\r
+ if (getMasterNoteIndex().get(i).getGuid().equals(noteTags.get(j).noteGuid)) {\r
tags.add(noteTags.get(j).tagGuid);\r
names.add(getTagNameByGuid(noteTags.get(j).tagGuid));\r
}\r
}\r
\r
- masterNoteIndex.get(i).setTagGuids(tags);\r
- masterNoteIndex.get(i).setTagNames(names);\r
+ getMasterNoteIndex().get(i).setTagGuids(tags);\r
+ getMasterNoteIndex().get(i).setTagNames(names);\r
}\r
\r
- setNoteIndex(masterNoteIndex);\r
+ setNoteIndex(getMasterNoteIndex());\r
\r
}\r
\r
//* selected notebooks\r
//***************************************************************\r
//***************************************************************\r
- // Return the selected notebook(s)\r
+ // Return the selected notebook(s)\r
public List<String> getSelectedNotebooks() {\r
return selectedNotebooks;\r
}\r
//** These functions deal with setting & retrieving the master lists\r
//***************************************************************\r
//***************************************************************\r
+ // Get the note table model\r
+ public NoteTableModel getNoteTableModel() {\r
+ return noteModel;\r
+ }\r
// save the saved search index\r
private void setSavedSearchIndex(List<SavedSearch> t) {\r
searchIndex = t;\r
return notebookIndex;\r
\r
}\r
+ public List<LinkedNotebook> getLinkedNotebookIndex() {\r
+ return linkedNotebookIndex;\r
+ }\r
public List<Notebook> getArchiveNotebookIndex() {\r
return archiveNotebookIndex;\r
}\r
// Save the current note list\r
private void setNoteIndex(List<Note> n) {\r
- noteIndex = n;\r
+ noteModel.setNoteIndex(n);\r
}\r
// Get the note index\r
public synchronized List<Note> getNoteIndex() {\r
- return noteIndex;\r
+ return noteModel.getNoteIndex();\r
}\r
// Save the count of notes per notebook\r
public void setNotebookCounter(List<NotebookCounter> n) {\r
}\r
// Unsynchronized Note List\r
public List<String> getUnsynchronizedNotes() {\r
- return unsynchronizedNotes;\r
+ return noteModel.getUnsynchronizedNotes();\r
}\r
public void setUnsynchronizedNotes(List<String> l) {\r
- unsynchronizedNotes = l;\r
+ noteModel.setUnsynchronizedNotes(l);\r
}\r
// Return a count of items in the trash\r
public int getTrashCount() {\r
return enSearch;\r
}\r
public List<Note> getMasterNoteIndex() {\r
- return masterNoteIndex;\r
+ return noteModel.getMasterNoteIndex();\r
+ }\r
+ // Thumbnails\r
+// public HashMap<String, QImage> getThumbnails() {\r
+// return thumbnailList;\r
+// }\r
+ public QImage getThumbnail(String guid) {\r
+// if (getThumbnails().containsKey(guid))\r
+// return getThumbnails().get(guid);\r
+ \r
+ QImage img = new QImage();\r
+ img = QImage.fromData(conn.getNoteTable().getThumbnail(guid));\r
+ if (img == null || img.isNull()) \r
+ return null;\r
+ //getThumbnails().put(guid, img);\r
+ return img;\r
+ }\r
+ public QPixmap getThumbnailPixmap(String guid) {\r
+// if (getThumbnails().containsKey(guid))\r
+// return getThumbnails().get(guid);\r
+ \r
+ QPixmap img = new QPixmap();\r
+ img.loadFromData(conn.getNoteTable().getThumbnail(guid));\r
+ if (img == null || img.isNull()) \r
+ return null;\r
+ //getThumbnails().put(guid, img);\r
+ return img;\r
}\r
- \r
//***************************************************************\r
//***************************************************************\r
//** These functions deal with setting & retrieving filters\r
//***************************************************************\r
//***************************************************************\r
public void setEnSearch(String t) {\r
- enSearch = new EnSearch(conn,logger, t, getTagIndex(), Global.getMinimumWordLength(), Global.getRecognitionWeight());\r
+ enSearch = new EnSearch(conn,logger, t, getTagIndex(), Global.getRecognitionWeight());\r
enSearchChanged = true;\r
}\r
// Save search tags\r
}\r
}\r
\r
- for (int i=0; i<noteIndex.size(); i++) {\r
- if (noteIndex.get(i).getGuid().equals(noteGuid)) {\r
- noteIndex.get(i).setTagNames(tags);\r
- noteIndex.get(i).setTagGuids(tagGuids);\r
- i=noteIndex.size()+1;\r
+ for (int i=0; i<getNoteIndex().size(); i++) {\r
+ if (getNoteIndex().get(i).getGuid().equals(noteGuid)) {\r
+ getNoteIndex().get(i).setTagNames(tags);\r
+ getNoteIndex().get(i).setTagGuids(tagGuids);\r
+ i=getNoteIndex().size()+1;\r
}\r
}\r
if (newTagCreated)\r
l=currentTime.getTimeInMillis();\r
}\r
\r
- for (int i=0; i<masterNoteIndex.size(); i++) {\r
- if (masterNoteIndex.get(i).getGuid().equals(guid)) {\r
- masterNoteIndex.get(i).setActive(false);\r
- masterNoteIndex.get(i).setDeleted(l);\r
- i=masterNoteIndex.size();\r
+ for (int i=0; i<getMasterNoteIndex().size(); i++) {\r
+ if (getMasterNoteIndex().get(i).getGuid().equals(guid)) {\r
+ getMasterNoteIndex().get(i).setActive(false);\r
+ getMasterNoteIndex().get(i).setDeleted(l);\r
+ i=getMasterNoteIndex().size();\r
}\r
}\r
for (int i=0; i<getNoteIndex().size(); i++) {\r
// Delete a note\r
public void restoreNote(String guid) {\r
trashCounterRunner.abortCount = true;\r
- for (int i=0; i<masterNoteIndex.size(); i++) {\r
- if (masterNoteIndex.get(i).getGuid().equals(guid)) {\r
- masterNoteIndex.get(i).setActive(true);\r
- masterNoteIndex.get(i).setDeleted(0);\r
- i=masterNoteIndex.size();\r
+ for (int i=0; i<getMasterNoteIndex().size(); i++) {\r
+ if (getMasterNoteIndex().get(i).getGuid().equals(guid)) {\r
+ getMasterNoteIndex().get(i).setActive(true);\r
+ getMasterNoteIndex().get(i).setDeleted(0);\r
+ i=getMasterNoteIndex().size();\r
}\r
}\r
for (int i=0; i<getNoteIndex().size(); i++) {\r
}\r
public void updateNote(Note n) {\r
\r
- for (int i=0; i<masterNoteIndex.size(); i++) {\r
- if (masterNoteIndex.get(i).getGuid().equals(n.getGuid())) {\r
- masterNoteIndex.remove(i);\r
- masterNoteIndex.add(n);\r
+ for (int i=0; i<getMasterNoteIndex().size(); i++) {\r
+ if (getMasterNoteIndex().get(i).getGuid().equals(n.getGuid())) {\r
+ getMasterNoteIndex().remove(i);\r
+ getMasterNoteIndex().add(n);\r
}\r
}\r
for (int i=0; i<getNoteIndex().size(); i++) {\r
}\r
// Add a note. \r
public void addNote(Note n) {\r
- getNoteIndex().add(n);\r
- masterNoteIndex.add(n);\r
+ noteModel.addNote(n);\r
}\r
// Expunge a note\r
public void expungeNote(String guid) {\r
trashCounterRunner.abortCount = true;\r
- for (int i=0; i<masterNoteIndex.size(); i++) {\r
- if (masterNoteIndex.get(i).getGuid().equals(guid)) {\r
- masterNoteIndex.remove(i);\r
- i=masterNoteIndex.size();\r
+ for (int i=0; i<getMasterNoteIndex().size(); i++) {\r
+ if (getMasterNoteIndex().get(i).getGuid().equals(guid)) {\r
+ getMasterNoteIndex().remove(i);\r
+ i=getMasterNoteIndex().size();\r
}\r
}\r
for (int i=0; i<getNoteIndex().size(); i++) {\r
// Expunge a note\r
public void emptyTrash() {\r
trashCounterRunner.abortCount = true; \r
- for (int i=masterNoteIndex.size()-1; i>=0; i--) {\r
- if (!masterNoteIndex.get(i).isActive()) {\r
- masterNoteIndex.remove(i);\r
+ for (int i=getMasterNoteIndex().size()-1; i>=0; i--) {\r
+ if (!getMasterNoteIndex().get(i).isActive()) {\r
+ getMasterNoteIndex().remove(i);\r
}\r
}\r
\r
}\r
// Update a note creation date\r
public void updateNoteCreatedDate(String guid, QDateTime date) {\r
- for (int i=0; i<masterNoteIndex.size(); i++) {\r
- if (masterNoteIndex.get(i).getGuid().equals(guid)) {\r
- masterNoteIndex.get(i).setCreated(date.toTime_t()*1000);\r
- i = masterNoteIndex.size();\r
- } \r
- }\r
- // Update the list tables \r
- for (int i=0; i<getNoteIndex().size(); i++) {\r
- if (getNoteIndex().get(i).getGuid().equals(guid)) {\r
- getNoteIndex().get(i).setCreated(date.toTime_t()*1000);\r
- i = getNoteIndex().size();\r
- }\r
- }\r
+ noteModel.updateNoteCreatedDate(guid, date);\r
conn.getNoteTable().updateNoteCreatedDate(guid, date);\r
}\r
// Subject date has been changed\r
public void updateNoteSubjectDate(String guid, QDateTime date) {\r
- for (int i=0; i<masterNoteIndex.size(); i++) {\r
- if (masterNoteIndex.get(i).getGuid().equals(guid)) {\r
- masterNoteIndex.get(i).getAttributes().setSubjectDate(date.toTime_t()*1000);\r
- i = masterNoteIndex.size();\r
- } \r
- }\r
- // Update the list tables \r
- for (int i=0; i<getNoteIndex().size(); i++) {\r
- if (getNoteIndex().get(i).getGuid().equals(guid)) {\r
- getNoteIndex().get(i).setCreated(date.toTime_t()*1000);\r
- i = getNoteIndex().size();\r
- }\r
- }\r
+ noteModel.updateNoteSubjectDate(guid, date);\r
conn.getNoteTable().updateNoteSubjectDate(guid, date);\r
}\r
// Author has changed\r
public void updateNoteAuthor(String guid, String author) {\r
- for (int i=0; i<masterNoteIndex.size(); i++) {\r
- if (masterNoteIndex.get(i).getGuid().equals(guid)) {\r
- masterNoteIndex.get(i).getAttributes().setAuthor(author);\r
- masterNoteIndex.get(i).getAttributes().setAltitudeIsSet(true);\r
- i = masterNoteIndex.size();\r
- } \r
- }\r
- // Update the list tables \r
- for (int i=0; i<getNoteIndex().size(); i++) {\r
- if (getNoteIndex().get(i).getGuid().equals(guid)) {\r
- getNoteIndex().get(i).getAttributes().setAuthor(author);\r
- getNoteIndex().get(i).getAttributes().setAuthorIsSet(true);\r
- i = getNoteIndex().size();\r
- }\r
- }\r
+ noteModel.updateNoteAuthor(guid, author);\r
conn.getNoteTable().updateNoteAuthor(guid, author);\r
}\r
// Author has changed\r
public void updateNoteGeoTag(String guid, Double lon, Double lat, Double alt) {\r
- for (int i=0; i<masterNoteIndex.size(); i++) {\r
- if (masterNoteIndex.get(i).getGuid().equals(guid)) {\r
- masterNoteIndex.get(i).getAttributes().setLongitude(lon);\r
- masterNoteIndex.get(i).getAttributes().setLongitudeIsSet(true);\r
- masterNoteIndex.get(i).getAttributes().setLatitude(lat);\r
- masterNoteIndex.get(i).getAttributes().setLatitudeIsSet(true);\r
- masterNoteIndex.get(i).getAttributes().setAltitude(alt);\r
- masterNoteIndex.get(i).getAttributes().setAltitudeIsSet(true);\r
- i = masterNoteIndex.size();\r
+ for (int i=0; i<getMasterNoteIndex().size(); i++) {\r
+ if (getMasterNoteIndex().get(i).getGuid().equals(guid)) {\r
+ getMasterNoteIndex().get(i).getAttributes().setLongitude(lon);\r
+ getMasterNoteIndex().get(i).getAttributes().setLongitudeIsSet(true);\r
+ getMasterNoteIndex().get(i).getAttributes().setLatitude(lat);\r
+ getMasterNoteIndex().get(i).getAttributes().setLatitudeIsSet(true);\r
+ getMasterNoteIndex().get(i).getAttributes().setAltitude(alt);\r
+ getMasterNoteIndex().get(i).getAttributes().setAltitudeIsSet(true);\r
+ i = getMasterNoteIndex().size();\r
} \r
}\r
// Update the list tables \r
}\r
conn.getNoteTable().updateNoteGeoTags(guid, lon, lat, alt);\r
}\r
- // Author has changed\r
+ // Source URL changed\r
public void updateNoteSourceUrl(String guid, String url) {\r
- for (int i=0; i<masterNoteIndex.size(); i++) {\r
- if (masterNoteIndex.get(i).getGuid().equals(guid)) {\r
- masterNoteIndex.get(i).getAttributes().setSourceURL(url);\r
- masterNoteIndex.get(i).getAttributes().setSourceURLIsSet(true);\r
- i = masterNoteIndex.size();\r
- } \r
- }\r
- // Update the list tables \r
- for (int i=0; i<getNoteIndex().size(); i++) {\r
- if (getNoteIndex().get(i).getGuid().equals(guid)) {\r
- getNoteIndex().get(i).getAttributes().setSourceURL(url);\r
- getNoteIndex().get(i).getAttributes().setSourceURLIsSet(true);\r
- i = getNoteIndex().size();\r
- }\r
- }\r
+ noteModel.updateNoteSourceUrl(guid, url);\r
conn.getNoteTable().updateNoteSourceUrl(guid, url);\r
}\r
// Update a note last changed date\r
public void updateNoteAlteredDate(String guid, QDateTime date) {\r
- for (int i=0; i<masterNoteIndex.size(); i++) {\r
- if (masterNoteIndex.get(i).getGuid().equals(guid)) {\r
- masterNoteIndex.get(i).setUpdated(date.toTime_t()*1000);\r
- i = masterNoteIndex.size();\r
- } \r
- }\r
- // Update the list tables \r
- for (int i=0; i<getNoteIndex().size(); i++) {\r
- if (getNoteIndex().get(i).getGuid().equals(guid)) {\r
- getNoteIndex().get(i).setUpdated(date.toTime_t()*1000);\r
- i = getNoteIndex().size();\r
- }\r
- }\r
- \r
+ noteModel.updateNoteChangedDate(guid, date);\r
conn.getNoteTable().updateNoteAlteredDate(guid, date);\r
}\r
// Update a note title\r
public void updateNoteTitle(String guid, String title) {\r
logger.log(logger.HIGH, "Entering ListManager.updateNoteTitle");\r
conn.getNoteTable().updateNoteTitle(guid, title);\r
- \r
- for (int i=0; i<masterNoteIndex.size(); i++) {\r
- if (masterNoteIndex.get(i).getGuid().equals(guid)) {\r
- masterNoteIndex.get(i).setTitle(title);\r
- i = masterNoteIndex.size();\r
- } \r
- }\r
- // Update the list tables \r
- for (int i=0; i<getNoteIndex().size(); i++) {\r
- if (getNoteIndex().get(i).getGuid().equals(guid)) {\r
- getNoteIndex().get(i).setTitle(title);\r
- i = getNoteIndex().size();\r
- }\r
- }\r
- \r
+ noteModel.updateNoteTitle(guid, title);\r
logger.log(logger.HIGH, "Leaving ListManager.updateNoteTitle");\r
}\r
// Update a note's notebook\r
public void updateNoteNotebook(String guid, String notebookGuid) {\r
logger.log(logger.HIGH, "Entering ListManager.updateNoteNotebook");\r
- for (int i=0; i<masterNoteIndex.size(); i++) {\r
- if (masterNoteIndex.get(i).getGuid().equals(guid)) {\r
- masterNoteIndex.get(i).setNotebookGuid(notebookGuid);\r
- i=masterNoteIndex.size();\r
- }\r
- }\r
- for (int i=0; i<getNoteIndex().size(); i++) {\r
- if (getNoteIndex().get(i).getGuid().equals(guid)) {\r
- getNoteIndex().get(i).setNotebookGuid(notebookGuid);\r
- i=masterNoteIndex.size();\r
- }\r
- }\r
+ noteModel.updateNoteNotebook(guid, notebookGuid);\r
conn.getNoteTable().updateNoteNotebook(guid, notebookGuid, true);\r
logger.log(logger.HIGH, "Leaving ListManager.updateNoteNotebook");\r
}\r
\r
conn.getNoteTable().updateNoteSequence(guid, sequence);\r
\r
- for (int i=0; i<noteIndex.size(); i++) {\r
- if (noteIndex.get(i).getGuid().equals(guid)) {\r
- noteIndex.get(i).setUpdateSequenceNum(sequence);\r
- i=noteIndex.size()+1;\r
+ for (int i=0; i<noteModel.getMasterNoteIndex().size(); i++) {\r
+ if (noteModel.getMasterNoteIndex().get(i).getGuid().equals(guid)) {\r
+ noteModel.getMasterNoteIndex().get(i).setUpdateSequenceNum(sequence);\r
+ i=noteModel.getMasterNoteIndex().size()+1;\r
+ }\r
+ }\r
+ \r
+ for (int i=0; i<getNoteIndex().size(); i++) {\r
+ if (getNoteIndex().get(i).getGuid().equals(guid)) {\r
+ getNoteIndex().get(i).setUpdateSequenceNum(sequence);\r
+ i=getNoteIndex().size()+1;\r
}\r
}\r
logger.log(logger.HIGH, "Leaving ListManager.updateNoteSequence");\r
}\r
public void updateNoteGuid(String oldGuid, String newGuid, boolean updateDatabase) {\r
logger.log(logger.HIGH, "Entering ListManager.updateNoteGuid");\r
- \r
if (updateDatabase) \r
conn.getNoteTable().updateNoteGuid(oldGuid, newGuid);\r
- \r
- for (int i=0; i<masterNoteIndex.size(); i++) {\r
- if (masterNoteIndex.get(i).getGuid() != null && masterNoteIndex.get(i).getGuid().equals(oldGuid)) {\r
- masterNoteIndex.get(i).setGuid(newGuid);\r
- i=masterNoteIndex.size()+1;\r
- }\r
- }\r
- for (int i=0; i<noteIndex.size(); i++) {\r
- if (noteIndex.get(i).getGuid() != null && noteIndex.get(i).getGuid().equals(oldGuid)) {\r
- noteIndex.get(i).setGuid(newGuid);\r
- i=noteIndex.size()+1;\r
- }\r
- }\r
+ noteModel.updateNoteGuid(oldGuid, newGuid);\r
logger.log(logger.HIGH, "Leaving ListManager.updateNoteGuid");\r
\r
}\r
logger.log(logger.HIGH, "Leaving ListManager.updateTagGuid");\r
\r
}\r
- // Count tag results\r
-// @SuppressWarnings("unused")\r
-// private void reloadTagCount() {\r
-// tagCounterRunner.threadLock.lock(); \r
-// tagCounterRunner.setNoteIndex(getNoteIndex());\r
-// QThreadPool.globalInstance().tryStart(tagCounterRunner);\r
-// tagCounterRunner.threadLock.unlock();\r
-// }\r
+\r
\r
//************************************************************************************\r
//************************************************************************************\r
for (int i=0; i<getNotebookIndex().size(); i++) {\r
if (getNotebookIndex().get(i).getGuid().equals(guid)) {\r
getNotebookIndex().remove(i);\r
- i=masterNoteIndex.size();\r
+ i=getMasterNoteIndex().size();\r
}\r
}\r
conn.getNotebookTable().expungeNotebook(guid, true); \r
}\r
+ // Rename a stack\r
+ public void renameStack(String oldName, String newName) {\r
+ for (int i=0; i<getNotebookIndex().size(); i++) {\r
+ if (getNotebookIndex().get(i).getStack() != null && \r
+ getNotebookIndex().get(i).getStack().equalsIgnoreCase(oldName)) {\r
+ getNotebookIndex().get(i).setStack(newName);\r
+ }\r
+ } \r
+ }\r
// Update a notebook sequence number\r
public void updateNotebookSequence(String guid, int sequence) {\r
logger.log(logger.HIGH, "Entering ListManager.updateNotebookSequence");\r
logger.log(logger.HIGH, "Leaving ListManager.updateNotebookGuid");\r
\r
}\r
+ // Update a notebook Guid number\r
+ public void updateNotebookStack(String oldGuid, String stack) {\r
+ logger.log(logger.HIGH, "Entering ListManager.updateNotebookGuid");\r
+\r
+ conn.getNotebookTable().setStack(oldGuid, stack);\r
+ \r
+ for (int i=0; i<notebookIndex.size(); i++) {\r
+ if (notebookIndex.get(i).getGuid().equals(oldGuid)) {\r
+ notebookIndex.get(i).setStack(stack);\r
+ i=notebookIndex.size()+1;\r
+ }\r
+ }\r
+ logger.log(logger.HIGH, "Leaving ListManager.updateNotebookGuid");\r
+\r
+ }\r
\r
\r
//************************************************************************************\r
//** Load and filter the note index\r
//************************************************************************************\r
//************************************************************************************\r
-// public void clearNoteIndexSearch() {\r
-// setNoteIndex(masterNoteIndex);\r
-// }\r
- // Load the note index based upon what the user wants.\r
- public void loadNotesIndex() {\r
- logger.log(logger.EXTREME, "Entering ListManager.loadNotesIndex()");\r
+ \r
+ public void noteDownloaded(Note n) {\r
+ boolean found = false;\r
+ for (int i=0; i<getMasterNoteIndex().size(); i++) {\r
+ if (getMasterNoteIndex().get(i).getGuid().equals(n.getGuid())) {\r
+ getMasterNoteIndex().set(i,n);\r
+ found = true;\r
+ i=getMasterNoteIndex().size();\r
+ }\r
+ }\r
+ \r
+ if (!found)\r
+ getMasterNoteIndex().add(n);\r
+ \r
+ for (int i=0; i<getNoteIndex().size(); i++) {\r
+ if (getNoteIndex().get(i).getGuid().equals(n.getGuid())) {\r
+ if (filterRecord(getNoteIndex().get(i)))\r
+ getNoteIndex().add(n);\r
+ getNoteIndex().remove(i);\r
+ i=getNoteIndex().size();\r
+ }\r
+ }\r
+ \r
+ if (filterRecord(n))\r
+ getNoteIndex().add(n);\r
+ \r
+ }\r
+ // Check if a note matches the currently selected notebooks, tags, or attribute searches.\r
+ public boolean filterRecord(Note n) {\r
+ \r
+ boolean goodNotebook = false;\r
+ boolean goodTag = false;\r
+ boolean goodStatus = false;\r
+ \r
+ // Check note status\r
+ if (!n.isActive() && Global.showDeleted)\r
+ return true;\r
+ else {\r
+ if (n.isActive() && !Global.showDeleted)\r
+ goodStatus = true;\r
+ }\r
+ \r
+ // Begin filtering results\r
+ if (goodStatus)\r
+ goodNotebook = filterByNotebook(n.getNotebookGuid());\r
+ if (goodNotebook) \r
+ goodTag = filterByTag(n.getTagGuids());\r
+ if (goodTag) {\r
+ boolean goodCreatedBefore = false;\r
+ boolean goodCreatedSince = false;\r
+ boolean goodChangedBefore = false;\r
+ boolean goodChangedSince = false;\r
+ boolean goodContains = false;\r
+ if (!Global.createdBeforeFilter.hasSelection())\r
+ goodCreatedBefore = true;\r
+ else\r
+ goodCreatedBefore = Global.createdBeforeFilter.check(n);\r
+ \r
+ if (!Global.createdSinceFilter.hasSelection())\r
+ goodCreatedSince = true;\r
+ else\r
+ goodCreatedSince = Global.createdSinceFilter.check(n);\r
+ \r
+ if (!Global.changedBeforeFilter.hasSelection())\r
+ goodChangedBefore = true;\r
+ else\r
+ goodChangedBefore = Global.changedBeforeFilter.check(n);\r
+ if (!Global.changedSinceFilter.hasSelection())\r
+ goodChangedSince = true;\r
+ else\r
+ goodChangedSince = Global.changedSinceFilter.check(n);\r
+ if (!Global.containsFilter.hasSelection())\r
+ goodContains = true;\r
+ else\r
+ goodContains = Global.containsFilter.check(conn.getNoteTable(), n);\r
+ \r
+ if (goodCreatedSince && goodCreatedBefore && goodChangedSince && goodChangedBefore && goodContains)\r
+ return true;\r
+ } \r
+ return false;\r
+ }\r
+ \r
+ // Trigger a recount of counters\r
+ public void refreshCounters() {\r
+// refreshCounters= false;\r
+ if (!refreshCounters)\r
+ return;\r
+ refreshCounters = false;\r
tagCounterRunner.abortCount = true;\r
notebookCounterRunner.abortCount = true;\r
trashCounterRunner.abortCount = true;\r
- \r
- List<Note> index = new ArrayList<Note>();\r
+ countNotebookResults(getNoteIndex());\r
+ countTagResults(getNoteIndex());\r
+ reloadTrashCount();\r
+\r
+ }\r
+ // Load the note index based upon what the user wants.\r
+ public void loadNotesIndex() {\r
+ logger.log(logger.EXTREME, "Entering ListManager.loadNotesIndex()");\r
\r
List<Note> matches;\r
- if (enSearchChanged || masterNoteIndex == null)\r
+ if (enSearchChanged || getMasterNoteIndex() == null)\r
matches = enSearch.matchWords();\r
else\r
- matches = masterNoteIndex;\r
+ matches = getMasterNoteIndex();\r
\r
if (matches == null)\r
- matches = masterNoteIndex;\r
+ matches = getMasterNoteIndex();\r
\r
+ setNoteIndex(new ArrayList<Note>());\r
for (int i=0; i<matches.size(); i++) {\r
- Note n = matches.get(i);\r
- boolean goodNotebook = false;\r
- boolean goodTag = false;\r
- boolean goodAttribute = false;\r
- boolean goodStatus = false;\r
- \r
- // Check note status\r
- if (!n.isActive() && Global.showDeleted)\r
- index.add(n);\r
- else {\r
- if (n.isActive() && !Global.showDeleted)\r
- goodStatus = true;\r
- // Begin filtering results\r
- if (goodStatus)\r
- goodNotebook = filterByNotebook(n.getNotebookGuid());\r
- if (goodNotebook) \r
- goodTag = filterByTag(n.getTagGuids());\r
- if (goodTag)\r
- goodAttribute = conn.getNoteTable().checkAttributeSelection(n);\r
- if (goodAttribute)\r
- index.add(n);\r
- }\r
-\r
- } \r
- countNotebookResults(index);\r
- countTagResults(index);\r
+ if (filterRecord(matches.get(i)))\r
+ getNoteIndex().add(matches.get(i));\r
+ }\r
+ refreshCounters = true;\r
enSearchChanged = false;\r
- setNoteIndex(index);\r
- reloadTrashCount();\r
logger.log(logger.EXTREME, "Leaving ListManager.loadNotesIndex()");\r
}\r
public void countNotebookResults(List<Note> index) {\r
logger.log(logger.EXTREME, "Entering ListManager.countNotebookResults()");\r
- if (!Global.mimicEvernoteInterface) {\r
+ notebookCounterRunner.abortCount = true;\r
+ if (!Global.mimicEvernoteInterface) \r
notebookCounterRunner.setNoteIndex(index);\r
- notebookCounterRunner.release(CounterRunner.NOTEBOOK);\r
- } else {\r
- notebookCounterRunner.setNoteIndex(masterNoteIndex);\r
- notebookCounterRunner.release(CounterRunner.NOTEBOOK_ALL);\r
- }\r
+ else \r
+ notebookCounterRunner.setNoteIndex(getMasterNoteIndex());\r
+ notebookCounterRunner.release(CounterRunner.NOTEBOOK);\r
logger.log(logger.EXTREME, "Leaving ListManager.countNotebookResults()");\r
}\r
public void countTagResults(List<Note> index) {\r
logger.log(logger.EXTREME, "Entering ListManager.countTagResults");\r
- if (!Global.tagBehavior().equalsIgnoreCase("DoNothing")) {\r
+ trashCounterRunner.abortCount = true;\r
+ if (!Global.tagBehavior().equalsIgnoreCase("DoNothing")) \r
tagCounterRunner.setNoteIndex(index);\r
- tagCounterRunner.release(CounterRunner.TAG);\r
- } else {\r
- tagCounterRunner.setNoteIndex(null);\r
- tagCounterRunner.release(CounterRunner.TAG_ALL);\r
- }\r
+ else\r
+ tagCounterRunner.setNoteIndex(getMasterNoteIndex());\r
+ tagCounterRunner.release(CounterRunner.TAG);\r
logger.log(logger.EXTREME, "Leaving ListManager.countTagResults()");\r
}\r
// Update the count of items in the trash\r
public void reloadTrashCount() {\r
logger.log(logger.EXTREME, "Entering ListManager.reloadTrashCount");\r
- trashCounterRunner.setNoteIndex(getNoteIndex());\r
+ trashCounterRunner.abortCount = true;\r
+ trashCounterRunner.setNoteIndex(getMasterNoteIndex());\r
trashCounterRunner.release(CounterRunner.TRASH);\r
logger.log(logger.EXTREME, "Leaving ListManager.reloadTrashCount");\r
} \r
if (selectedTags.size() == 0) \r
return true;\r
\r
- for (int i=0; i<selectedTags.size(); i++) {\r
- String selectedGuid = selectedTags.get(i);\r
- if (noteTags.contains(selectedGuid))\r
- return true;\r
+ if (!Global.anyTagSelectionMatch()) {\r
+ for (int i=0; i<selectedTags.size(); i++) {\r
+ String selectedGuid = selectedTags.get(i);\r
+ if (!noteTags.contains(selectedGuid))\r
+ return false;\r
+ }\r
+ return true;\r
+ } else {\r
+ for (int i=0; i<selectedTags.size(); i++) {\r
+ String selectedGuid = selectedTags.get(i);\r
+ if (noteTags.contains(selectedGuid))\r
+ return true;\r
+ }\r
+ return false;\r
}\r
- return false;\r
}\r
\r
- \r
+ public void setNoteSynchronized(String guid, boolean value) {\r
+ getNoteTableModel().updateNoteSyncStatus(guid, value);\r
+ }\r
\r
public void updateNoteTitleColor(String guid, Integer color) {\r
- titleColors.remove(guid);\r
- titleColors.put(guid, color);\r
+ noteModel.updateNoteTitleColor(guid, color);\r
conn.getNoteTable().setNoteTitleColor(guid, color);\r
}\r
public void loadNoteTitleColors() {\r
List<Pair<String,Integer>> colors = conn.getNoteTable().getNoteTitleColors();\r
- if (titleColors == null)\r
- titleColors = new HashMap<String,Integer>();\r
+ if (noteModel.getTitleColors() == null)\r
+ noteModel.setTitleColors(new HashMap<String,Integer>());\r
else\r
- titleColors.clear();\r
+ noteModel.getTitleColors().clear();\r
for (int i=0; i<colors.size(); i++) {\r
- titleColors.put(colors.get(i).getFirst(), colors.get(i).getSecond());\r
+ noteModel.getTitleColors().put(colors.get(i).getFirst(), colors.get(i).getSecond());\r
}\r
}\r
\r
}\r
}\r
\r
- \r
- \r
public boolean threadCheck(int id) {\r
if (id == Global.notebookCounterThreadId) \r
return notebookThread.isAlive();\r
OSDN Git Service
