You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
240 lines
9.3 KiB
240 lines
9.3 KiB
/* This file is part of the KOffice project
|
|
* Copyright (C) 2005 Thomas Zander <zander@kde.org>
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Library General Public
|
|
* License as published by the Free Software Foundation; version 2.
|
|
|
|
* This library 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
|
|
* Library General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Library General Public License
|
|
* along with this library; see the file COPYING.LIB. If not, write to
|
|
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
* Boston, MA 02110-1301, USA.
|
|
*/
|
|
#ifndef kwframeviewmanager_h
|
|
#define kwframeviewmanager_h
|
|
#include <tqobject.h>
|
|
#include <tqptrlist.h>
|
|
#include <tqvaluelist.h>
|
|
#include <tqvaluevector.h>
|
|
#include <defs.h>
|
|
|
|
class KWDocument;
|
|
class KWFrame;
|
|
class KWFrameSet;
|
|
class KWView;
|
|
class KWViewMode;
|
|
class KWFramesListener;
|
|
class KWFrameSetEdit;
|
|
class KWFrameView;
|
|
|
|
class KoPoint;
|
|
class KoRect;
|
|
|
|
class TQPointer;
|
|
class TQRegion;
|
|
|
|
/**
|
|
* Class that knows about all the (visible) frames in the document and will act as
|
|
* a manager between the GUI code and the data objects to couple any GUI action to the
|
|
* right frame.
|
|
* There is one KWFrameViewManager per view (stored in KWCanvas).
|
|
*
|
|
* All coordinates used in this object are point (pt) based, i.e. the same as in KWFrame. Any
|
|
* coordinates in pixels should first be converted in the KoZoomHandler (in KWord
|
|
* that's the KWDocument)
|
|
*/
|
|
class KWFrameViewManager : public TQObject {
|
|
TQ_OBJECT
|
|
|
|
|
|
public:
|
|
KWFrameViewManager();
|
|
/**
|
|
* Constructor that takes the already existing frames and framesets from doc and
|
|
* adds them.
|
|
*/
|
|
KWFrameViewManager(KWDocument *doc);
|
|
virtual ~KWFrameViewManager();
|
|
|
|
/**
|
|
* Used to change the behavior of view()<dl>
|
|
* <dt>selected</dt>
|
|
* <dd>return the first selected with the highest z-ordering (i.e. on top).</dd>
|
|
* <dt>unselected</dt>
|
|
* <dd>return the first unselected on top.</dd>
|
|
* <dt>nextUnselected</dt>
|
|
* <dd>return the first unselected directly under a selected frame, or
|
|
* the top most one if nothing is selected.</dd>
|
|
* <dt>frameOnTop</dt>
|
|
* <dd>return the frame highest z-ordering, regardless of selection.</dd>
|
|
* </dl>
|
|
*/
|
|
enum SelectionType { selected, unselected, nextUnselected, frameOnTop };
|
|
/**
|
|
* Returns a frameView representing a frame positioned at @p point, or 0 when no match found.
|
|
* @param point the position of the frame
|
|
* @param select this alters the behavior of which frame to return if more then one
|
|
* exist at the appointed location.
|
|
* @param borderOnly If true frames only frames that have the border at the point will be
|
|
* looked at.
|
|
*/
|
|
KWFrameView *view(const KoPoint &point, SelectionType select, bool borderOnly = false) const;
|
|
/** Returns a frameView representing @p frame */
|
|
KWFrameView *view(const KWFrame *frame) const;
|
|
|
|
/**
|
|
* Return all currently selected frames.
|
|
*/
|
|
TQValueList<KWFrameView*> selectedFrames() const;
|
|
/**
|
|
* Returns the first selected frame.
|
|
* Is the same as selectedFrames()[0]
|
|
*/
|
|
KWFrameView* selectedFrame() const;
|
|
|
|
// this should be changed to a real iterator
|
|
const TQValueList<KWFrameView*> frameViewsIterator() const { return m_frames; }
|
|
|
|
/**
|
|
* Return the MouseMeaning of what a click of the mouse would do at the @p point.
|
|
* All the frames that have a presence at the point are considered and depending on
|
|
* what kind of frame and where in the frame the mouse is the meaning is calculated.
|
|
* @param point the point where the mouse is hovering.
|
|
* @param keyState the bitmask of keys that are pressed. Same as Event::state();
|
|
*/
|
|
MouseMeaning mouseMeaning( const KoPoint &point, int keyState) const;
|
|
/**
|
|
* Similar to mouseMeaning(), but instead of returning the meaning this will return
|
|
* a mouse cursor to represent the action.
|
|
* @param point the point where the mouse is hovering.
|
|
* @param keyState the bitmask of keys that are pressed. Same as Event::state();
|
|
*/
|
|
TQCursor mouseCursor( const KoPoint &point, int keyState ) const;
|
|
|
|
/**
|
|
* Show a context-sensitive popup menu based on the location of 'point'.
|
|
* @param point the point at which the mouse was clicked. The context is based on
|
|
* what is present at that location.
|
|
* @param keyState the bitmask of keys that are pressed. Same as Event::state();
|
|
* @param popupPoint the point in the same coordinate system as the parent widget of
|
|
* where the popup menu should be located.
|
|
* @param view the parent widget for the popup.
|
|
*/
|
|
void showPopup( const KoPoint &point, KWView *view, int keyState, const TQPoint &popupPoint) const;
|
|
|
|
// listeners; see the fireEvents method signature for more info.
|
|
void addKWFramesListener(KWFramesListener *listener);
|
|
void removeKWFramesListener(KWFramesListener *listener);
|
|
|
|
/**
|
|
* Select frames based on a mouse click at @p point using @p keystate.
|
|
* Handles the click of a mouse and searches for frames at the location selecting and
|
|
* / or unselecting any frames based on this information.
|
|
* @param leftClick true if this select is due to the main button being clicked.
|
|
* @param point the point clicked.
|
|
* @param keyState the bitmask of keys that are pressed. Same as Event::state();
|
|
*/
|
|
void selectFrames(const KoPoint &point, int keyState, bool leftClick);
|
|
|
|
public slots:
|
|
/// notify this slot if a FrameSet has been created and should become visible.
|
|
void slotFrameSetAdded(KWFrameSet *fs);
|
|
/// notify this slot if a FrameSet has been removed
|
|
void slotFrameSetRemoved(KWFrameSet *fs);
|
|
/// notify this slot if a Frame has been created and should become visible.
|
|
void slotFrameAdded(KWFrame *f);
|
|
/// notify this slot if a Frame has been removed
|
|
void slotFrameRemoved(KWFrame *f);
|
|
/**
|
|
* notify this slot if a Frame has been moved
|
|
* @param f the frame
|
|
* @param previousYPosition the pt-based location of the frame before it was moved.
|
|
* This is used to update any views in a more intelligent matter.
|
|
*/
|
|
void slotFrameMoved(KWFrame *f, double previousYPosition);
|
|
/// notify this slot if a Frame has been resized
|
|
void slotFrameResized(KWFrame *f);
|
|
/// notify this slot if one or more frames have been selected or unselected.
|
|
void slotFrameSelectionChanged();
|
|
/// notify this slot if a frameset was renamed
|
|
void slotFrameSetRenamed(KWFrameSet *fs);
|
|
|
|
signals:
|
|
/// emitted after one or more incoming slotFrameSelectionChanged events.
|
|
void sigFrameSelectionChanged();
|
|
/// emitted after a frameset that had at least one selected frame was renamed.
|
|
void sigFrameSetRenamed();
|
|
/// emitted after frames were resized
|
|
void sigFrameResized(const TQValueList<KWFrame*>&);
|
|
/// emitted after frames were moved
|
|
void sigFrameMoved(const TQValueList<KWFrame*>&);
|
|
|
|
protected slots:
|
|
/**
|
|
* This method will propagate all the events saved up to the listeners.
|
|
* You don't normally want to call this method; call requestFireEvents() instead
|
|
* which will eventually call this method for you.
|
|
*/
|
|
void fireEvents();
|
|
|
|
protected:
|
|
/// prepare or update the singleshot timer to fire events.
|
|
#ifndef NDEBUG
|
|
virtual
|
|
#endif
|
|
void requestFireEvents();
|
|
|
|
private:
|
|
/** Internal class to store FrameEvents in (from the slots) until they are fired later */
|
|
class FrameEvent {
|
|
public:
|
|
enum ActionType { FrameRemoved, FrameAdded, FrameSetRemoved, FrameSetAdded, FrameMoved,
|
|
FrameResized, FrameSelectionChanged, FrameSetRenamed };
|
|
FrameEvent (ActionType action);
|
|
FrameEvent (ActionType action, KWFrame *frame);
|
|
FrameEvent (ActionType action, KWFrameSet *frameSet);
|
|
private:
|
|
ActionType m_action;
|
|
KWFrame *m_frame;
|
|
KWFrameSet *m_frameSet;
|
|
friend class KWFrameViewManager;
|
|
};
|
|
|
|
/// make sure the caches for pages and frame-hit positions is uptodate.
|
|
void recalculateFrameCache();
|
|
|
|
/**
|
|
* Returns a sorted list of KWFrameView objects that represents frames present at @p point
|
|
* @param point the location the frame should occupy
|
|
* @param borderOnly if true, only return frames that are hit in the border by point.
|
|
*/
|
|
TQValueVector<KWFrameView*> framesAt(const KoPoint &point, bool borderOnly = false) const;
|
|
/**
|
|
* This is a method used to sort a list using the STL sorting methods.
|
|
* @param f1 the first object
|
|
* @param f2 the second object
|
|
*/
|
|
static bool compareFrameViewZOrder(KWFrameView *f1, KWFrameView *f2);
|
|
|
|
private:
|
|
TQValueList<KWFrameView*> m_frames; // TODO TQHash<KWFrame*,KWFrameView*>
|
|
TQValueList<KWFramesListener*> m_framesListener;
|
|
TQValueList<FrameEvent*> m_frameEvents;
|
|
bool m_queueRequested, m_blockEvents;
|
|
};
|
|
|
|
class KWFramesListener {
|
|
public:
|
|
virtual void frameSetAdded(KWFrameSet *fs) = 0;
|
|
virtual void frameSetRemoved(KWFrameSet *fs) = 0;
|
|
virtual void frameAdded(KWFrame *f) = 0;
|
|
virtual void frameRemoved(KWFrame *f) = 0;
|
|
};
|
|
|
|
#endif
|