Q3DockArea Class Reference

#include <q3dockarea.h>

Inheritance diagram for Q3DockArea:

[legend]Collaboration diagram for Q3DockArea:

[legend]List of all members.

---

Detailed Description

The Q3DockArea class manages and lays out Q3DockWindows.

A Q3DockArea is a container which manages a list of {Q3DockWindow}s which it lays out within its area. In cooperation with the {Q3DockWindow}s it is responsible for the docking and undocking of {Q3DockWindow}s and moving them inside the dock area. Q3DockAreas also handle the wrapping of {Q3DockWindow}s to fill the available space as compactly as possible. Q3DockAreas can contain Q3ToolBars since Q3ToolBar is a Q3DockWindow subclass.

QMainWindow contains four Q3DockAreas which you can use for your Q3ToolBars and Q3DockWindows, so in most situations you do not need to use the Q3DockArea class directly. Although QMainWindow contains support for its own dock areas it isn't convenient for adding new Q3DockAreas. If you need to create your own dock areas we suggest that you create a subclass of QWidget and add your Q3DockAreas to your subclass.

qmainwindow-qdockareas.png QMainWindow's Q3DockAreas

lines Lines. Q3DockArea uses the concept of lines. A line is a horizontal region which may contain dock windows side-by-side. A dock area may have room for more than one line. When dock windows are docked into a dock area they are usually added at the right hand side of the top-most line that has room (unless manually placed by the user). When users move dock windows they may leave empty lines or gaps in non-empty lines. Qt::Dock windows can be lined up to minimize wasted space using the lineUp() function.

The Q3DockArea class maintains a position list of all its child dock windows. Qt::Dock windows are added to a dock area from position 0 onwards. Qt::Dock windows are laid out sequentially in position order from left to right, and in the case of multiple lines of dock windows, from top to bottom. If a dock window is floated it still retains its position since this is where the window will return if the user double clicks its caption. A dock window's position can be determined with hasDockWindow(). The position can be changed with moveDockWindow().

To dock or undock a dock window use Q3DockWindow::dock() and Q3DockWindow::undock() respectively. If you want to control which dock windows can dock in a dock area use setAcceptDockWindow(). To see if a dock area contains a particular dock window use {hasDockWindow()}; to see how many dock windows a dock area contains use count().

The streaming operators can write the positions of the dock windows in the dock area to a QTextStream. The positions can be read back later to restore the saved positions.

Save the positions to a QTextStream:

    ts << *myDockArea;

Restore the positions from a QTextStream:

    ts >> *myDockArea;

Definition at line 97 of file q3dockarea.h.

Public Types
enum	HandlePosition
Public Slots
void	lineUp (bool keepNewLines)
Public Member Functions
	Q3DockArea (Qt::Orientation o, HandlePosition h=Normal, QWidget *parent=0, const char *name=0)
	~Q3DockArea ()
void	moveDockWindow (Q3DockWindow *w, const QPoint &globalPos, const QRect &rect, bool swap)
void	removeDockWindow (Q3DockWindow *w, bool makeFloating, bool swap, bool fixNewLines=true)
void	moveDockWindow (Q3DockWindow *w, int index=-1)
bool	hasDockWindow (Q3DockWindow *w, int *index=0)
void	invalidNextOffset (Q3DockWindow *dw)
Qt::Orientation	orientation () const
HandlePosition	handlePosition () const
bool	eventFilter (QObject *, QEvent *)
bool	isEmpty () const
int	count () const
QList< Q3DockWindow * >	dockWindowList () const
bool	isDockWindowAccepted (Q3DockWindow *dw)
void	setAcceptDockWindow (Q3DockWindow *dw, bool accept)
Private Member Functions
int	findDockWindow (Q3DockWindow *w)
int	lineOf (int index)
DockWindowData *	dockWindowData (Q3DockWindow *w)
void	dockWindow (Q3DockWindow *dockWindow, DockWindowData *data)
void	updateLayout ()
void	invalidateFixedSizes ()
int	maxSpace (int hint, Q3DockWindow *dw)
void	setFixedExtent (int d, Q3DockWindow *dw)
bool	isLastDockWindow (Q3DockWindow *dw)
Private Attributes
Qt::Orientation	orient
QList< Q3DockWindow * >	dockWindows
Q3DockAreaLayout *	layout
HandlePosition	hPos
QList< Q3DockWindow * >	forbiddenWidgets
Q3DockAreaPrivate *	d
Friends
class	Q3DockWindow
class	Q3DockWindowResizeHandle
class	Q3DockAreaLayout
Related Functions
(Note that these are not member functions.)
QTextStream &	operator<< (QTextStream &ts, const Q3DockArea &dockArea)
QTextStream &	operator>> (QTextStream &ts, Q3DockArea &dockArea)
Classes
struct	DockWindowData

---

Member Enumeration Documentation

enum Q3DockArea::HandlePosition

A dock window has two kinds of handles, the dock window handle used for dragging the dock window, and the splitter handle used to resize the dock window in relation to other dock windows using a splitter. (The splitter handle is only visible for docked windows.)

This enum specifies where the dock window splitter handle is placed in the dock area.

Normal The splitter handles of dock windows are placed at the right or bottom.

Reverse The splitter handles of dock windows are placed at the left or top.

Definition at line 111 of file q3dockarea.h.

{ Normal, Reverse };

---

Constructor & Destructor Documentation

