001: /**
002: * NoteListImpl.java
003: * Created on 21.02.2003, 15:43:26 Alex
004: * Package: net.sf.memoranda
005: *
006: * @author Alex V. Alishevskikh, alex@openmechanics.net
007: * Copyright (c) 2003 Memoranda Team. http://memoranda.sf.net
008: */package net.sf.memoranda;
009:
010: import java.util.Collection;
011: import java.util.Vector;
012:
013: import net.sf.memoranda.date.CalendarDate;
014: import net.sf.memoranda.date.CurrentDate;
015: import net.sf.memoranda.util.Util;
016: import nu.xom.Attribute;
017: import nu.xom.Document;
018: import nu.xom.Element;
019: import nu.xom.Elements;
020:
021: /**
022: *
023: */
024: /*$Id: NoteListImpl.java,v 1.14 2004/10/28 11:30:15 alexeya Exp $*/
025: public class NoteListImpl implements NoteList {
026:
027: private Project _project = null;
028: private Document _doc = null;
029: private Element _root = null;
030:
031: // public static final String NS_JNNL = "http://www.openmechanics.org/2003/jnotes-noteslist";
032:
033: /**
034: * Constructor for NoteListImpl.
035: */
036: public NoteListImpl(Document doc, Project prj) {
037: _doc = doc;
038: _root = _doc.getRootElement();
039: _project = prj;
040: }
041:
042: public NoteListImpl(Project prj) {
043: //_root = new Element("noteslist", NS_JNNL);
044: _root = new Element("noteslist");
045: _doc = new Document(_root);
046: _project = prj;
047: }
048:
049: public Collection getAllNotes() {
050: Vector v = new Vector();
051: Elements yrs = _root.getChildElements("year");
052: for (int yi = 0; yi < yrs.size(); yi++) {
053: Year y = new Year(yrs.get(yi));
054: Vector ms = y.getMonths();
055: for (int mi = 0; mi < ms.size(); mi++) {
056: Month m = (Month) ms.get(mi);
057: Vector ds = m.getDays();
058: for (int di = 0; di < ds.size(); di++) {
059: Day d = (Day) ds.get(di);
060: Vector ns = d.getNotes();
061: for (int ni = 0; ni < ns.size(); ni++) {
062: NoteElement n = (NoteElement) ns.get(ni);
063: v.add(new NoteImpl(n.getElement(), _project));
064: }
065: }
066: }
067: }
068: return v;
069: }
070:
071: /**
072: * @see net.sf.memoranda.NoteList#getMarkedNotes()
073: */
074: public Collection getMarkedNotes() {
075: Vector v = new Vector();
076: Elements yrs = _root.getChildElements("year");
077: for (int yi = 0; yi < yrs.size(); yi++) {
078: Year y = new Year(yrs.get(yi));
079: Vector ms = y.getMonths();
080: for (int mi = 0; mi < ms.size(); mi++) {
081: Month m = (Month) ms.get(mi);
082: Vector ds = m.getDays();
083: for (int di = 0; di < ds.size(); di++) {
084: Day d = (Day) ds.get(di);
085: Vector ns = d.getNotes();
086: for (int ni = 0; ni < ns.size(); ni++) {
087: NoteElement ne = (NoteElement) ns.get(ni);
088: Note n = new NoteImpl(ne.getElement(), _project);
089: if (n.isMarked())
090: v.add(n);
091: }
092: }
093: }
094: }
095: return v;
096: }
097:
098: public Collection getNotesForPeriod(CalendarDate startDate,
099: CalendarDate endDate) {
100: Vector v = new Vector();
101: Elements yrs = _root.getChildElements("year");
102: for (int yi = 0; yi < yrs.size(); yi++) {
103: Year y = new Year(yrs.get(yi));
104: if ((y.getValue() >= startDate.getYear())
105: && (y.getValue() <= endDate.getYear())) {
106: Vector months = y.getMonths();
107: for (int mi = 0; mi < months.size(); mi++) {
108: Month m = (Month) months.get(mi);
109: if (!((y.getValue() == startDate.getYear()) && (m
110: .getValue() < startDate.getMonth()))
111: || !((y.getValue() == endDate.getYear()) && (m
112: .getValue() > endDate.getMonth()))) {
113: Vector days = m.getDays();
114: for (int di = 0; di < days.size(); di++) {
115: Day d = (Day) days.get(di);
116: if (!((m.getValue() == startDate.getMonth()) && (d
117: .getValue() < startDate.getDay()))
118: || !((m.getValue() == endDate
119: .getMonth()) && (d
120: .getValue() > endDate
121: .getDay()))) {
122: Vector ns = d.getNotes();
123: for (int ni = 0; ni < ns.size(); ni++) {
124: NoteElement n = (NoteElement) ns
125: .get(ni);
126: v.add(new NoteImpl(n.getElement(),
127: _project));
128: }
129: }
130: }
131: }
132: }
133: }
134: }
135: return v;
136: }
137:
138: /**
139: * returns the first note for a date.
140: * @param CalendarDate
141: * @return Note
142: */
143:
144: public Note getNoteForDate(CalendarDate date) {
145: Day d = getDay(date);
146: if (d == null)
147: return null;
148: Vector ns = d.getNotes();
149: if (ns.size() > 0) {
150: NoteElement n = (NoteElement) ns.get(0);
151: Note currentNote = new NoteImpl(n.getElement(), _project);
152: return currentNote;
153: }
154: return null;
155: //return new NoteImpl(d.getElement(), _project);
156: }
157:
158: public Note createNoteForDate(CalendarDate date) {
159: Year y = getYear(date.getYear());
160: if (y == null)
161: y = createYear(date.getYear());
162: Month m = y.getMonth(date.getMonth());
163: if (m == null)
164: m = y.createMonth(date.getMonth());
165: Day d = m.getDay(date.getDay());
166: if (d == null)
167: d = m.createDay(date.getDay());
168: NoteElement ne = d.createNote(Util.generateId());
169: return new NoteImpl(ne.getElement(), _project);
170: }
171:
172: /*
173: * @see net.sf.memoranda.NoteList#removeNoteForDate(net.sf.memoranda.date.CalendarDate)
174: */
175: /* public void removeNoteForDate(CalendarDate date) {
176: Day d = getDay(date);
177: if (d == null) return;
178: d.getElement().getParent().removeChild(d.getElement());
179: }
180: */
181: public void removeNote(CalendarDate date, String id) {
182: Day d = getDay(date);
183: if (d == null)
184: return;
185: Vector ns = d.getNotes();
186: for (int i = 0; i < ns.size(); i++) {
187: NoteElement n = (NoteElement) ns.get(i);
188: Element ne = n.getElement();
189: if (ne.getAttribute("refid").getValue().equals(id))
190: d.getElement().removeChild(n.getElement());
191: }
192: // CurrentNote.set(null);
193: }
194:
195: public Note getActiveNote() {
196: //return CurrentNote.get();
197: return getNoteForDate(CurrentDate.get());
198: // FIXED: Must return the first note for today [alexeya]
199: }
200:
201: private Year getYear(int y) {
202: Elements yrs = _root.getChildElements("year");
203: String yy = new Integer(y).toString();
204: for (int i = 0; i < yrs.size(); i++)
205: if (yrs.get(i).getAttribute("year").getValue().equals(yy))
206: return new Year(yrs.get(i));
207: //return createYear(y);
208: return null;
209: }
210:
211: private Year createYear(int y) {
212: Element el = new Element("year");
213: el
214: .addAttribute(new Attribute("year", new Integer(y)
215: .toString()));
216: _root.appendChild(el);
217: return new Year(el);
218: }
219:
220: /*
221: private Vector getYears() {
222: Vector v = new Vector();
223: Elements yrs = _root.getChildElements("year");
224: for (int i = 0; i < yrs.size(); i++)
225: v.add(new Year(yrs.get(i)));
226: return v;
227: }
228: */
229: private Day getDay(CalendarDate date) {
230: Year y = getYear(date.getYear());
231: if (y == null)
232: return null;
233: Month m = y.getMonth(date.getMonth());
234: if (m == null)
235: return null;
236: return m.getDay(date.getDay());
237: }
238:
239: private class Year {
240: Element yearElement = null;
241:
242: public Year(Element el) {
243: yearElement = el;
244: }
245:
246: public int getValue() {
247: return new Integer(yearElement.getAttribute("year")
248: .getValue()).intValue();
249: }
250:
251: public Month getMonth(int m) {
252: Elements ms = yearElement.getChildElements("month");
253: String mm = new Integer(m).toString();
254: for (int i = 0; i < ms.size(); i++)
255: if (ms.get(i).getAttribute("month").getValue().equals(
256: mm))
257: return new Month(ms.get(i));
258: //return createMonth(m);
259: return null;
260: }
261:
262: private Month createMonth(int m) {
263: Element el = new Element("month");
264: el.addAttribute(new Attribute("month", new Integer(m)
265: .toString()));
266: yearElement.appendChild(el);
267: return new Month(el);
268: }
269:
270: public Vector getMonths() {
271: Vector v = new Vector();
272: Elements ms = yearElement.getChildElements("month");
273: for (int i = 0; i < ms.size(); i++)
274: v.add(new Month(ms.get(i)));
275: return v;
276: }
277:
278: public Element getElement() {
279: return yearElement;
280: }
281:
282: }
283:
284: private class Month {
285: Element mElement = null;
286:
287: public Month(Element el) {
288: mElement = el;
289: }
290:
291: public int getValue() {
292: return new Integer(mElement.getAttribute("month")
293: .getValue()).intValue();
294: }
295:
296: public Day getDay(int d) {
297: if (mElement == null)
298: return null;
299: Elements ds = mElement.getChildElements("day");
300: String dd = new Integer(d).toString();
301: for (int i = 0; i < ds.size(); i++)
302: if (ds.get(i).getAttribute("day").getValue().equals(dd))
303: return new Day(ds.get(i));
304: //return createDay(d);
305: return null;
306: }
307:
308: private Day createDay(int d) {
309: Element el = new Element("day");
310: el.addAttribute(new Attribute("day", new Integer(d)
311: .toString()));
312: /* el.addAttribute(
313: new Attribute(
314: "date",
315: new CalendarDate(
316: d,
317: getValue(),
318: new Integer(((Element) mElement.getParent()).getAttribute("year").getValue()).intValue())
319: .toString()));
320: */
321: mElement.appendChild(el);
322: return new Day(el);
323: }
324:
325: public Vector getDays() {
326: if (mElement == null)
327: return null;
328: Vector v = new Vector();
329: Elements ds = mElement.getChildElements("day");
330: for (int i = 0; i < ds.size(); i++)
331: v.add(new Day(ds.get(i)));
332: return v;
333: }
334:
335: public Element getElement() {
336: return mElement;
337: }
338:
339: }
340:
341: /*
342: * private class Day
343: */
344:
345: private class Day {
346: Element dEl = null;
347:
348: public Day(Element el) {
349: dEl = el;
350: // Added to fix old '.notes' XML format
351: // Old-style XML is converted on the fly [alexeya]
352: if (dEl.getAttribute("date") != null) {
353: Attribute dAttr = dEl.getAttribute("date");
354: Attribute tAttr = dEl.getAttribute("title");
355: Element nEl = new Element("note");
356: String date = dAttr.getValue().replace('/', '-');
357: nEl.addAttribute(new Attribute("refid", date));
358: nEl.addAttribute(new Attribute("title", tAttr
359: .getValue()));
360: dEl.appendChild(nEl);
361: dEl.removeAttribute(dAttr);
362: dEl.removeAttribute(tAttr);
363: }
364: }
365:
366: public int getValue() {
367: return new Integer(dEl.getAttribute("day").getValue())
368: .intValue();
369: }
370:
371: /*public Note getNote() {
372: return new NoteImpl(dEl);
373: }*/
374:
375: public NoteElement getNote(String d) {
376: if (dEl == null)
377: return null;
378: Elements ne = dEl.getChildElements("note");
379:
380: for (int i = 0; i < ne.size(); i++)
381: if (ne.get(i).getAttribute("refid").getValue()
382: .equals(d))
383: return new NoteElement(ne.get(i));
384: //return createDay(d);
385: return null;
386: }
387:
388: public NoteElement createNote(String d) {
389: Element el = new Element("note");
390: // el.addAttribute(new Attribute("refid", d));
391: /* el.addAttribute(new Attribute("day", new Integer(d).toString()));
392: el.addAttribute(
393: new Attribute(
394: "date",
395: new CalendarDate(
396: 10,
397: 10,
398: 2004).toString()));
399: */
400: dEl.appendChild(el);
401: return new NoteElement(el);
402: }
403:
404: public Vector getNotes() {
405: if (dEl == null)
406: return null;
407: Vector v = new Vector();
408: Elements ds = dEl.getChildElements("note");
409: for (int i = 0; i < ds.size(); i++)
410: v.add(new NoteElement(ds.get(i)));
411: return v;
412: }
413:
414: public Element getElement() {
415: return dEl;
416: }
417: }
418:
419: /*
420: * private class Day
421: */
422:
423: private class NoteElement {
424: Element nEl;
425:
426: public NoteElement(Element el) {
427: nEl = el;
428: }
429:
430: public Element getElement() {
431: return nEl;
432: }
433: }
434:
435: /**
436: * @see net.sf.memoranda.NoteList#getXMLContent()
437: */
438: public Document getXMLContent() {
439: return _doc;
440: }
441:
442: }
|