|
|
/***************************************************************************
|
|
|
* 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 <tqscrollview.h>
|
|
|
#include <tqtooltip.h>
|
|
|
#include <tqvaluelist.h>
|
|
|
#include <tqtimer.h>
|
|
|
#include <tqimage.h>
|
|
|
#include <tqdatetime.h>
|
|
|
#include <tqclipboard.h>
|
|
|
#include <tdeshortcut.h>
|
|
|
#include <kdirwatch.h>
|
|
|
#include <tdeaction.h>
|
|
|
#include <tdeio/job.h>
|
|
|
#include <kdialogbase.h>
|
|
|
|
|
|
#include "filter.h"
|
|
|
#include "note.h" // For Note::Zone
|
|
|
|
|
|
#define BASKET_USE_DRKONQI
|
|
|
|
|
|
class TQVBoxLayout;
|
|
|
class TQDomDocument;
|
|
|
class TQDomElement;
|
|
|
|
|
|
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
|
|
|
{
|
|
|
TQ_OBJECT
|
|
|
|
|
|
public:
|
|
|
DiskErrorDialog(const TQString &titleMessage, const TQString &message, TQWidget *parent = 0);
|
|
|
~DiskErrorDialog();
|
|
|
protected:
|
|
|
void closeEvent(TQCloseEvent *event);
|
|
|
void keyPressEvent(TQKeyEvent*);
|
|
|
};
|
|
|
|
|
|
|
|
|
/** 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;
|
|
|
TQString fullPath; // Needeed for 'Cut' code to store temporary path of the cutted note.
|
|
|
|
|
|
NoteSelection* firstStacked();
|
|
|
NoteSelection* nextStacked();
|
|
|
void append(NoteSelection *node);
|
|
|
int count();
|
|
|
|
|
|
TQValueList<Note*> parentGroups();
|
|
|
};
|
|
|
|
|
|
/** This store all needed information when exporting to HTML
|
|
|
*/
|
|
|
class HtmlExportData
|
|
|
{
|
|
|
public:
|
|
|
TQString iconsFolderPath;
|
|
|
TQString iconsFolderName;
|
|
|
TQString imagesFolderPath;
|
|
|
TQString imagesFolderName;
|
|
|
TQString dataFolderPath;
|
|
|
TQString 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 TQWidget
|
|
|
{
|
|
|
TQ_OBJECT
|
|
|
|
|
|
public:
|
|
|
DecoratedBasket(TQWidget *parent, const TQString &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:
|
|
|
TQVBoxLayout *m_layout;
|
|
|
FilterBar *m_filter;
|
|
|
Basket *m_basket;
|
|
|
};
|
|
|
|
|
|
class TransparentWidget : public TQWidget
|
|
|
{
|
|
|
TQ_OBJECT
|
|
|
|
|
|
public:
|
|
|
TransparentWidget(Basket *basket);
|
|
|
void setPosition(int x, int y);
|
|
|
//void reparent(TQWidget *parent, WFlags f, const TQPoint &p, bool showIt = FALSE);
|
|
|
protected:
|
|
|
void paintEvent(TQPaintEvent*);
|
|
|
void mouseMoveEvent(TQMouseEvent *event);
|
|
|
bool eventFilter(TQObject *object, TQEvent *event);
|
|
|
private:
|
|
|
Basket *m_basket;
|
|
|
int m_x;
|
|
|
int m_y;
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* @author S<>astien Laot
|
|
|
*/
|
|
|
class Basket : public TQScrollView, public TQToolTip
|
|
|
{
|
|
|
/// CONSTRUCTOR AND DESTRUCTOR:
|
|
|
TQ_OBJECT
|
|
|
|
|
|
public:
|
|
|
enum EncryptionTypes {
|
|
|
NoEncryption = 0,
|
|
|
PasswordEncryption = 1,
|
|
|
PrivateKeyEncryption = 2
|
|
|
};
|
|
|
|
|
|
public:
|
|
|
Basket(TQWidget *parent, const TQString &folderName);
|
|
|
~Basket();
|
|
|
|
|
|
/// USER INTERACTION:
|
|
|
private:
|
|
|
bool m_noActionOnMouseRelease;
|
|
|
bool m_ignoreCloseEditorOnNextMouseRelease;
|
|
|
TQPoint m_pressPos;
|
|
|
bool m_canDrag;
|
|
|
public:
|
|
|
void viewportResizeEvent(TQResizeEvent *);
|
|
|
void drawContents(TQPainter *painter, int clipX, int clipY, int clipWidth, int clipHeight);
|
|
|
void enterEvent(TQEvent *);
|
|
|
void leaveEvent(TQEvent *);
|
|
|
void contentsMouseMoveEvent(TQMouseEvent *event);
|
|
|
void contentsMousePressEvent(TQMouseEvent *event);
|
|
|
void contentsMouseReleaseEvent(TQMouseEvent *event);
|
|
|
void contentsMouseDoubleClickEvent(TQMouseEvent *event);
|
|
|
void contentsContextMenuEvent(TQContextMenuEvent *event);
|
|
|
void updateNote(Note *note);
|
|
|
void clickedToInsert(TQMouseEvent *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;
|
|
|
TQPoint 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 TQPoint &pos = TQPoint(), 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;
|
|
|
TQPoint m_posToInsert;
|
|
|
Note *m_savedClickedToInsert;
|
|
|
int m_savedZoneToInsert;
|
|
|
TQPoint 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 TQColor &color);
|
|
|
void insertImage(const TQPixmap &image);
|
|
|
void pasteNote(TQClipboard::Mode mode = TQClipboard::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 TQPoint &pos);
|
|
|
|
|
|
/// ANIMATIONS:
|
|
|
private:
|
|
|
TQValueList<Note*> m_animatedNotes;
|
|
|
TQTimer m_animationTimer;
|
|
|
int m_deltaY;
|
|
|
TQTime 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;
|
|
|
TQFrame* m_decryptBox;
|
|
|
TQPushButton* m_button;
|
|
|
int m_encryptionType;
|
|
|
TQString m_encryptionKey;
|
|
|
#ifdef HAVE_LIBGPGME
|
|
|
KGpgMe* m_gpg;
|
|
|
#endif
|
|
|
TQTimer m_inactivityAutoLockTimer;
|
|
|
void enableActions();
|
|
|
|
|
|
private slots:
|
|
|
void loadNotes(const TQDomElement ¬es, Note *parent);
|
|
|
void saveNotes(TQDomDocument &document, TQDomElement &element, Note *parent);
|
|
|
void unlock();
|
|
|
protected slots:
|
|
|
void inactivityAutoLockTimeout();
|
|
|
public slots:
|
|
|
void load();
|
|
|
void loadProperties(const TQDomElement &properties);
|
|
|
void saveProperties(TQDomDocument &document, TQDomElement &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 TQString &fullPath, TQString* string, bool isLocalEncoding = false);
|
|
|
bool loadFromFile(const TQString &fullPath, TQByteArray* array);
|
|
|
bool saveToFile(const TQString& fullPath, const TQByteArray& array);
|
|
|
bool saveToFile(const TQString& fullPath, const TQByteArray& array, TQ_ULONG length);
|
|
|
bool saveToFile(const TQString& fullPath, const TQString& string, bool isLocalEncoding = false);
|
|
|
static bool safelySaveToFile(const TQString& fullPath, const TQByteArray& array);
|
|
|
static bool safelySaveToFile(const TQString& fullPath, const TQByteArray& array, TQ_ULONG length);
|
|
|
static bool safelySaveToFile(const TQString& fullPath, const TQString& string, bool isLocalEncoding = false);
|
|
|
bool setProtection(int type, TQString key);
|
|
|
int encryptionType() { return m_encryptionType; };
|
|
|
TQString encryptionKey(){ return m_encryptionKey; };
|
|
|
bool saveAgain();
|
|
|
|
|
|
/// BACKGROUND:
|
|
|
private:
|
|
|
TQColor m_backgroundColorSetting;
|
|
|
TQString m_backgroundImageName;
|
|
|
TQPixmap *m_backgroundPixmap;
|
|
|
TQPixmap *m_opaqueBackgroundPixmap;
|
|
|
TQPixmap *m_selectedBackgroundPixmap;
|
|
|
bool m_backgroundTiled;
|
|
|
TQColor m_textColorSetting;
|
|
|
public:
|
|
|
inline bool hasBackgroundImage() { return m_backgroundPixmap != 0; }
|
|
|
inline const TQPixmap* backgroundPixmap() { return m_backgroundPixmap; }
|
|
|
inline bool isTiledBackground() { return m_backgroundTiled; }
|
|
|
inline TQString backgroundImageName() { return m_backgroundImageName; }
|
|
|
inline TQColor backgroundColorSetting() { return m_backgroundColorSetting; }
|
|
|
inline TQColor textColorSetting() { return m_textColorSetting; }
|
|
|
TQColor backgroundColor();
|
|
|
TQColor textColor();
|
|
|
void setAppearance(const TQString &icon, const TQString &name, const TQString &backgroundImage, const TQColor &backgroundColor, const TQColor &textColor);
|
|
|
void blendBackground(TQPainter &painter, const TQRect &rect, int xPainter = -1, int yPainter = -1, bool opaque = false, TQPixmap *bg = 0);
|
|
|
void unbufferizeAll();
|
|
|
void subscribeBackgroundImages();
|
|
|
void unsubscribeBackgroundImages();
|
|
|
|
|
|
/// KEYBOARD SHORTCUT:
|
|
|
public: // Temporar: for deletion purpose
|
|
|
TDEAction *m_action;
|
|
|
private:
|
|
|
int m_shortcutAction;
|
|
|
private slots:
|
|
|
void activatedShortcut();
|
|
|
public:
|
|
|
TDEShortcut shortcut() { return m_action->shortcut(); }
|
|
|
int shortcutAction() { return m_shortcutAction; }
|
|
|
void setShortcut(TDEShortcut shortcut, int action);
|
|
|
|
|
|
/// USER INTERACTION:
|
|
|
private:
|
|
|
Note *m_hoveredNote;
|
|
|
int m_hoveredZone;
|
|
|
bool m_lockedHovering;
|
|
|
bool m_underMouse;
|
|
|
TQRect 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 TQPoint &pos = TQPoint(0, 0)); /// << @p pos is optionnal and only used to show the link target in the statusbar
|
|
|
void doHoverEffects(const TQPoint &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 TQRect& inserterRect() { return m_inserterRect; }
|
|
|
bool inserterShown() { return m_inserterShown; }
|
|
|
void drawInserter(TQPainter &painter, int xPainter, int yPainter);
|
|
|
DecoratedBasket* decoration();
|
|
|
State *stateForTagFromSelectedNotes(Tag *tag);
|
|
|
public slots:
|
|
|
void activatedTagShortcut(Tag *tag);
|
|
|
void recomputeAllStyles();
|
|
|
void removedStates(const TQValueList<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;
|
|
|
TQTime m_lastDisableClick;
|
|
|
|
|
|
/// SELECTION:
|
|
|
private:
|
|
|
bool m_isSelecting;
|
|
|
bool m_selectionStarted;
|
|
|
bool m_selectionInvert;
|
|
|
TQPoint m_selectionBeginPoint;
|
|
|
TQPoint m_selectionEndPoint;
|
|
|
TQRect m_selectionRect;
|
|
|
TQTimer m_autoScrollSelectionTimer;
|
|
|
void stopAutoScrollSelection();
|
|
|
private slots:
|
|
|
void doAutoScrollSelection();
|
|
|
public:
|
|
|
inline bool isSelecting() { return m_isSelecting; }
|
|
|
inline const TQRect& selectionRect() { return m_selectionRect; }
|
|
|
void selectNotesIn(const TQRect &rect, bool invertSelection, bool unselectOthers = true);
|
|
|
void resetWasInLastSelectionRect();
|
|
|
void selectAll();
|
|
|
void unselectAll();
|
|
|
void invertSelection();
|
|
|
void unselectAllBut(Note *toSelect);
|
|
|
void invertSelectionOf(Note *toSelect);
|
|
|
TQColor selectionRectInsideColor();
|
|
|
Note* theSelectedNote();
|
|
|
NoteSelection* selectedNotes();
|
|
|
|
|
|
/// BLANK SPACES DRAWING:
|
|
|
private:
|
|
|
TQValueList<TQRect> m_blankAreas;
|
|
|
void recomputeBlankRects();
|
|
|
TQWidget *m_cornerWidget;
|
|
|
|
|
|
/// COMMUNICATION WITH ITS CONTAINER:
|
|
|
signals:
|
|
|
void postMessage(const TQString &message); /// << Post a temporar message in the statusBar.
|
|
|
void setStatusBarText(const TQString &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:
|
|
|
TQTimer 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:
|
|
|
TQString basketName() { return m_basketName; }
|
|
|
TQString icon() { return m_icon; }
|
|
|
TQString folderName() { return m_folderName; }
|
|
|
TQString fullPath();
|
|
|
TQString fullPathForFileName(const TQString &fileName); // Full path of an [existing or not] note in this basket
|
|
|
static TQString fullPathForFolderName(const TQString &folderName);
|
|
|
private:
|
|
|
TQString m_basketName;
|
|
|
TQString m_icon;
|
|
|
TQString m_folderName;
|
|
|
|
|
|
/// ACTIONS ON SELECTED NOTES FROM THE INTERFACE:
|
|
|
public slots:
|
|
|
void noteEdit(Note *note = 0L, bool justAdded = false, const TQPoint &clickedPoint = TQPoint());
|
|
|
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;
|
|
|
//TQWidget *m_rightEditorBorder;
|
|
|
TransparentWidget *m_leftEditorBorder;
|
|
|
TransparentWidget *m_rightEditorBorder;
|
|
|
bool m_redirectEditActions;
|
|
|
int m_editorWidth;
|
|
|
int m_editorHeight;
|
|
|
TQTimer 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;
|
|
|
TQValueList<Note*> m_draggedNotes;
|
|
|
public:
|
|
|
static void acceptDropEvent(TQDropEvent *event, bool preCond = true);
|
|
|
void contentsDropEvent(TQDropEvent *event);
|
|
|
void blindDrop(TQDropEvent* event);
|
|
|
bool isDuringDrag() { return m_isDuringDrag; }
|
|
|
TQValueList<Note*> draggedNotes() { return m_draggedNotes; }
|
|
|
protected:
|
|
|
void contentsDragEnterEvent(TQDragEnterEvent*);
|
|
|
void contentsDragMoveEvent(TQDragMoveEvent *event);
|
|
|
void contentsDragLeaveEvent(TQDragLeaveEvent*);
|
|
|
public slots:
|
|
|
void slotCopyingDone2(TDEIO::Job *job);
|
|
|
public:
|
|
|
Note* noteForFullPath(const TQString &path);
|
|
|
|
|
|
/// EXPORTATION:
|
|
|
public:
|
|
|
TQValueList<State*> usedStates();
|
|
|
static TQString saveGradientBackground(const TQColor &color, const TQFont &font, const TQString &folder);
|
|
|
|
|
|
public:
|
|
|
void listUsedTags(TQValueList<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(TQKeyEvent *event);
|
|
|
virtual void focusInEvent(TQFocusEvent*);
|
|
|
virtual void focusOutEvent(TQFocusEvent*);
|
|
|
TQRect 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(TQWheelEvent *event);
|
|
|
|
|
|
|
|
|
|
|
|
public:
|
|
|
Note *m_startOfShiftSelectionNote;
|
|
|
|
|
|
|
|
|
/// THE NEW FILE WATCHER:
|
|
|
private:
|
|
|
KDirWatch *m_watcher;
|
|
|
TQTimer m_watcherTimer;
|
|
|
TQValueList<TQString> m_modifiedFiles;
|
|
|
public:
|
|
|
void addWatchedFile(const TQString &fullPath);
|
|
|
void removeWatchedFile(const TQString &fullPath);
|
|
|
private slots:
|
|
|
void watchedFileModified(const TQString &fullPath);
|
|
|
void watchedFileDeleted(const TQString &fullPath);
|
|
|
void updateModifiedNotes();
|
|
|
|
|
|
|
|
|
/// FROM OLD ARCHITECTURE **********************
|
|
|
|
|
|
public slots:
|
|
|
|
|
|
void showFrameInsertTo() {}
|
|
|
void resetInsertTo() {}
|
|
|
|
|
|
void computeInsertPlace(const TQPoint &/*cursorPosition*/) { }
|
|
|
public:
|
|
|
|
|
|
friend class SystemTray;
|
|
|
|
|
|
/// SPEED OPTIMIZATION
|
|
|
private:
|
|
|
bool m_finishLoadOnFirstShow;
|
|
|
bool m_relayoutOnNextShow;
|
|
|
public:
|
|
|
void aboutToBeActivated();
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
|
|
#include <tqwidget.h>
|
|
|
#include <tqscrollview.h>
|
|
|
#include <tqclipboard.h>
|
|
|
#include <tqptrlist.h>
|
|
|
#include <tqtimer.h>
|
|
|
#include <tdeio/job.h>
|
|
|
#include <tqcolor.h>
|
|
|
|
|
|
#include "filter.h"
|
|
|
|
|
|
class TQFrame;
|
|
|
class TQVBoxLayout;
|
|
|
class TQCheckBox;
|
|
|
class TQString;
|
|
|
class TQColor;
|
|
|
class TQPixmap;
|
|
|
class TQAction;
|
|
|
class TQStringList;
|
|
|
class TQRect;
|
|
|
|
|
|
class TQDomElement;
|
|
|
|
|
|
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 TQString &path)
|
|
|
: event(evt), filePath(path)
|
|
|
{ }
|
|
|
public: // Because it must be fast and theire is no need to be private
|
|
|
Event event;
|
|
|
TQString filePath;
|
|
|
};
|
|
|
|
|
|
/** Basket that contain some Notes.
|
|
|
* @author S<>astien Laot
|
|
|
*/
|
|
|
clas s Bas ket : public TQScrollView
|
|
|
{
|
|
|
TQ_OBJECT
|
|
|
|
|
|
public:
|
|
|
/** Construtor and destructor */
|
|
|
Bask et(TQWidget *parent, const TQString &folderName, const char *name = "", WFlags fl = 0);
|
|
|
public:
|
|
|
protected:
|
|
|
virtual void contentsContextMenuEvent(TQContextMenuEvent *event);
|
|
|
virtual void contentsMousePressEvent(TQMouseEvent *event); // For redirected event !!
|
|
|
virtual void showEvent(TQShowEvent *);
|
|
|
/** Drag and drop functions */
|
|
|
virtual void dragEnterEvent(TQDragEnterEvent*);
|
|
|
virtual void dragMoveEvent(TQDragMoveEvent* event);
|
|
|
virtual void dragLeaveEvent(TQDragLeaveEvent*);
|
|
|
public:
|
|
|
virtual void dropEvent(TQDropEvent *event);
|
|
|
static void acceptDropEvent(TQDropEvent *event, bool preCond = true);
|
|
|
bool canDragNote() { return !isEmpty(); }
|
|
|
void computeInsertPlace(const TQPoint &cursorPosition);
|
|
|
Note* noteAtPosition(const TQPoint &pos);
|
|
|
Note* duplicatedOf(Note *note);
|
|
|
void checkClipboard();
|
|
|
void processActionAsYouType(TQKeyEvent *event);
|
|
|
void exportToHTML();
|
|
|
signals:
|
|
|
void nameChanged(Basket *basket, const TQString &name);
|
|
|
void iconChanged(Basket *basket, const TQString &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(TQClipboard::Mode mode = TQClipboard::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);
|
|
|
TQRect 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 TQString &path);
|
|
|
TQString copyIcon(const TQString &iconName, int size, const TQString &destFolder);
|
|
|
TQString copyFile(const TQString &srcPath, const TQString &destFolder, bool createIt = false);
|
|
|
protected slots:
|
|
|
void slotModifiedFile(const TQString &path);
|
|
|
void slotCreatedFile(const TQString &path);
|
|
|
void slotDeletedFile(const TQString &path);
|
|
|
void slotUpdateNotes();
|
|
|
void placeEditor();
|
|
|
void closeEditor(bool save = true);
|
|
|
void clipboardChanged(bool selectionMode = false);
|
|
|
void selectionChanged();
|
|
|
private:
|
|
|
TQTimer m_updateTimer;
|
|
|
TQPtrList<FileEvent> m_updateQueue;
|
|
|
TQStringList m_dontCare;
|
|
|
static const int c_updateTime;
|
|
|
private:
|
|
|
void load(); // Load is performed only once, during contructor
|
|
|
void loadNotes(const TQDomElement ¬es);
|
|
|
bool importLauncher(const TQString &type, const TQDomElement &content, const TQString &runCommand,
|
|
|
const TQString &annotations/*, bool checked*/);
|
|
|
void computeShownNotes();
|
|
|
|
|
|
private:
|
|
|
KDirWatch *m_watcher;
|
|
|
NoteEditorBase *m_editor;
|
|
|
TQKeyEvent *m_stackedKeyEvent;
|
|
|
};
|
|
|
|
|
|
#endif // #if 0
|
|
|
|
|
|
#endif // BASKET_H
|