Q3DockArea::Q3DockArea	(	Qt::Orientation	o,
		HandlePosition	h = Normal,
		QWidget *	parent = 0,
		const char *	name = 0
	)

Constructs a Q3DockArea with orientation o, HandlePosition h, parent parent and called name.

Definition at line 548 of file q3dockarea.cpp.

References dockWindows, QObject::installEventFilter(), QWidget::layout(), and Q3DockAreaLayout.

    : QWidget(parent, name), orient(o), layout(0), hPos(h)
{
    layout = new Q3DockAreaLayout(this, o, &dockWindows, 0, 0, "toollayout");
    installEventFilter(this);
}

Here is the call graph for this function:

Q3DockArea::~Q3DockArea

(

)

Destroys the dock area and all the dock windows docked in the dock area.

Does not affect any floating dock windows or dock windows in other dock areas, even if they first appeared in this dock area. Floating dock windows are effectively top level windows and are not child windows of the dock area. When a floating dock window is docked (dragged into a dock area) its parent becomes the dock area.

Definition at line 567 of file q3dockarea.cpp.

References dockWindows, QList< T >::isEmpty(), and QList< T >::takeFirst().

{
    while (!dockWindows.isEmpty())
        delete dockWindows.takeFirst();
}

Here is the call graph for this function:

---

Member Function Documentation

