From 8362bf63dea22bbf6736609b0f49c152f975eb63 Mon Sep 17 00:00:00 2001 From: tpearson Date: Wed, 20 Jan 2010 01:29:50 +0000 Subject: Added old abandoned KDE3 version of koffice git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/koffice@1077364 283d02a7-25f6-0310-bc7c-ecb5cbfe19da --- kword/KWFrameViewManager.cpp | 434 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 434 insertions(+) create mode 100644 kword/KWFrameViewManager.cpp (limited to 'kword/KWFrameViewManager.cpp') diff --git a/kword/KWFrameViewManager.cpp b/kword/KWFrameViewManager.cpp new file mode 100644 index 00000000..2e09ff5f --- /dev/null +++ b/kword/KWFrameViewManager.cpp @@ -0,0 +1,434 @@ +/* This file is part of the KOffice project + * Copyright (C) 2005 Thomas Zander + * + * 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. + */ +#include "KWDocument.h" +#include "KWFrameViewManager.h" +#include +#include +#include + +#include +#include +#include +#include +#include "qpopupmenu.h" +#include + +KWFrameViewManager::KWFrameViewManager() : QObject() { + setName("KWFrameViewManager"); + m_queueRequested = false; + m_blockEvents = false; +} + +KWFrameViewManager::KWFrameViewManager(KWDocument *doc) { + m_queueRequested = false; + m_blockEvents = true; + QPtrListIterator frameSets = doc->framesetsIterator(); + while(frameSets.current()) { + slotFrameSetAdded(*frameSets); + ++frameSets; + } + m_blockEvents = false; + connect(doc, SIGNAL( sigFrameSetAdded(KWFrameSet*)), SLOT( slotFrameSetAdded(KWFrameSet*))); + connect(doc, SIGNAL( sigFrameSetRemoved(KWFrameSet*)), SLOT( slotFrameSetRemoved(KWFrameSet*))); + recalculateFrameCache(); +} + +KWFrameViewManager::~KWFrameViewManager() { + QValueListIterator events = m_frameEvents.begin(); + while(events != m_frameEvents.end()) { + delete (*events); + ++events; + } +} + +void KWFrameViewManager::addKWFramesListener(KWFramesListener *listener) { + m_framesListener.append(listener); +} +void KWFrameViewManager::removeKWFramesListener(KWFramesListener *listener) { + m_framesListener.remove(listener); +} + +void KWFrameViewManager::slotFrameSetAdded(KWFrameSet *fs) { + if(! m_blockEvents) + m_frameEvents.append(new FrameEvent(FrameEvent::FrameSetAdded, fs)); + connect(fs, SIGNAL( sigFrameAdded(KWFrame*)), SLOT( slotFrameAdded(KWFrame *))); + connect(fs, SIGNAL( sigFrameRemoved(KWFrame*)), SLOT( slotFrameRemoved(KWFrame *))); + connect(fs, SIGNAL( sigNameChanged(KWFrameSet*)), SLOT( slotFrameSetRenamed(KWFrameSet *))); + QPtrListIterator frames = fs->frameIterator(); + while(frames.current()) { + KWFrame *f = frames.current(); + slotFrameAdded(f); + ++frames; + } + requestFireEvents(); +} +void KWFrameViewManager::slotFrameSetRemoved(KWFrameSet *fs) { + if(! m_blockEvents) + m_frameEvents.append(new FrameEvent(FrameEvent::FrameSetRemoved, fs)); + disconnect(fs, SIGNAL( sigFrameAdded(KWFrame*)), this, SLOT( slotFrameAdded(KWFrame *))); + disconnect(fs, SIGNAL( sigFrameRemoved(KWFrame*)), this, SLOT( slotFrameRemoved(KWFrame *))); + disconnect(fs, SIGNAL( sigNameChanged(KWFrameSet*)), this, SLOT( slotFrameSetRenamed(KWFrameSet *))); + QPtrListIterator frames = fs->frameIterator(); + while(frames.current()) { + KWFrame *f = frames.current(); + slotFrameRemoved(f); + ++frames; + } + requestFireEvents(); +} +void KWFrameViewManager::slotFrameAdded(KWFrame *f) { + if(! m_blockEvents) + m_frameEvents.append(new FrameEvent(FrameEvent::FrameAdded, f)); + m_frames.append(new KWFrameView(this, f)); + requestFireEvents(); +} +void KWFrameViewManager::slotFrameRemoved(KWFrame *f) { + if(! m_blockEvents) + m_frameEvents.append(new FrameEvent(FrameEvent::FrameRemoved, f)); + QValueListIterator frames = m_frames.begin(); + while(frames != m_frames.end()) { + KWFrameView *fv = *frames; + if(fv->frame() == f) { + if(fv->selected()) + m_frameEvents.append(new FrameEvent(FrameEvent::FrameSelectionChanged)); + m_frames.remove(frames); + delete fv; + break; + } + ++frames; + } + requestFireEvents(); +} +void KWFrameViewManager::slotFrameMoved(KWFrame *f, double previousYPosition) { + Q_UNUSED(previousYPosition); // to be used for the page caches to mark them dirty + if(! m_blockEvents) + m_frameEvents.append(new FrameEvent(FrameEvent::FrameMoved, f)); + // TODO; KWFrameList update?? + // update our caches.. + requestFireEvents(); +} +void KWFrameViewManager::slotFrameResized(KWFrame *f) { + if(! m_blockEvents) + m_frameEvents.append(new FrameEvent(FrameEvent::FrameResized, f)); + // update our caches.. + requestFireEvents(); +} +void KWFrameViewManager::slotFrameSelectionChanged() { + if(! m_blockEvents) + m_frameEvents.append(new FrameEvent(FrameEvent::FrameSelectionChanged)); + // update our caches.. + requestFireEvents(); +} + +void KWFrameViewManager::slotFrameSetRenamed(KWFrameSet *fs) { + if(! m_blockEvents) + m_frameEvents.append(new FrameEvent(FrameEvent::FrameSetRenamed, fs)); + requestFireEvents(); +} + +void KWFrameViewManager::requestFireEvents() { + if(m_queueRequested && !m_blockEvents) + return; + m_queueRequested = true; + QTimer::singleShot ( 0, this, SLOT(fireEvents()) ); +} + +void KWFrameViewManager::fireEvents() { + m_queueRequested = false; + if(m_frameEvents.isEmpty()) + return; + recalculateFrameCache(); + + QValueList copy(m_frameEvents); + m_frameEvents.clear(); + + QValueList resizedFrames; + QValueList movedFrames; + QValueList listenersCopy(m_framesListener); + bool selectionChangedFired=false; + + QValueListIterator events = copy.begin(); + while(events != copy.end()) { + FrameEvent *event = *events; + + // emit based. + if(!selectionChangedFired && event->m_action == FrameEvent::FrameSelectionChanged) { + emit sigFrameSelectionChanged(); + selectionChangedFired = true; // only fire ones. + } else if(event->m_action == FrameEvent::FrameSetRenamed) { + QPtrListIterator frames = event->m_frameSet->frameIterator(); + for(;frames.current();++frames) { + if(view(frames.current())->selected()) { + emit sigFrameSetRenamed(); + break; + } + } + } else if(event->m_action == FrameEvent::FrameResized) { + resizedFrames.append(event->m_frame); + } else if(event->m_action == FrameEvent::FrameMoved) { + movedFrames.append(event->m_frame); + } + + // listener based + QValueListIterator listeners = listenersCopy.begin(); + while(listeners != listenersCopy.end()) { + if(event->m_action == FrameEvent::FrameRemoved) + (*listeners)->frameRemoved(event->m_frame); + else if(event->m_action == FrameEvent::FrameAdded) + (*listeners)->frameAdded(event->m_frame); + else if(event->m_action == FrameEvent::FrameSetRemoved) + (*listeners)->frameSetRemoved(event->m_frameSet); + else if(event->m_action == FrameEvent::FrameSetAdded) + (*listeners)->frameSetAdded(event->m_frameSet); + ++listeners; + } + + delete event; + events = copy.remove(events); + } + if(resizedFrames.count() > 0) + emit sigFrameResized(resizedFrames); + if(movedFrames.count() > 0) + emit sigFrameMoved(movedFrames); +} + +void KWFrameViewManager::recalculateFrameCache() { + // TODO :) design and implement a cache... + // list of frames sorted on y-coord, with an additional list containing a jump-index + kdDebug(31001) << "recalculateFrameCache " << m_frames.count() << " frames are currently registred" << endl; +} + +KWFrameView *KWFrameViewManager::view(const KoPoint &point, SelectionType selected, bool borderOnly) const { + QValueVector framesThatAreHit = framesAt(point, borderOnly); + bool foundCycleFrame = false; + QValueVector::iterator sortedFrames = framesThatAreHit.begin(); + while(sortedFrames != framesThatAreHit.end()) { + if(selected == nextUnselected) { + if((*sortedFrames)->selected() ) + foundCycleFrame = true; + else if(foundCycleFrame && !(*sortedFrames)->selected() ) + return *sortedFrames; + } + else if(selected == frameOnTop) + return *sortedFrames; + else { // not cycle, so simply a selected check. + if((*sortedFrames)->selected() == (selected == KWFrameViewManager::selected )) + return *sortedFrames; + } + ++sortedFrames; + } + if(selected == nextUnselected && framesThatAreHit.count() > 0) + return framesThatAreHit[0]; + return 0; +} + +QValueVector KWFrameViewManager::framesAt(const KoPoint &point, bool borderOnly) const { + QValueVector framesThatAreHit; + // This is probably the slowest and worst way to do it, mark this for optimalisation! + for(QValueListConstIterator frames = m_frames.begin(); + frames != m_frames.end(); ++frames) { + if(! (*frames)->frame()->frameSet()->isVisible()) + continue; + if(borderOnly && (*frames)->isBorderHit(point) || + !borderOnly && (*frames)->contains(point)) + framesThatAreHit.append(*frames); + } + // sort on z-ordering; top on first + std::sort(framesThatAreHit.begin(), framesThatAreHit.end(), compareFrameViewZOrder); + return framesThatAreHit; +} + +KWFrameView *KWFrameViewManager::view(const KWFrame *frame) const { + // This is probably the slowest and worst way to do it, mark this for optimalisation! + QValueListConstIterator frames = m_frames.begin(); + while(frames != m_frames.end()) { + if((*frames)->frame() == frame) + return *frames; + ++frames; + } + return 0; +} + +bool KWFrameViewManager::compareFrameViewZOrder(KWFrameView *f1, KWFrameView *f2) { + return f1->frame()->zOrder() >= f2->frame()->zOrder(); +} + +QCursor KWFrameViewManager::mouseCursor( const KoPoint &point, int keyState ) const { + KWFrameView *view = 0; + QValueVector framesThatAreHit = framesAt(point); + QValueVector::iterator sortedFrames = framesThatAreHit.begin(); + MouseMeaning meaning; + while(sortedFrames != framesThatAreHit.end()) { + meaning = (*sortedFrames)->mouseMeaning(point, keyState); + if(meaning != MEANING_NONE) { + view = (*sortedFrames); + break; + } + ++sortedFrames; + } + + if(view == 0) + return QCursor(); // default arrow shape + + KWFrameSet*frameSet = view->frame()->frameSet(); + switch ( meaning ) { + case MEANING_NONE: + return Qt::ibeamCursor; // default cursor in margins + case MEANING_MOUSE_INSIDE: + return QCursor(); // default arrow shape + case MEANING_MOUSE_INSIDE_TEXT: + return Qt::ibeamCursor; + case MEANING_MOUSE_OVER_LINK: + return Qt::PointingHandCursor; + case MEANING_MOUSE_OVER_FOOTNOTE: + return Qt::PointingHandCursor; + case MEANING_MOUSE_MOVE: + return Qt::sizeAllCursor; + case MEANING_MOUSE_SELECT: + return KCursor::handCursor(); + case MEANING_ACTIVATE_PART: + return KCursor::handCursor(); + case MEANING_TOPLEFT: + case MEANING_BOTTOMRIGHT: + return Qt::sizeFDiagCursor; + case MEANING_LEFT: + case MEANING_RIGHT: + return Qt::sizeHorCursor; + case MEANING_BOTTOMLEFT: + case MEANING_TOPRIGHT: + return Qt::sizeBDiagCursor; + case MEANING_TOP: + case MEANING_BOTTOM: + if ( frameSet->isProtectSize() || frameSet->isMainFrameset()) + return Qt::forbiddenCursor; + return Qt::sizeVerCursor; + case MEANING_RESIZE_COLUMN: + // Bug in Qt up to Qt-3.1.1 : Qt::splitVCursor and Qt::splitHCursor are swapped! +#if QT_VERSION <= 0x030101 + return Qt::splitVCursor; +#else + return Qt::splitHCursor; +#endif + case MEANING_RESIZE_ROW: +#if QT_VERSION <= 0x030101 + return Qt::splitHCursor; +#else + return Qt::splitVCursor; +#endif + case MEANING_SELECT_RANGE: + case MEANING_SELECT_COLUMN: + case MEANING_SELECT_ROW: + case MEANING_FORBIDDEN: + return KCursor::handCursor(); + } + return QCursor(); // default arrow shape +} + +MouseMeaning KWFrameViewManager::mouseMeaning( const KoPoint &point, int keyState) const { + QValueVector framesThatAreHit = framesAt(point); + QValueVector::iterator sortedFrames = framesThatAreHit.begin(); + while(sortedFrames != framesThatAreHit.end()) { + MouseMeaning answer = (*sortedFrames)->mouseMeaning(point, keyState); + if(answer != MEANING_NONE) { + //kdDebug() << "mouseMeaning at " << point << " is " << answer << endl; + return answer; + } + ++sortedFrames; + } + return MEANING_NONE; +} + +QValueList KWFrameViewManager::selectedFrames() const { + QValueList selectedFrames; + + QValueList::const_iterator frames = m_frames.begin(); + for(; frames != m_frames.end(); ++frames ) + if( (*frames)->selected() ) + selectedFrames.append( *frames ); + return selectedFrames; +} + +KWFrameView* KWFrameViewManager::selectedFrame() const { + QValueList::const_iterator frames = m_frames.begin(); + for(; frames != m_frames.end(); ++frames ) + if( (*frames)->selected() ) + return *frames; + return 0; +} + +void KWFrameViewManager::showPopup( const KoPoint &point, KWView *view, int keyState, const QPoint &popupPoint) const { + QValueVector framesThatAreHit = framesAt(point); + if(framesThatAreHit.count() == 0) { + view->popupMenu("action_popup")->popup(popupPoint); + return; + } + if(keyState == Qt::ControlButton) { + // show the border popup of the top most frame. + framesThatAreHit[0]->showPopup(framesThatAreHit[0]->frame()->topLeft(), view, popupPoint); + return; + } + QValueVector::iterator iter = framesThatAreHit.begin(); + while(iter != framesThatAreHit.end()) { + if( (*iter)->selected() && keyState == Qt::ControlButton ) { + (*iter)->showPopup(point, view, popupPoint); + return; + } + ++iter; + } + framesThatAreHit[0]->showPopup(point, view, popupPoint); +} + +void KWFrameViewManager::selectFrames(const KoPoint &point, int keyState, bool leftClick) { + MouseMeaning mm = mouseMeaning(point, keyState); + bool multiSelect = mm == MEANING_MOUSE_SELECT || ( keyState & Qt::ControlButton ); + SelectionType se = frameOnTop; + if(leftClick && multiSelect) + se = nextUnselected; + KWFrameView *toBeSelected = view(point, se, !multiSelect); + //kdDebug() << "KWFrameViewManager::selectFrames" << point << " got: " << toBeSelected << endl; + if(toBeSelected == 0 || (keyState & Qt::ControlButton) == 0 || ( keyState & Qt::ShiftButton ) && + !(leftClick && (mm == MEANING_TOPLEFT || mm == MEANING_TOPRIGHT || mm == MEANING_TOP || + mm == MEANING_LEFT || mm == MEANING_RIGHT || mm == MEANING_MOUSE_MOVE || + mm == MEANING_BOTTOMLEFT || mm == MEANING_BOTTOM || mm == MEANING_BOTTOMRIGHT))) { + // unselect all + for(QValueListConstIterator frames = m_frames.begin(); + frames != m_frames.end(); ++frames) { + (*frames)->setSelected(false); + } + } + if(toBeSelected == 0) + return; + toBeSelected->setSelected(true, mm); + slotFrameSelectionChanged(); +} + +// ********** FrameEvent **** */ +KWFrameViewManager::FrameEvent::FrameEvent (ActionType action) { + m_action = action; +} +KWFrameViewManager::FrameEvent::FrameEvent (ActionType action, KWFrame *frame) { + m_action = action; + m_frame = frame; +} +KWFrameViewManager::FrameEvent::FrameEvent (ActionType action, KWFrameSet *frameSet) { + m_action = action; + m_frameSet = frameSet; +} + + +#include "KWFrameViewManager.moc" -- cgit v1.2.1