Add author-abandoned basket application

git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/basket@1072339 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 835 insertions, 0 deletions

diff --git a/src/basket.h b/src/basket.h
new file mode 100644
index 0000000..4e0331f
--- /dev/null
+++ b/src/basket.h
@@ -0,0 +1,835 @@
+/***************************************************************************
+ *   Copyright (C) 2003 by S�astien Laot                                 *
+ *   slaout@linux62.org                                                    *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.             *
+ ***************************************************************************/
+
+#ifndef BASKET_H
+#define BASKET_H
+
+#include <qscrollview.h>
+#include <qtooltip.h>
+#include <qvaluelist.h>
+#include <qtimer.h>
+#include <qimage.h>
+#include <qdatetime.h>
+#include <qclipboard.h>
+#include <kshortcut.h>
+#include <kdirwatch.h>
+#include <kaction.h>
+#include <kio/job.h>
+#include <kdialogbase.h>
+
+#include "filter.h"
+#include "note.h" // For Note::Zone
+#include "config.h"
+
+class QVBoxLayout;
+class QDomDocument;
+class QDomElement;
+
+class Basket;
+class Note;
+class NoteEditor;
+class Tag;
+#ifdef HAVE_LIBGPGME
+class KGpgMe;
+#endif
+
+/** Provide a dialog to avert the user the disk is full.
+  * This dialog is modal and is shown until the user has made space on the disk.
+  * @author S�astien Laot
+  */
+class DiskErrorDialog : public KDialogBase
+{
+  Q_OBJECT
+  public:
+	DiskErrorDialog(const QString &titleMessage, const QString &message, QWidget *parent = 0);
+	~DiskErrorDialog();
+  protected:
+	void closeEvent(QCloseEvent *event);
+	void keyPressEvent(QKeyEvent*);
+};
+
+
+/** A list of flags to set how notes are inserted/plugged in the basket
+  * Declare a varible with the type PlugOptions::Flags and assign a value like PlugOptions::DoSelection...
+  * @author S�astien Laot
+  */
+namespace PlugOptions
+{
+	enum Flags {
+		SelectOnlyNewNotes = 0x01, /// << Unselect every notes in the basket and select the newly inserted ones
+		DoTagsInheriting   = 0x02  /// << The new notes inherit the tags of the sibbling note
+	};
+	// TODO: FocusLastInsertedNote (last visible!), EnsureVisibleAddedNotes, PopupFeebackBaloon (if not called by hand), AnimateNewPosition, FeedbackUnmatched
+	// TODO: moveNoteInTree(bool animate);
+}
+
+/** This represent a hierarchy of the selected classes.
+  * If this is null, then there is no selected note.
+  */
+class NoteSelection
+{
+  public:
+	NoteSelection()        : note(0), parent(0), firstChild(0), next(0), fullPath() {}
+	NoteSelection(Note *n) : note(n), parent(0), firstChild(0), next(0), fullPath() {}
+
+	Note          *note;
+	NoteSelection *parent;
+	NoteSelection *firstChild;
+	NoteSelection *next;
+	QString        fullPath; // Needeed for 'Cut' code to store temporary path of the cutted note.
+
+	NoteSelection* firstStacked();
+	NoteSelection* nextStacked();
+	void append(NoteSelection *node);
+	int count();
+
+	QValueList<Note*> parentGroups();
+};
+
+/** This store all needed information when exporting to HTML
+  */
+class HtmlExportData
+{
+  public:
+	QString iconsFolderPath;
+	QString iconsFolderName;
+	QString imagesFolderPath;
+	QString imagesFolderName;
+	QString dataFolderPath;
+	QString dataFolderName;
+	bool    formatForImpression;
+	bool    embedLinkedFiles;
+	bool    embedLinkedFolders;
+};
+
+/** This class handle Basket and add a FilterWidget on top of it.
+  * @author S�astien Laot
+  */
+class DecoratedBasket : public QWidget
+{
+  Q_OBJECT
+  public:
+	DecoratedBasket(QWidget *parent, const QString &folderName, const char *name = 0, WFlags fl = 0);
+	~DecoratedBasket();
+	void setFilterBarPosition(bool onTop);
+	void resetFilter();
+	void setFilterBarShown(bool show, bool switchFocus = true);
+	bool isFilterBarShown()        { return m_filter->isShown();    }
+	const FilterData& filterData() { return m_filter->filterData(); }
+	FilterBar* filterBar()         { return m_filter;               }
+	Basket*    basket()            { return m_basket;               }
+  private:
+	QVBoxLayout *m_layout;
+	FilterBar   *m_filter;
+	Basket      *m_basket;
+};
+
+class TransparentWidget : public QWidget
+{
+  Q_OBJECT
+  public:
+	TransparentWidget(Basket *basket);
+	void setPosition(int x, int y);
+	//void reparent(QWidget *parent, WFlags f, const QPoint &p, bool showIt = FALSE);
+  protected:
+	void paintEvent(QPaintEvent*);
+	void mouseMoveEvent(QMouseEvent *event);
+	bool eventFilter(QObject *object, QEvent *event);
+  private:
+	Basket *m_basket;
+	int     m_x;
+	int     m_y;
+};
+
+/**
+  * @author S�astien Laot
+  */
+class Basket : public QScrollView, public QToolTip
+{
+/// CONSTRUCTOR AND DESTRUCTOR:
+  Q_OBJECT
+	public:
+		enum EncryptionTypes {
+			NoEncryption         = 0,
+			PasswordEncryption   = 1,
+			PrivateKeyEncryption = 2
+		};
+
+	public:
+	Basket(QWidget *parent, const QString &folderName);
+	~Basket();
+
+/// USER INTERACTION:
+  private:
+	bool   m_noActionOnMouseRelease;
+	bool   m_ignoreCloseEditorOnNextMouseRelease;
+	QPoint m_pressPos;
+	bool   m_canDrag;
+  public:
+	void viewportResizeEvent(QResizeEvent *);
+	void drawContents(QPainter *painter, int clipX, int clipY, int clipWidth, int clipHeight);
+	void enterEvent(QEvent *);
+	void leaveEvent(QEvent *);
+	void contentsMouseMoveEvent(QMouseEvent *event);
+	void contentsMousePressEvent(QMouseEvent *event);
+	void contentsMouseReleaseEvent(QMouseEvent *event);
+	void contentsMouseDoubleClickEvent(QMouseEvent *event);
+	void contentsContextMenuEvent(QContextMenuEvent *event);
+	void updateNote(Note *note);
+	void clickedToInsert(QMouseEvent *event, Note *clicked = 0, int zone = 0);
+  private slots:
+	void setFocusIfNotInPopupMenu();
+
+/// LAYOUT:
+  private:
+	Note   *m_firstNote;
+	int     m_columnsCount;
+	bool    m_mindMap;
+	Note   *m_resizingNote;
+	int     m_pickedResizer;
+	Note   *m_movingNote;
+	QPoint  m_pickedHandle;
+  public:
+	int tmpWidth;
+	int tmpHeight;
+  public:
+	void unsetNotesWidth();
+	void relayoutNotes(bool animate);
+	Note* noteAt(int x, int y);
+	inline Note* firstNote()       { return m_firstNote;                 }
+	inline int   columnsCount()    { return m_columnsCount;              }
+	inline bool  isColumnsLayout() { return m_columnsCount > 0;          }
+	inline bool  isFreeLayout()    { return m_columnsCount <= 0;         }
+	inline bool  isMindMap()       { return isFreeLayout() && m_mindMap; }
+	Note* resizingNote()           { return m_resizingNote;              }
+	void  deleteNotes();
+	Note* lastNote();
+	void setDisposition(int disposition, int columnCount);
+	void equalizeColumnSizes();
+
+/// NOTES INSERTION AND REMOVAL:
+  public:
+	/// The following methods assume that the note(s) to insert already all have 'this' as the parent basket:
+	void prependNoteIn(   Note *note, Note *in);     /// << Add @p note (and the next linked notes) as the first note(s) of the group @p in.
+	void appendNoteIn(    Note *note, Note *in);     /// << Add @p note (and the next linked notes) as the last note(s) of the group @p in.
+	void appendNoteAfter( Note *note, Note *after);  /// << Add @p note (and the next linked notes) just after (just below) the note @p after.
+	void appendNoteBefore(Note *note, Note *before); /// << Add @p note (and the next linked notes) just before (just above) the note @p before.
+	void groupNoteAfter(  Note *note, Note *with);   /// << Add a group at @p with place, move @p with in it, and add @p note (and the next linked notes) just after the group.
+	void groupNoteBefore( Note *note, Note *with);   /// << Add a group at @p with place, move @p with in it, and add @p note (and the next linked notes) just before the group.
+	void unplugNote(      Note *note);               /// << Unplug @p note (and its child notes) from the basket (and also decrease counts...).
+	                                                 /// <<  After that, you should delete the notes yourself. Do not call prepend/append/group... functions two times: unplug and ok
+	void ungroupNote(     Note *group);              /// << Unplug @p group but put child notes at its place.
+	/// And this one do almost all the above methods depending on the context:
+	void insertNote(Note *note, Note *clicked, int zone, const QPoint &pos = QPoint(), bool animateNewPosition = false);
+	void insertCreatedNote(Note *note);
+	/// And working with selections:
+	void unplugSelection(NoteSelection *selection);
+	void insertSelection(NoteSelection *selection, Note *after);
+	void selectSelection(NoteSelection *selection);
+  private:
+	void preparePlug(Note *note);
+  private:
+	Note  *m_clickedToInsert;
+	int    m_zoneToInsert;
+	QPoint m_posToInsert;
+	Note  *m_savedClickedToInsert;
+	int    m_savedZoneToInsert;
+	QPoint m_savedPosToInsert;
+	bool   m_isInsertPopupMenu;
+  public:
+	void saveInsertionData();
+	void restoreInsertionData();
+	void resetInsertionData();
+  public slots:
+	void insertEmptyNote(int type);
+	void insertWizard(int type);
+	void insertColor(const QColor &color);
+	void insertImage(const QPixmap &image);
+	void pasteNote(QClipboard::Mode mode = QClipboard::Clipboard);
+	void delayedCancelInsertPopupMenu();
+	void setInsertPopupMenu()    { m_isInsertPopupMenu = true;  }
+	void cancelInsertPopupMenu() { m_isInsertPopupMenu = false; }
+  private slots:
+	void hideInsertPopupMenu();
+	void timeoutHideInsertPopupMenu();
+
+/// TOOL TIPS:
+  protected:
+	void maybeTip(const QPoint &pos);
+
+/// ANIMATIONS:
+  private:
+	QValueList<Note*> m_animatedNotes;
+	QTimer            m_animationTimer;
+	int               m_deltaY;
+	QTime             m_lastFrameTime;
+	static const int FRAME_DELAY;
+  private slots:
+	void animateObjects();
+  public slots:
+	void animateLoad();
+  public:
+	void addAnimatedNote(Note *note);
+
+/// LOAD AND SAVE:
+  private:
+	bool m_loaded;
+	bool m_loadingLaunched;
+	bool m_locked;
+	bool m_shouldConvertPlainTextNotes;
+	QFrame* m_decryptBox;
+	QPushButton* m_button;
+	int m_encryptionType;
+	QString m_encryptionKey;
+#ifdef HAVE_LIBGPGME
+	KGpgMe* m_gpg;
+#endif
+        QTimer      m_inactivityAutoLockTimer;
+        void enableActions();
+
+  private slots:
+	void loadNotes(const QDomElement &notes, Note *parent);
+	void saveNotes(QDomDocument &document, QDomElement &element, Note *parent);
+	void unlock();
+protected slots:
+        void inactivityAutoLockTimeout();
+public slots:
+	void load();
+	void loadProperties(const QDomElement &properties);
+	void saveProperties(QDomDocument &document, QDomElement &properties);
+	bool save();
+  public:
+	bool isEncrypted();
+	bool isFileEncrypted();
+	bool isLocked()        { return m_locked;          };
+	void lock();
+	bool isLoaded()        { return m_loaded;          };
+	bool loadingLaunched() { return m_loadingLaunched; };
+	bool loadFromFile(const QString &fullPath, QString* string, bool isLocalEncoding = false);
+	bool loadFromFile(const QString &fullPath, QByteArray* array);
+	bool saveToFile(const QString& fullPath, const QByteArray& array);
+	bool saveToFile(const QString& fullPath, const QByteArray& array, Q_ULONG length);
+	bool saveToFile(const QString& fullPath, const QString& string, bool isLocalEncoding = false);
+	static bool safelySaveToFile(const QString& fullPath, const QByteArray& array);
+	static bool safelySaveToFile(const QString& fullPath, const QByteArray& array, Q_ULONG length);
+	static bool safelySaveToFile(const QString& fullPath, const QString& string, bool isLocalEncoding = false);
+	bool setProtection(int type, QString key);
+	int  encryptionType()  { return m_encryptionType;  };
+	QString encryptionKey(){ return m_encryptionKey;   };
+	bool saveAgain();
+
+/// BACKGROUND:
+  private:
+	QColor   m_backgroundColorSetting;
+	QString  m_backgroundImageName;
+	QPixmap *m_backgroundPixmap;
+	QPixmap *m_opaqueBackgroundPixmap;
+	QPixmap *m_selectedBackgroundPixmap;
+	bool     m_backgroundTiled;
+	QColor   m_textColorSetting;
+  public:
+	inline bool           hasBackgroundImage()     { return m_backgroundPixmap != 0;  }
+	inline const QPixmap* backgroundPixmap()       { return m_backgroundPixmap;       }
+	inline bool           isTiledBackground()      { return m_backgroundTiled;        }
+	inline QString        backgroundImageName()    { return m_backgroundImageName;    }
+	inline QColor         backgroundColorSetting() { return m_backgroundColorSetting; }
+	inline QColor         textColorSetting()       { return m_textColorSetting;       }
+	QColor backgroundColor();
+	QColor textColor();
+	void setAppearance(const QString &icon, const QString &name, const QString &backgroundImage, const QColor &backgroundColor, const QColor &textColor);
+	void blendBackground(QPainter &painter, const QRect &rect, int xPainter = -1, int yPainter = -1, bool opaque = false, QPixmap *bg = 0);
+	void unbufferizeAll();
+	void subscribeBackgroundImages();
+	void unsubscribeBackgroundImages();
+
+/// KEYBOARD SHORTCUT:
+  public: // Temporar: for deletion purpose
+	KAction *m_action;
+  private:
+	int      m_shortcutAction;
+  private slots:
+	void activatedShortcut();
+  public:
+	KShortcut shortcut() { return m_action->shortcut(); }
+	int shortcutAction() { return m_shortcutAction;     }
+	void setShortcut(KShortcut shortcut, int action);
+
+/// USER INTERACTION:
+  private:
+	Note  *m_hoveredNote;
+	int    m_hoveredZone;
+	bool   m_lockedHovering;
+	bool   m_underMouse;
+	QRect  m_inserterRect;
+	bool   m_inserterShown;
+	bool   m_inserterSplit;
+	bool   m_inserterTop;
+	bool   m_inserterGroup;
+	void placeInserter(Note *note, int zone);
+	void removeInserter();
+  public:
+//	bool inserterShown() { return m_inserterShown; }
+	bool inserterSplit() { return m_inserterSplit; }
+	bool inserterGroup() { return m_inserterGroup; }
+  public slots:
+	void doHoverEffects(Note *note, Note::Zone zone, const QPoint &pos = QPoint(0, 0)); /// << @p pos is optionnal and only used to show the link target in the statusbar
+	void doHoverEffects(const QPoint &pos);
+	void doHoverEffects(); // The same, but using the current cursor position
+	void mouseEnteredEditorWidget();
+  public:
+	void popupTagsMenu(Note *note);
+	void popupEmblemMenu(Note *note, int emblemNumber);
+	void addTagToSelectedNotes(Tag *tag);
+	void removeTagFromSelectedNotes(Tag *tag);
+	void removeAllTagsFromSelectedNotes();
+	void addStateToSelectedNotes(State *state);
+	void changeStateOfSelectedNotes(State *state);
+	bool selectedNotesHaveTags();
+	const QRect& inserterRect()  { return m_inserterRect;  }
+	bool         inserterShown() { return m_inserterShown; }
+	void drawInserter(QPainter &painter, int xPainter, int yPainter);
+	DecoratedBasket* decoration();
+	State *stateForTagFromSelectedNotes(Tag *tag);
+  public slots:
+	void activatedTagShortcut(Tag *tag);
+	void recomputeAllStyles();
+	void removedStates(const QValueList<State*> &deletedStates);
+  private slots:
+	void toggledTagInMenu(int id);
+	void toggledStateInMenu(int id);
+	void unlockHovering();
+	void disableNextClick();
+	void contentsMoved();
+  public:
+	Note  *m_tagPopupNote;
+  private:
+	Tag   *m_tagPopup;
+	QTime  m_lastDisableClick;
+
+/// SELECTION:
+  private:
+	bool   m_isSelecting;
+	bool   m_selectionStarted;
+	bool   m_selectionInvert;
+	QPoint m_selectionBeginPoint;
+	QPoint m_selectionEndPoint;
+	QRect  m_selectionRect;
+	QTimer m_autoScrollSelectionTimer;
+	void stopAutoScrollSelection();
+  private slots:
+	void doAutoScrollSelection();
+  public:
+	inline bool isSelecting() { return m_isSelecting; }
+	inline const QRect& selectionRect() { return m_selectionRect; }
+	void selectNotesIn(const QRect &rect, bool invertSelection, bool unselectOthers = true);
+	void resetWasInLastSelectionRect();
+	void selectAll();
+	void unselectAll();
+	void invertSelection();
+	void unselectAllBut(Note *toSelect);
+	void invertSelectionOf(Note *toSelect);
+	QColor selectionRectInsideColor();
+	Note* theSelectedNote();
+	NoteSelection* selectedNotes();
+
+/// BLANK SPACES DRAWING:
+  private:
+	QValueList<QRect> m_blankAreas;
+	void recomputeBlankRects();
+	QWidget *m_cornerWidget;
+
+/// COMMUNICATION WITH ITS CONTAINER:
+  signals:
+	void postMessage(const QString &message);      /// << Post a temporar message in the statusBar.
+	void setStatusBarText(const QString &message); /// << Set the permanent statusBar text or reset it if message isEmpty().
+	void resetStatusBarText();                     /// << Equivalent to setStatusBarText("").
+	void propertiesChanged(Basket *basket);
+	void countsChanged(Basket *basket);
+  public slots:
+	void linkLookChanged();
+	void signalCountsChanged();
+  private:
+	QTimer m_timerCountsChanged;
+  private slots:
+	void countsChangedTimeOut();
+
+/// NOTES COUNTING:
+  public:
+	void addSelectedNote()    { ++m_countSelecteds;   signalCountsChanged(); }
+	void removeSelectedNote() { --m_countSelecteds;   signalCountsChanged(); }
+	void resetSelectedNote()  { m_countSelecteds = 0; signalCountsChanged(); } // FIXME: Useful ???
+	int count()               { return m_count;          }
+	int countFounds()         { return m_countFounds;    }
+	int countSelecteds()      { return m_countSelecteds; }
+  private:
+	int m_count;
+	int m_countFounds;
+	int m_countSelecteds;
+
+/// PROPERTIES:
+  public:
+	QString basketName() { return m_basketName; }
+	QString icon()       { return m_icon;       }
+	QString folderName() { return m_folderName; }
+	QString fullPath();
+	QString fullPathForFileName(const QString &fileName); // Full path of an [existing or not] note in this basket
+	static QString fullPathForFolderName(const QString &folderName);
+  private:
+	QString m_basketName;
+	QString m_icon;
+	QString m_folderName;
+
+/// ACTIONS ON SELECTED NOTES FROM THE INTERFACE:
+  public slots:
+	void noteEdit(Note *note = 0L, bool justAdded = false, const QPoint &clickedPoint = QPoint());
+	void showEditedNoteWhileFiltering();
+	void noteDelete();
+	void noteDeleteWithoutConfirmation(bool deleteFilesToo = true);
+	void noteCopy();
+	void noteCut();
+	void noteOpen(Note *note = 0L);
+	void noteOpenWith(Note *note = 0L);
+	void noteSaveAs();
+	void noteGroup();
+	void noteUngroup();
+	void noteMoveOnTop();
+	void noteMoveOnBottom();
+	void noteMoveNoteUp();
+	void noteMoveNoteDown();
+	void moveSelectionTo(Note *here, bool below);
+  public:
+	enum CopyMode { CopyToClipboard, CopyToSelection, CutToClipboard };
+	void doCopy(CopyMode copyMode);
+	bool selectionIsOneGroup();
+	Note* selectedGroup();
+	Note* firstSelected();
+	Note* lastSelected();
+
+/// NOTES EDITION:
+  private:
+	NoteEditor *m_editor;
+	//QWidget    *m_rightEditorBorder;
+	TransparentWidget *m_leftEditorBorder;
+	TransparentWidget *m_rightEditorBorder;
+	bool        m_redirectEditActions;
+	int         m_editorWidth;
+	int         m_editorHeight;
+	QTimer      m_inactivityAutoSaveTimer;
+	bool        m_doNotCloseEditor;
+	int         m_editParagraph;
+	int         m_editIndex;
+  public:
+	bool isDuringEdit()        { return m_editor;              }
+	bool redirectEditActions() { return m_redirectEditActions; }
+	bool hasTextInEditor();
+	bool hasSelectedTextInEditor();
+	bool selectedAllTextInEditor();
+	Note* editedNote();
+  protected slots:
+	void selectionChangedInEditor();
+	void contentChangedInEditor();
+	void inactivityAutoSaveTimeout();
+  public slots:
+	void editorCursorPositionChanged();
+  private:
+	int m_editorX;
+	int m_editorY;
+  public slots:
+	void placeEditor(bool andEnsureVisible = false);
+	void placeEditorAndEnsureVisible();
+	bool closeEditor();
+	void closeEditorDelayed();
+	void updateEditorAppearance();
+	void editorPropertiesChanged();
+	void openBasket();
+	void closeBasket();
+
+/// FILTERING:
+  public slots:
+	void newFilter(const FilterData &data, bool andEnsureVisible = true);
+	void cancelFilter();
+	void validateFilter();
+	void filterAgain(bool andEnsureVisible = true);
+	void filterAgainDelayed();
+	bool isFiltering();
+
+/// DRAG AND DROP:
+  private:
+	bool m_isDuringDrag;
+	QValueList<Note*> m_draggedNotes;
+  public:
+	static void acceptDropEvent(QDropEvent *event, bool preCond = true);
+	void contentsDropEvent(QDropEvent *event);
+	void blindDrop(QDropEvent* event);
+	bool isDuringDrag() { return m_isDuringDrag; }
+	QValueList<Note*> draggedNotes() { return m_draggedNotes; }
+  protected:
+	void contentsDragEnterEvent(QDragEnterEvent*);
+	void contentsDragMoveEvent(QDragMoveEvent *event);
+	void contentsDragLeaveEvent(QDragLeaveEvent*);
+  public slots:
+	void slotCopyingDone2(KIO::Job *job);
+  public:
+	Note* noteForFullPath(const QString &path);
+
+/// EXPORTATION:
+  public:
+	QValueList<State*> usedStates();
+	static QString saveGradientBackground(const QColor &color, const QFont &font, const QString &folder);
+
+  public:
+	void listUsedTags(QValueList<Tag*> &list);
+
+/// MANAGE FOCUS:
+  private:
+	Note *m_focusedNote;
+  public:
+	void setFocusedNote(Note *note);
+	void focusANote();
+	void focusANonSelectedNoteAbove(bool inSameColumn);
+	void focusANonSelectedNoteBelow(bool inSameColumn);
+	void focusANonSelectedNoteBelowOrThenAbove();
+	void focusANonSelectedNoteAboveOrThenBelow();
+	Note* focusedNote() { return m_focusedNote; }
+	Note* firstNoteInStack();
+	Note* lastNoteInStack();
+	Note* firstNoteShownInStack();
+	Note* lastNoteShownInStack();
+	void selectRange(Note *start, Note *end, bool unselectOthers = true); /// FIXME: Not really a focus related method!
+	void ensureNoteVisible(Note *note);
+	virtual void keyPressEvent(QKeyEvent *event);
+	virtual void focusInEvent(QFocusEvent*);
+	virtual void focusOutEvent(QFocusEvent*);
+	QRect noteVisibleRect(Note *note); // clipped global (desktop as origin) rectangle
+	Note* firstNoteInGroup();
+	Note *noteOnHome();
+	Note *noteOnEnd();
+
+	enum NoteOn { LEFT_SIDE = 1, RIGHT_SIDE, TOP_SIDE, BOTTOM_SIDE };
+	Note* noteOn(NoteOn side);
+
+/// REIMPLEMENTED:
+  public:
+	void deleteFiles();
+	bool convertTexts();
+
+
+  public:
+	void wheelEvent(QWheelEvent *event);
+
+
+
+  public:
+	Note *m_startOfShiftSelectionNote;
+
+
+/// THE NEW FILE WATCHER:
+  private:
+	KDirWatch           *m_watcher;
+	QTimer               m_watcherTimer;
+	QValueList<QString>  m_modifiedFiles;
+  public:
+	void addWatchedFile(const QString &fullPath);
+	void removeWatchedFile(const QString &fullPath);
+  private slots:
+	void watchedFileModified(const QString &fullPath);
+	void watchedFileDeleted(const QString &fullPath);
+	void updateModifiedNotes();
+
+
+/// FROM OLD ARCHITECTURE **********************
+
+public slots:
+
+	void showFrameInsertTo() {}
+	void resetInsertTo() {}
+
+	void  computeInsertPlace(const QPoint &/*cursorPosition*/)    { }
+  public:
+
+	friend class SystemTray;
+
+/// SPEED OPTIMIZATION
+  private:
+	bool m_finishLoadOnFirstShow;
+	bool m_relayoutOnNextShow;
+  public:
+	void aboutToBeActivated();
+};
+
+
+
+
+
+
+
+
+
+#if 0
+
+#include <qwidget.h>
+#include <qscrollview.h>
+#include <qclipboard.h>
+#include <qptrlist.h>
+#include <qtimer.h>
+#include <kio/job.h>
+#include <qcolor.h>
+
+#include "filter.h"
+
+class QFrame;
+class QVBoxLayout;
+class QCheckBox;
+class QString;
+class QColor;
+class QPixmap;
+class QAction;
+class QStringList;
+class QRect;
+
+class QDomElement;
+
+class KDirWatch;
+
+class Basket;
+class Note;
+class NoteEditorBase;
+
+/** Used to enqueue a file path when the Basket receive a file modification / creation / deletion
+  * It associate the file name with an event.
+  * All this queue will be treated later.
+  * TODO: rename to class WatcherEvent ?
+  * @author S�astien Laot
+  */
+class FileEvent
+{
+  public:
+	enum Event { Modified = 1, Created, Deleted, Renamed };
+	FileEvent(Event evt, const QString &path)
+	 : event(evt), filePath(path)
+	{ }
+  public: // Because it must be fast and theire is no need to be private
+	Event   event;
+	QString filePath;
+};
+
+/** Basket that contain some Notes.
+  * @author S�astien Laot
+  */
+clas   s Bas    ket : public QScrollView
+{
+  Q_OBJECT
+  public:
+	/** Construtor and destructor */
+	Bask      et(QWidget *parent, const QString &folderName, const char *name = "", WFlags fl = 0);
+  public:
+  protected:
+	virtual void contentsContextMenuEvent(QContextMenuEvent *event);
+	virtual void contentsMousePressEvent(QMouseEvent *event); // For redirected event !!
+	virtual void showEvent(QShowEvent *);
+	/** Drag and drop functions */
+	virtual void dragEnterEvent(QDragEnterEvent*);
+	virtual void dragMoveEvent(QDragMoveEvent* event);
+	virtual void dragLeaveEvent(QDragLeaveEvent*);
+  public:
+	virtual void dropEvent(QDropEvent *event);
+	static  void acceptDropEvent(QDropEvent *event, bool preCond = true);
+	bool  canDragNote()       { return !isEmpty(); }
+	void  computeInsertPlace(const QPoint &cursorPosition);
+	Note* noteAtPosition(const QPoint &pos);
+	Note* duplicatedOf(Note *note);
+	void  checkClipboard();
+	void  processActionAsYouType(QKeyEvent *event);
+	void  exportToHTML();
+  signals:
+	void nameChanged(Basket *basket, const QString &name);
+	void iconChanged(Basket *basket, const QString &icon);
+	void notesNumberChanged(Basket *basket);
+  public slots:
+	void linkLookChanged();
+	void showNotesToolTipChanged();
+	/** Notes manipulation */
+	void insertNote(Note *note);
+	void delNote(Note *note, bool askForMirroredFile = true);
+	void changeNotePlace(Note *note);
+	void pasteNote(QClipboard::Mode mode = QClipboard::Clipboard);
+	void recolorizeNotes();
+	void reloadMirroredFolder();
+	void showMirrorOnlyOnceInfo();
+	/** Selection of note(s) */
+	void selectAll();
+	void unselectAll();
+	void unselectAllBut(Note *toSelect);
+	void invertSelection();
+	void selectRange(Note *start, Note *end);
+	void clicked(Note *note, bool controlPressed, bool shiftPressed);
+	void setFocusedNote(Note *note);
+	void focusANote();
+	void ensureVisibleNote(Note *note);
+	QRect noteRect(Note *note); // clipped global (desktop as origin) rectangle
+	/** Travel the list to find the next shown note, or the previous if step == -1, or the next after 10 if step == 10... */
+	Note* nextShownNoteFrom(Note *note, int step);
+	/** Actions on (selected) notes */
+	void editNote(Note *note, bool editAnnotations = false);
+	void editNote();
+	void delNote();
+	void copyNote();
+	void cutNote();
+	void openNote();
+	void openNoteWith();
+	void saveNoteAs();
+	void moveOnTop();
+	void moveOnBottom();
+	void moveNoteUp();
+	void moveNoteDown();
+  public:
+	void    dontCareOfCreation(const QString &path);
+	QString copyIcon(const QString &iconName, int size, const QString &destFolder);
+	QString copyFile(const QString &srcPath, const QString &destFolder, bool createIt = false);
+  protected slots:
+	void slotModifiedFile(const QString &path);
+	void slotCreatedFile(const QString &path);
+	void slotDeletedFile(const QString &path);
+	void slotUpdateNotes();
+	void placeEditor();
+	void closeEditor(bool save = true);
+	void clipboardChanged(bool selectionMode = false);
+	void selectionChanged();
+  private:
+	QTimer              m_updateTimer;
+	QPtrList<FileEvent> m_updateQueue;
+	QStringList         m_dontCare;
+	static const int    c_updateTime;
+  private:
+	void load(); // Load is performed only once, during contructor
+	void loadNotes(const QDomElement &notes);
+	bool importLauncher(const QString &type, const QDomElement &content, const QString &runCommand,
+	                    const QString &annotations/*, bool checked*/);
+	void computeShownNotes();
+
+  private:
+	KDirWatch      *m_watcher;
+	NoteEditorBase *m_editor;
+	QKeyEvent      *m_stackedKeyEvent;
+};
+
+#endif // #if 0
+
+#endif // BASKET_H