void Q3DockArea::moveDockWindow	(	Q3DockWindow *	w,
		const QPoint &	p,
		const QRect &	r,
		bool	swap
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. Moves the dock window w inside the dock area where p is the new position (in global screen coordinates), r is the suggested rectangle of the dock window and swap specifies whether or not the orientation of the docked widget needs to be changed.

This function is used internally by Q3DockWindow. You shouldn't need to call it yourself.

Definition at line 660 of file q3dockarea.cpp.

References QList< T >::append(), QList< T >::at(), QList< T >::begin(), QRect::contains(), QList< T >::contains(), QList< T >::count(), dockWindow(), dockWindows, QList< T >::end(), QSizePolicy::Expanding, findDockWindow(), fix_pos(), QWidget::height(), QRect::height(), Qt::Horizontal, i, index, QList< T >::indexOf(), QList< T >::insert(), int, invalidateFixedSizes(), QList< T >::isEmpty(), QWidget::layout(), lineOf(), qdesigner_internal::lineRect(), QWidget::mapFromGlobal(), QSizePolicy::Minimum, QWidget::minimumHeight(), QWidget::minimumWidth(), Q3DockWindow::newLine(), orientation(), p, point_pos(), QWidget::pos(), qDebug(), qMax(), qMin(), QWidget::rect(), QPoint::rx(), Q3DockWindow::setFixedExtentWidth(), Q3DockWindow::setNewLine(), QWidget::setSizePolicy(), QRect::size(), QList< T >::size(), size_extent(), QList< T >::takeAt(), QRect::topLeft(), updateLayout(), Qt::Vertical, w, QRect::width(), QWidget::width(), QRect::x(), QPoint::x(), and QRect::y().

Referenced by Q3DockWindow::init(), and Q3DockWindow::updatePosition().

{
    invalidateFixedSizes();
    int mse = -10;
    bool hasResizable = false;
    for (int i = 0; i < dockWindows.size(); ++i) {
        Q3DockWindow *dw = dockWindows.at(i);
        if (dw->isHidden())
            continue;
        if (dw->isResizeEnabled())
            hasResizable = true;
        if (orientation() != Qt::Horizontal)
            mse = qMax(qMax(dw->fixedExtent().width(), dw->width()), mse);
        else
            mse = qMax(qMax(dw->fixedExtent().height(), dw->height()), mse);
    }
    if (!hasResizable && w->isResizeEnabled()) {
        if (orientation() != Qt::Horizontal)
            mse = qMax(w->fixedExtent().width(), mse);
        else
            mse = qMax(w->fixedExtent().height(), mse);
    }

    Q3DockWindow *dockWindow = 0;
    int dockWindowIndex = findDockWindow(w);
    QList<Q3DockWindow *> lineStarts = layout->lineStarts();
    QList<QRect> lines = layout->lineList();
    bool wasAloneInLine = false;
    QPoint pos = mapFromGlobal(p);
    int line = lineOf(dockWindowIndex);
    QRect lr;
    if (line < lines.size())
        lr = lines.at(line);
    if (dockWindowIndex != -1) {
        if (lineStarts.contains(w)
            && ((dockWindowIndex < dockWindows.count() - 1
                 && lineStarts.contains(dockWindows.at(dockWindowIndex + 1)))
                || dockWindowIndex == dockWindows.count() - 1))
            wasAloneInLine = true;
        dockWindow = dockWindows.takeAt(dockWindowIndex);
        if (!wasAloneInLine) { // only do the pre-layout if the widget isn't the only one in its line
            if (lineStarts.contains(dockWindow) && dockWindowIndex < dockWindows.count())
                dockWindows.at(dockWindowIndex)->setNewLine(true);
            layout->layoutItems(QRect(0, 0, width(), height()), true);
        }
    } else {
        dockWindow = w;
        bool vis = dockWindow->isVisible();
        dockWindow->setParent(this);
        dockWindow->move(0, 0);
        if(vis)
            dockWindow->show();
        if (swap)
            dockWindow->resize(dockWindow->height(), dockWindow->width());
        w->installEventFilter(this);
    }

    lineStarts = layout->lineStarts();
    lines = layout->lineList();

    QRect rect = QRect(mapFromGlobal(r.topLeft()), r.size());
    if (orientation() == Qt::Horizontal && QApplication::reverseLayout()) {
        rect = QRect(width() - rect.x() - rect.width(), rect.y(), rect.width(), rect.height());
        pos.rx() = width() - pos.x();
    }
    dockWindow->setOffset(point_pos(rect.topLeft(), orientation()));
    if (orientation() == Qt::Horizontal) {
        int offs = dockWindow->offset();
        if (width() - offs < dockWindow->minimumWidth())
            dockWindow->setOffset(width() - dockWindow->minimumWidth());
    } else {
        int offs = dockWindow->offset();
        if (height() - offs < dockWindow->minimumHeight())
            dockWindow->setOffset(height() - dockWindow->minimumHeight());
    }

    if (dockWindows.isEmpty()) {
        dockWindows.append(dockWindow);
    } else {
        int dockLine = -1;
        bool insertLine = false;
        int i = 0;
        QRect lineRect;
        // find the line which we touched with the mouse
        for (QList<QRect>::Iterator it = lines.begin(); it != lines.end(); ++it, ++i) {
            if (point_pos(pos, orientation(), true) >= point_pos((*it).topLeft(), orientation(), true) &&
                 point_pos(pos, orientation(), true) <= point_pos((*it).topLeft(), orientation(), true) +
                 size_extent((*it).size(), orientation(), true)) {
                dockLine = i;
                lineRect = *it;
                break;
            }
        }
        if (dockLine == -1) { // outside the dock...
            insertLine = true;
            if (point_pos(pos, orientation(), true) < 0) // insert as first line
                dockLine = 0;
            else
                dockLine = (int)lines.count(); // insert after the last line ### size_t/int cast
        } else { // inside the dock (we have found a dockLine)
            if (point_pos(pos, orientation(), true) <
                 point_pos(lineRect.topLeft(), orientation(), true) + 4) {        // mouse was at the very beginning of the line
                insertLine = true;                                        // insert a new line before that with the docking widget
            } else if (point_pos(pos, orientation(), true) >
                        point_pos(lineRect.topLeft(), orientation(), true) +
                        size_extent(lineRect.size(), orientation(), true) - 4) {        // mouse was at the very and of the line
                insertLine = true;                                                // insert a line after that with the docking widget
                dockLine++;
            }
        }

        if (!insertLine && wasAloneInLine && lr.contains(pos)) // if we are alone in a line and just moved in there, re-insert it
            insertLine = true;

#if defined(QDOCKAREA_DEBUG)
        qDebug("insert in line %d, and insert that line: %d", dockLine, insertLine);
        qDebug("     (btw, we have %d lines)", lines.count());
#endif
        Q3DockWindow *dw = 0;
        if (dockLine >= (int)lines.count()) { // insert after last line
            dockWindows.append(dockWindow);
            dockWindow->setNewLine(true);
#if defined(QDOCKAREA_DEBUG)
            qDebug("insert at the end");
#endif
        } else if (dockLine == 0 && insertLine) { // insert before first line
            dockWindows.insert(0, dockWindow);
            dockWindows.at(1)->setNewLine(true);
#if defined(QDOCKAREA_DEBUG)
            qDebug("insert at the begin");
#endif
        } else { // insert somewhere in between
            // make sure each line start has a new line
            for (int i = 0; i < lineStarts.size(); ++i) {
                dw = lineStarts.at(i);
                dw->setNewLine(true);
            }

            // find the index of the first widget in the search line
            int searchLine = dockLine;
#if defined(QDOCKAREA_DEBUG)
            qDebug("search line start of %d", searchLine);
#endif
            Q3DockWindow *lsw = lineStarts.at(searchLine);
            int index = dockWindows.indexOf(lsw);
            if (index == -1) { // the linestart widget hasn't been found, try to find it harder
                if (lsw == w && dockWindowIndex <= dockWindows.count())
                    index = dockWindowIndex;
                else
                    index = 0;
            }
#if defined(QDOCKAREA_DEBUG)
            qDebug("     which starts at %d", index);
#endif
            if (!insertLine) { // if we insert the docking widget in the existing line
                // find the index for the widget
                bool inc = true;
                bool firstTime = true;
                for (int i = index; i < dockWindows.size(); ++i) {
                    dw = dockWindows.at(i);
                    if (orientation() == Qt::Horizontal)
                        dw->setFixedExtentWidth(-1);
                    else
                        dw->setFixedExtentHeight(-1);
                    if (!firstTime && lineStarts.contains(dw)) // we are in the next line, so break
                        break;
                    if (point_pos(pos, orientation()) <
                         point_pos(fix_pos(dw), orientation()) + size_extent(dw->size(), orientation()) / 2) {
                        inc = false;
                    }
                    if (inc)
                        index++;
                    firstTime = false;
                }
#if defined(QDOCKAREA_DEBUG)
                qDebug("insert at index: %d", index);
#endif
                // if we insert it just before a widget which has a new line, transfer the newline to the docking widget
                // but not if we didn't only mave a widget in its line which was alone in the line before
                if (!(wasAloneInLine && lr.contains(pos))
                     && index >= 0 && index < dockWindows.count() &&
                     dockWindows.at(index)->newLine() && lineOf(index) == dockLine) {
#if defined(QDOCKAREA_DEBUG)
                    qDebug("get rid of the old newline and get me one");
#endif
                    dockWindows.at(index)->setNewLine(false);
                    dockWindow->setNewLine(true);
                } else if (wasAloneInLine && lr.contains(pos)) {
                    dockWindow->setNewLine(true);
                } else { // if we are somewhere in a line, get rid of the newline
                    dockWindow->setNewLine(false);
                }
            } else { // insert in a new line, so make sure the dock widget and the widget which will be after it have a newline
#if defined(QDOCKAREA_DEBUG)
                qDebug("insert a new line");
#endif
                if (index < dockWindows.count()) {
#if defined(QDOCKAREA_DEBUG)
                    qDebug("give the widget at %d a newline", index);
#endif
                    Q3DockWindow* nldw = dockWindows.at(index);
                    if (nldw)
                        nldw->setNewLine(true);
                }
#if defined(QDOCKAREA_DEBUG)
                qDebug("give me a newline");
#endif
                dockWindow->setNewLine(true);
            }
            // finally insert the widget
            dockWindows.insert(index, dockWindow);
        }
    }

    if (mse != -10 && w->isResizeEnabled()) {
        if (orientation() != Qt::Horizontal)
            w->setFixedExtentWidth(qMin(qMax(w->minimumWidth(), mse), w->sizeHint().width()));
        else
            w->setFixedExtentHeight(qMin(qMax(w->minimumHeight(), mse), w->sizeHint().height()));
    }

    updateLayout();
    setSizePolicy(QSizePolicy(orientation() == Qt::Horizontal ? QSizePolicy::Expanding : QSizePolicy::Minimum,
                                orientation() == Qt::Vertical ? QSizePolicy::Expanding : QSizePolicy::Minimum));
}

Here is the call graph for this function:

void Q3DockArea::removeDockWindow	(	Q3DockWindow *	w,
		bool	makeFloating,
		bool	swap,
		bool	fixNewLines = true
	)

Removes the dock window w from the dock area. If makeFloating is true, w gets floated, and if swap is true, the orientation of w gets swapped. If fixNewLines is true (the default) newlines in the area will be fixed.

You should never need to call this function yourself. Use Q3DockWindow::dock() and Q3DockWindow::undock() instead.

Definition at line 896 of file q3dockarea.cpp.

References QList< T >::at(), QList< T >::contains(), QList< T >::count(), dockWindow(), dockWindows, findDockWindow(), i, QList< T >::isEmpty(), QWidget::layout(), p, QWidget::parentWidget(), QSizePolicy::Preferred, QList< T >::removeAt(), Q3DockWindow::setNewLine(), QWidget::setSizePolicy(), updateLayout(), w, and QWidget::window().

Referenced by eventFilter(), Q3DockWindow::removeFromDock(), Q3DockWindow::undock(), Q3DockWindow::updatePosition(), and Q3DockWindow::~Q3DockWindow().

{
    w->removeEventFilter(this);
    Q3DockWindow *dockWindow = 0;
    int i = findDockWindow(w);
    if (i == -1)
        return;
    dockWindow = dockWindows.at(i);
    dockWindows.removeAt(i);
    QList<Q3DockWindow *> lineStarts = layout->lineStarts();
    if (fixNewLines && lineStarts.contains(dockWindow) && i < dockWindows.count())
        dockWindows.at(i)->setNewLine(true);
    if (makeFloating) {
        QWidget *p = parentWidget() ? parentWidget() : window();
        dockWindow->setParent(p, Qt::WType_Dialog | Qt::WStyle_Customize | Qt::WStyle_NoBorder | Qt::WStyle_Tool);
        dockWindow->move(0, 0);
    }
    if (swap)
        dockWindow->resize(dockWindow->height(), dockWindow->width());
    updateLayout();
    if (dockWindows.isEmpty())
        setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred));
}

