summaryrefslogtreecommitdiffstats
path: root/src/basket.h
diff options
context:
space:
mode:
Diffstat (limited to 'src/basket.h')
-rw-r--r--src/basket.h835
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
generated by cgit v1.2.1 (git 2.18.0) at 2024-11-14 22:22:09 +0000