autoResizeTreeView.cpp

/***************************************************************************
 *   Copyright (C) 2006 by Graeme Foster                                   *
 *   email    foster.graeme@gmail.com                                      *
 *                                                                         *
 *   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.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include "autoResizeTreeView.h"

gf_AutoResizeTreeView::gf_AutoResizeTreeView (QWidget * parent)
:QTreeView(parent)
{
        setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
        gf_gd = gf_GD_WIDTH;
        gf_gp = gf_GP_FRIENDLY;
        gf_twin = 0;
        gf_friendlyMin = 30;
        setMinimumSize(gf_friendlyMin,gf_friendlyMin);
        gf_shrinkToWidth = -1;
        gf_shrinkToHeight = -1;
        gf_hold = true;
        setStatus(gf_S_NORMAL);
}

void gf_AutoResizeTreeView::storeSize()
{
        // Capture the current width and height
        if (gf_shrinkToWidth == -1)
                gf_shrinkToWidth = width();
        if (gf_shrinkToHeight == -1)
                gf_shrinkToHeight = height();
}

void gf_AutoResizeTreeView::restoreSize()
{
        // Restore back to the stored values
        if (gf_shrinkToWidth != -1 && gf_shrinkToHeight != -1)
        {
                setMaximumSize(1000,1000);
                resize(gf_shrinkToWidth,gf_shrinkToHeight);
        }
}

void gf_AutoResizeTreeView::resizeEvent(QResizeEvent * event)
{
        QTreeView::resizeEvent(event);
        switch (status)
        {
                case gf_S_GROWING:
                        status = gf_S_GROWN;
                        break;
                case gf_S_SHRINKING:
                        status = gf_S_SHRUNK;
                        break;
                case gf_S_SHRUNK:
                        if (gf_gd & gf_GD_WIDTH)
                                gf_twin->growWidth(event->size().width() - event->oldSize().width());
                        if (gf_gd & gf_GD_HEIGHT)
                                gf_twin->growHeight(event->size().height() - event->oldSize().height());
                        break;
                case gf_S_NORMAL:
                case gf_S_GROWN:
                        if (gf_shrinkToWidth != -1 && gf_shrinkToHeight != -1)
                        {
                                gf_shrinkToWidth  += (event->size().width() - event->oldSize().width());
                                gf_shrinkToHeight += (event->size().height() - event->oldSize().height());
                        }
        } // end of the switch on the status.
//      QTreeView::resizeEvent(event);
}

void gf_AutoResizeTreeView::focusInEvent ( QFocusEvent * event )
{
        QTreeView::focusInEvent(event);
        if (gf_twin != 0)
        {
                // Occasionally the focusOutEvent doesn't get triggered so
                // If necessary shrink back to the original size
                setStatus(gf_S_GROWING);
                gf_twin->setStatus(gf_S_SHRINKING);
                shrink();
                
                storeSize();
                gf_twin->storeSize();
                // Now select the appropriate grow method
                setStatus(gf_S_GROWING);
                gf_twin->setStatus(gf_S_SHRINKING);
                gf_twin->clearSelection();
                selectGrow();
        }
//      QTreeView::focusInEvent(event);
}

void gf_AutoResizeTreeView::focusOutEvent ( QFocusEvent * event )
{
        QTreeView::focusOutEvent(event);
        if (gf_hold==false && gf_twin != 0)
        {
                setStatus(gf_S_NORMAL);
                gf_twin->setStatus(gf_S_NORMAL);
                shrink();
        }
//      QTreeView::focusOutEvent(event);
}

void gf_AutoResizeTreeView::selectGrow()
{
        if (gf_twin != 0)
        {
                switch (gf_gp)
                {
                        case gf_GP_GREEDY:
                                grow(1,1);
                                break;
                        case gf_GP_FRIENDLY:
                                grow(gf_friendlyMin,gf_friendlyMin);
                                break;
                        case gf_GP_STAGGERED:
                                staggeredGrow();
                                break;
                        case gf_GP_NONE:
                                // Do nothing
                                break;
                } //  end of select on the grow policy
        } // end of if a twin exists.
} // end of method selectGrow

void gf_AutoResizeTreeView::grow(int smallWidth, int smallHeight)
{
        if (gf_gd & gf_GD_WIDTH)
        {
                int gf_twinwidth = gf_twin->width();
                gf_twin->setMaximumWidth(smallWidth);
                resize(width() +gf_twinwidth - smallWidth,height());
        }
        
        if (gf_gd & gf_GD_HEIGHT)
        {
                int gf_twinheight = gf_twin->height();
                gf_twin->setMaximumHeight(smallHeight);
                resize(width(),height() +gf_twinheight - smallHeight);
        }
}

void gf_AutoResizeTreeView::staggeredGrow()
{
}

void gf_AutoResizeTreeView::shrink()
{
        int totalWidth  = gf_twin->gf_shrinkToWidth + gf_shrinkToWidth;
        int totalHeight = gf_twin->gf_shrinkToHeight + gf_shrinkToHeight;
        // Calculate the new sizes
        gf_twin->gf_shrinkToWidth = totalWidth / 2;
        gf_shrinkToWidth  = totalWidth - gf_twin->gf_shrinkToWidth;
        gf_twin->gf_shrinkToHeight = totalHeight / 2;
        gf_shrinkToHeight = totalHeight - gf_twin->gf_shrinkToHeight;
        // Restore the sizes.
        restoreSize();
        gf_twin->restoreSize();
}

---