Here is the call graph for this function:

void Q3DockArea::moveDockWindow	(	Q3DockWindow *	w,
		int	index = -1
	)

Moves the Q3DockWindow w within the dock area. If w is not already docked in this area, w is docked first. If index is -1 or larger than the number of docked widgets, w is appended at the end, otherwise it is inserted at the position index.

Definition at line 580 of file q3dockarea.cpp.

References QList< T >::append(), QList< T >::count(), dockWindow(), dockWindows, QSizePolicy::Expanding, findDockWindow(), Qt::Horizontal, Q3DockWindow::InDock, QList< T >::insert(), invalidateFixedSizes(), QSizePolicy::Minimum, orientation(), QList< T >::removeAll(), QWidget::setSizePolicy(), updateLayout(), Qt::Vertical, and w.

{
    invalidateFixedSizes();
    Q3DockWindow *dockWindow = 0;
    int dockWindowIndex = findDockWindow(w);
    if (dockWindowIndex == -1) {
        dockWindow = w;
        bool vis = dockWindow->isVisible();
        dockWindow->setParent(this);
        dockWindow->move(0, 0);
        if(vis)
            dockWindow->show();
        w->installEventFilter(this);
        updateLayout();
        setSizePolicy(QSizePolicy(orientation() == Qt::Horizontal ? QSizePolicy::Expanding : QSizePolicy::Minimum,
                                    orientation() == Qt::Vertical ? QSizePolicy::Expanding : QSizePolicy::Minimum));
        dockWindows.append(w);
    } else {
        if (w->parent() != this) {
            bool vis = w->isVisible();
            w->setParent(this);
            w->move(0, 0);
            if(vis)
                w->show();
        }
        if (index == -1) {
            dockWindows.removeAll(w);
            dockWindows.append(w);
        }
    }

    w->dockArea = this;
    w->curPlace = Q3DockWindow::InDock;
    w->updateGui();

    if (index != -1 && index < (int)dockWindows.count()) {
        dockWindows.removeAll(w);
        dockWindows.insert(index, w);
    }
}

Here is the call graph for this function:

bool Q3DockArea::hasDockWindow	(	Q3DockWindow *	w,
		int *	index = 0
	)

Returns true if the dock area contains the dock window w; otherwise returns false. If index is not 0 it will be set as follows: if the dock area contains the dock window *{index} is set to w's index position; otherwise *{index} is set to -1.

Definition at line 628 of file q3dockarea.cpp.

References dockWindows, i, QList< T >::indexOf(), and w.

{
    int i = dockWindows.indexOf(w);
    if (index)
        *index = i;
    return i != -1;
}

Here is the call graph for this function:

void Q3DockArea::invalidNextOffset

(

Q3DockWindow *

dw

)

Definition at line 953 of file q3dockarea.cpp.

References QList< T >::at(), QList< T >::count(), dockWindows, i, QList< T >::indexOf(), and Q3DockWindow::setOffset().

Referenced by Q3DockWindowResizeHandle::mouseReleaseEvent().

{
    int i = dockWindows.indexOf(dw);
    if (i == -1 || i >= (int)dockWindows.count() - 1)
        return;
    if ((dw = dockWindows.at(++i)))
        dw->setOffset(0);
}

Here is the call graph for this function:

Qt::Orientation Q3DockArea::orientation

(

)

const [inline]

Definition at line 123 of file q3dockarea.h.

References orient.

Referenced by dockWindow(), dockWindowData(), Q3DockWindow::handleMove(), invalidateFixedSizes(), isLastDockWindow(), maxSpace(), Q3DockWindowResizeHandle::mouseMoveEvent(), Q3DockWindowResizeHandle::mouseReleaseEvent(), moveDockWindow(), Q3DockWindow::orientation(), Q3DockWindowHandle::paintEvent(), setFixedExtent(), Q3DockWindowResizeHandle::sizeHint(), and Q3DockWindowHandle::updateGui().

{ return orient; }

HandlePosition Q3DockArea::handlePosition

(

)

const [inline]

Definition at line 124 of file q3dockarea.h.

References hPos.

Referenced by Q3DockWindowResizeHandle::mouseReleaseEvent().

{ return hPos; }

bool Q3DockArea::eventFilter	(	QObject *	o,
		QEvent *	e
	)			[virtual]

Reimplemented from QObject.

Definition at line 934 of file q3dockarea.cpp.

References QEvent::Close, o, removeDockWindow(), QCoreApplication::sendEvent(), and QEvent::type().

{
    if (e->type() == QEvent::Close) {
        if (qobject_cast<Q3DockWindow*>(o)) {
            o->removeEventFilter(this);
            QApplication::sendEvent(o, e);
            if (((QCloseEvent*)e)->isAccepted())
                removeDockWindow((Q3DockWindow*)o, false, false);
            return true;
        }
    }
    return false;
}

Here is the call graph for this function:

bool Q3DockArea::isEmpty

(

)

const

Definition at line 976 of file q3dockarea.cpp.

References dockWindows, and QList< T >::isEmpty().

Referenced by Q3MainWindowLayout::extraPixels().

{
    return dockWindows.isEmpty();
}

Here is the call graph for this function:

int Q3DockArea::count

(

)

const

Definition at line 966 of file q3dockarea.cpp.

References QList< T >::count(), and dockWindows.

{
    return dockWindows.count();
}

Here is the call graph for this function:

QList< Q3DockWindow * > Q3DockArea::dockWindowList

(

)

const

Returns a list of the dock windows in the dock area.

Definition at line 986 of file q3dockarea.cpp.

References dockWindows.

Referenced by operator<<(), and operator>>().

{
    return dockWindows;
}

bool Q3DockArea::isDockWindowAccepted

(

Q3DockWindow *

dw

)

Returns true if dock window dw could be docked into the dock area; otherwise returns false.

See also:

setAcceptDockWindow()

Definition at line 1094 of file q3dockarea.cpp.

References QList< T >::contains(), forbiddenWidgets, Q3MainWindow::hasDockWindow(), Q3MainWindow::isDockEnabled(), and QWidget::parentWidget().

{
    if (!dw)
        return false;
    if (forbiddenWidgets.contains(dw))
        return false;

    Q3MainWindow *mw = qobject_cast<Q3MainWindow*>(parentWidget());
    if (!mw)
        return true;
    if (!mw->hasDockWindow(dw))
        return false;
    if (!mw->isDockEnabled(this))
        return false;
    if (!mw->isDockEnabled(dw, this))
        return false;
    return true;
}

Here is the call graph for this function:

void Q3DockArea::setAcceptDockWindow	(	Q3DockWindow *	dw,
		bool	accept
	)

If accept is true, dock window dw can be docked in the dock area. If accept is false, dock window dw cannot be docked in the dock area.

See also:

isDockWindowAccepted()

Definition at line 1121 of file q3dockarea.cpp.

References QList< T >::append(), QList< T >::contains(), forbiddenWidgets, and QList< T >::removeAll().

Referenced by Q3MainWindow::setDockEnabled().

{
    if (accept)
        forbiddenWidgets.removeAll(dw);
    else if (forbiddenWidgets.contains(dw))
        forbiddenWidgets.append(dw);
}

Here is the call graph for this function:

void Q3DockArea::lineUp

(

bool

keepNewLines

)

[slot]

Lines up the dock windows in this dock area to minimize wasted space. If keepNewLines is true, only space within lines is cleaned up. If keepNewLines is false the number of lines might be changed.

Definition at line 998 of file q3dockarea.cpp.

References QLayout::activate(), QList< T >::at(), dockWindows, i, QWidget::layout(), Q3DockWindow::setOffset(), and QList< T >::size().

{
    for (int i = 0; i < dockWindows.size(); ++i) {
        Q3DockWindow *dw = dockWindows.at(i);
        dw->setOffset(0);
        if (!keepNewLines)
            dw->setNewLine(false);
    }
    layout->activate();
}

int Q3DockArea::findDockWindow

(

Q3DockWindow *

w

)

[private]

Definition at line 920 of file q3dockarea.cpp.

References dockWindows, QList< T >::indexOf(), and w.

Referenced by dockWindowData(), maxSpace(), moveDockWindow(), and removeDockWindow().

{
    return dockWindows.indexOf(w);
}

Here is the call graph for this function:

int Q3DockArea::lineOf

(

int

index

)

[private]

Definition at line 636 of file q3dockarea.cpp.

References QList< T >::at(), dockWindows, i, QList< T >::indexOf(), QWidget::layout(), QList< T >::size(), and w.

Referenced by dockWindow(), and moveDockWindow().

{
    QList<Q3DockWindow *> lineStarts = layout->lineStarts();
    int i = 0;
    for (; i < lineStarts.size(); ++i) {
        Q3DockWindow *w = lineStarts.at(i);
        if (dockWindows.indexOf(w) >= index)
            return i;
    }
    return i;
}

Here is the call graph for this function:

Q3DockArea::DockWindowData * Q3DockArea::dockWindowData

(

Q3DockWindow *

w

)

[private]

Definition at line 1009 of file q3dockarea.cpp.

References QList< T >::at(), QList< T >::contains(), data, dockWindows, findDockWindow(), fix_x(), i, j, QWidget::layout(), orientation(), point_pos(), QList< T >::size(), and w.

Referenced by Q3DockWindow::undock(), and Q3DockWindow::updatePosition().

{
    DockWindowData *data = new DockWindowData;
    data->index = findDockWindow(w);
    if (data->index == -1) {
        delete data;
        return 0;
    }
    QList<Q3DockWindow *> lineStarts = layout->lineStarts();
    int i = -1;
    for (int j = 0; j < dockWindows.size(); ++j) {
        Q3DockWindow *dw = dockWindows.at(j);
        if (lineStarts.contains(dw))
            ++i;
        if (dw == w)
            break;
    }
    data->line = i;
    data->offset = point_pos(QPoint(fix_x(w), w->y()), orientation());
    data->area = this;
    data->fixedExtent = w->fixedExtent();
    return data;
}

Here is the call graph for this function:

void Q3DockArea::dockWindow	(	Q3DockWindow *	dockWindow,
		DockWindowData *	data
	)			[private]

Definition at line 1033 of file q3dockarea.cpp.

References QList< T >::append(), QList< T >::at(), QList< T >::contains(), QList< T >::count(), data, dockWindows, QSizePolicy::Expanding, fix_pos(), Qt::Horizontal, i, index, QList< T >::indexOf(), QList< T >::insert(), QList< T >::isEmpty(), QWidget::layout(), lineOf(), QSizePolicy::Minimum, Q3DockWindow::newLine(), orientation(), point_pos(), Q3DockWindow::setNewLine(), QWidget::setSizePolicy(), QList< T >::size(), size_extent(), updateLayout(), and Qt::Vertical.

Referenced by Q3DockWindow::dock(), moveDockWindow(), and removeDockWindow().

{
    if (!data)
        return;

    dockWindow->setParent(this);
    dockWindow->move(0, 0);

    dockWindow->installEventFilter(this);
    dockWindow->dockArea = this;
    dockWindow->updateGui();

    if (dockWindows.isEmpty()) {
        dockWindows.append(dockWindow);
    } else {
        QList<Q3DockWindow *> lineStarts = layout->lineStarts();
        int index = 0;
        if (lineStarts.count() > data->line)
            index = dockWindows.indexOf(lineStarts.at(data->line));
        if (index == -1)
            index = 0;
        bool firstTime = true;
        int offset = data->offset;
        for (int i = index; i < dockWindows.size(); ++i) {
            Q3DockWindow *dw = dockWindows.at(i);
            if (!firstTime && lineStarts.contains(dw))
                break;
            if (offset <
                 point_pos(fix_pos(dw), orientation()) + size_extent(dw->size(), orientation()) / 2)
                break;
            index++;
            firstTime = false;
        }
        if (index >= 0 && index < dockWindows.count() &&
             dockWindows.at(index)->newLine() && lineOf(index) == data->line) {
            dockWindows.at(index)->setNewLine(false);
            dockWindow->setNewLine(true);
        } else {
            dockWindow->setNewLine(false);
        }

        dockWindows.insert(index, dockWindow);
    }
    dockWindow->show();

    dockWindow->setFixedExtentWidth(data->fixedExtent.width());
    dockWindow->setFixedExtentHeight(data->fixedExtent.height());

    updateLayout();
    setSizePolicy(QSizePolicy(orientation() == Qt::Horizontal ? QSizePolicy::Expanding : QSizePolicy::Minimum,
                                orientation() == Qt::Vertical ? QSizePolicy::Expanding : QSizePolicy::Minimum));

}

Here is the call graph for this function:

void Q3DockArea::updateLayout

(

)

[private]

Definition at line 925 of file q3dockarea.cpp.

References QLayout::activate(), QLayout::invalidate(), and QWidget::layout().

Referenced by dockWindow(), moveDockWindow(), and removeDockWindow().

{
    layout->invalidate();
    layout->activate();
}

Here is the call graph for this function:

void Q3DockArea::invalidateFixedSizes

(

)

[private]

Definition at line 1129 of file q3dockarea.cpp.

References QList< T >::at(), dockWindows, Qt::Horizontal, i, orientation(), Q3DockWindow::setFixedExtentWidth(), and QList< T >::size().

Referenced by moveDockWindow().

{
    for (int i = 0; i < dockWindows.size(); ++i) {
        Q3DockWindow *dw = dockWindows.at(i);
        if (orientation() == Qt::Horizontal)
            dw->setFixedExtentWidth(-1);
        else
            dw->setFixedExtentHeight(-1);
    }
}

Here is the call graph for this function:

int Q3DockArea::maxSpace	(	int	hint,
		Q3DockWindow *	dw
	)			[private]

Definition at line 1140 of file q3dockarea.cpp.

References QList< T >::at(), QList< T >::count(), diff(), dockWindows, findDockWindow(), QWidget::height(), Qt::Horizontal, i, index, int, orientation(), qMax(), tb, w, and QWidget::width().

Referenced by Q3DockWindowResizeHandle::mouseReleaseEvent().

{
    int index = findDockWindow(dw);
    if (index == -1 || index + 1 >= (int)dockWindows.count()) {
        if (orientation() == Qt::Horizontal)
            return dw->width();
        return dw->height();
    }

    Q3DockWindow *w = 0;
    int i = 0;
    do {
        w = dockWindows.at(index + (++i));
    } while (i + 1 < (int)dockWindows.count() && (!w || w->isHidden()));
    if (!w || !w->isResizeEnabled() || i >= (int)dockWindows.count()) {
        if (orientation() == Qt::Horizontal)
            return dw->width();
        return dw->height();
    }
    int min = 0;
    Q3ToolBar *tb = qobject_cast<Q3ToolBar*>(w);
    if (orientation() == Qt::Horizontal) {
        w->setFixedExtentWidth(-1);
        if (!tb)
            min = qMax(w->minimumSize().width(), w->minimumSizeHint().width());
        else
            min = w->sizeHint().width();
    } else {
        w->setFixedExtentHeight(-1);
        if (!tb)
            min = qMax(w->minimumSize().height(), w->minimumSizeHint().height());
        else
            min = w->sizeHint().height();
    }

    int diff = hint - (orientation() == Qt::Horizontal ? dw->width() : dw->height());

    if ((orientation() == Qt::Horizontal ? w->width() : w->height()) - diff < min)
        hint = (orientation() == Qt::Horizontal ? dw->width() : dw->height()) + (orientation() == Qt::Horizontal ? w->width() : w->height()) - min;

    diff = hint - (orientation() == Qt::Horizontal ? dw->width() : dw->height());
    if (orientation() == Qt::Horizontal)
        w->setFixedExtentWidth(w->width() - diff);
    else
        w->setFixedExtentHeight(w->height() - diff);
    return hint;
}

Here is the call graph for this function:

void Q3DockArea::setFixedExtent	(	int	d,
		Q3DockWindow *	dw
	)			[private]

Definition at line 1188 of file q3dockarea.cpp.

References QList< T >::append(), QList< T >::at(), dockWindows, Qt::Horizontal, i, orientation(), qMax(), QList< T >::size(), w, QWidget::x(), and QWidget::y().

Referenced by Q3DockWindowResizeHandle::mouseReleaseEvent().

{
    QList<Q3DockWindow *> lst;
    for (int i = 0; i < dockWindows.size(); ++i) {
        Q3DockWindow *w = dockWindows.at(i);
        if (w->isHidden())
            continue;
        if (orientation() == Qt::Horizontal) {
            if (dw->y() != w->y())
                continue;
        } else {
            if (dw->x() != w->x())
                continue;
        }
        if (orientation() == Qt::Horizontal)
            d = qMax(d, w->minimumHeight());
        else
            d = qMax(d, w->minimumWidth());
        if (w->isResizeEnabled())
            lst.append(w);
    }
    for (int i = 0; i < lst.size(); ++i) {
        Q3DockWindow *w = lst.at(i);
        if (orientation() == Qt::Horizontal)
            w->setFixedExtentHeight(d);
        else
            w->setFixedExtentWidth(d);
    }
}

Here is the call graph for this function:

bool Q3DockArea::isLastDockWindow

(

Q3DockWindow *

dw

)

[private]

Definition at line 1218 of file q3dockarea.cpp.

References QList< T >::at(), QList< T >::count(), dockWindows, Qt::Horizontal, i, QList< T >::indexOf(), orientation(), Qt::Vertical, w, QWidget::x(), and QWidget::y().

{
    int i = dockWindows.indexOf(dw);
    if (i == -1 || i >= (int)dockWindows.count() - 1)
        return true;
    Q3DockWindow *w = 0;
    if ((w = dockWindows.at(++i))) {
        if (orientation() == Qt::Horizontal && dw->y() < w->y())
            return true;
        if (orientation() == Qt::Vertical && dw->x() < w->x())
            return true;
    } else {
        return true;
    }
    return false;
}

Here is the call graph for this function:

---

Friends And Related Function Documentation

friend class Q3DockWindow [friend]

Definition at line 106 of file q3dockarea.h.

friend class Q3DockWindowResizeHandle [friend]

Definition at line 107 of file q3dockarea.h.

friend class Q3DockAreaLayout [friend]

Definition at line 108 of file q3dockarea.h.

Referenced by Q3DockArea().

QTextStream & operator<<	(	QTextStream &	ts,
		const Q3DockArea &	dockArea
	)			[related]

Writes the layout of the dock windows in dock area dockArea to the text stream ts.

Definition at line 1244 of file q3dockarea.cpp.

References dockWindowList(), QTextStream::endl(), i, l, and QString::number().

{
    QString str;
    QList<Q3DockWindow *> l = dockArea.dockWindowList();

    for (int i = 0; i < l.size(); ++i) {
        Q3DockWindow *dw = l.at(i);
        str += "[" + QString(dw->windowTitle()) + "," + QString::number((int)dw->offset()) +
               "," + QString::number((int)dw->newLine()) + "," + QString::number(dw->fixedExtent().width()) +
               "," + QString::number(dw->fixedExtent().height()) + "," + QString::number((int)!dw->isHidden()) + "]";
    }
    ts << str << endl;

    return ts;
}

Here is the call graph for this function:

QTextStream & operator>>	(	QTextStream &	ts,
		Q3DockArea &	dockArea
	)			[related]

Reads the layout description of the dock windows in dock area dockArea from the text stream ts and restores it. The layout description must have been previously written by the operator<<() function.

Definition at line 1269 of file q3dockarea.cpp.

References c, dockWindowList(), QCss::Height, height, i, j, l, name, Post, Pre, QTextStream::readLine(), s, QString::toInt(), Width, and width.

{
    QString s = ts.readLine();

    QString name, offset, newLine, width, height, visible;

    enum State { Pre, Name, Offset, NewLine, Width, Height, Visible, Post };
    int state = Pre;
    QChar c;
    QList<Q3DockWindow *> l = dockArea.dockWindowList();

    for (int i = 0; i < s.length(); ++i) {
        c = s[i];
        if (state == Pre && c == '[') {
            state++;
            continue;
        }
        if (c == ',' &&
             (state == Name || state == Offset || state == NewLine || state == Width || state == Height)) {
            state++;
            continue;
        }
        if (state == Visible && c == ']') {
            for (int j = 0; j < l.size(); ++j) {
                Q3DockWindow *dw = l.at(j);
                if (QString(dw->windowTitle()) == name) {
                    dw->setNewLine((bool)newLine.toInt());
                    dw->setOffset(offset.toInt());
                    dw->setFixedExtentWidth(width.toInt());
                    dw->setFixedExtentHeight(height.toInt());
                    if (!(bool)visible.toInt())
                        dw->hide();
                    else
                        dw->show();
                    break;
                }
            }

            name = offset = newLine = width = height = visible = "";

            state = Pre;
            continue;
        }
        if (state == Name)
            name += c;
        else if (state == Offset)
            offset += c;
        else if (state == NewLine)
            newLine += c;
        else if (state == Width)
            width += c;
        else if (state == Height)
            height += c;
        else if (state == Visible)
            visible += c;
    }

    dockArea.QWidget::layout()->invalidate();
    dockArea.QWidget::layout()->activate();
    return ts;
}

Here is the call graph for this function:

---

Member Data Documentation

Qt::Orientation Q3DockArea::orient [private]

Definition at line 160 of file q3dockarea.h.

Referenced by Q3DockAreaLayout::orientation(), and orientation().

QList<Q3DockWindow *> Q3DockArea::dockWindows [private]

Definition at line 161 of file q3dockarea.h.

Referenced by count(), dockWindow(), dockWindowData(), dockWindowList(), findDockWindow(), hasDockWindow(), invalidateFixedSizes(), invalidNextOffset(), isEmpty(), isLastDockWindow(), lineOf(), lineUp(), maxSpace(), moveDockWindow(), Q3DockArea(), removeDockWindow(), setFixedExtent(), and ~Q3DockArea().

Q3DockAreaLayout* Q3DockArea::layout [private]

Definition at line 162 of file q3dockarea.h.

HandlePosition Q3DockArea::hPos [private]

Definition at line 163 of file q3dockarea.h.

Referenced by handlePosition().

QList<Q3DockWindow *> Q3DockArea::forbiddenWidgets [private]

Definition at line 164 of file q3dockarea.h.

Referenced by isDockWindowAccepted(), and setAcceptDockWindow().

Q3DockAreaPrivate* Q3DockArea::d [private]

Definition at line 165 of file q3dockarea.h.

---

The documentation for this class was generated from the following files:

• src/qt3support/widgets/q3dockarea.h
• src/qt3support/widgets/q3dockarea.cpp

---