Subversion Repositories Scribus

Rev

Rev 17088 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

/*
For general Scribus (>=1.3.2) copyright and licensing information please refer
to the COPYING file provided with the program. Following this notice may exist
a copyright and/or license notice that predates the release of Scribus 1.3.2
for which a new license (GPL+exception) is in place.
*/



#include "propertywidget_groupshape.h"

#if defined(_MSC_VER)
#define _USE_MATH_DEFINES
#endif
#include <cmath>
#include "autoform.h"
#include "commonstrings.h"
#include "sccolorengine.h"
#include "pageitem_textframe.h"
#include "pageitem_regularpolygon.h"
#include "polyprops.h"
#include "sccombobox.h"
#include "scribus.h"
#include "scribuscore.h"
#include "scraction.h"
#include "scribusview.h"
#include "selection.h"
#include "units.h"
#include "undomanager.h"
#include "util.h"
#include "util_icon.h"
#include "util_math.h"
#include "text/nlsconfig.h"

#include "ui/nodeeditpalette.h"
#include "ui/propertiespalette_utils.h"
#include "ui/propertiespalette_xyz.h"

PropertyWidget_GroupShape::PropertyWidget_GroupShape( QWidget* parent) : PropertyWidget_Shape(parent)
{
        setEnabled(false);
}

void PropertyWidget_GroupShape::connectSignals()
{
        connect(textFlowBtnGroup, SIGNAL(buttonClicked(int))   , this, SLOT(handleTextFlow())    , Qt::UniqueConnection);
        connect(editShape  , SIGNAL(clicked())                 , this, SLOT(handleShapeEdit())   , Qt::UniqueConnection);
        connect(roundRect  , SIGNAL(valueChanged(double))      , this, SLOT(handleCornerRadius()), Qt::UniqueConnection);
        connect(evenOdd    , SIGNAL(clicked())                 , this, SLOT(handleFillRule())    , Qt::UniqueConnection );
        connect(nonZero    , SIGNAL(clicked())                 , this, SLOT(handleFillRule())    , Qt::UniqueConnection );
        connect(customShape, SIGNAL(FormSel(int, int, qreal *)), this, SLOT(handleNewShape(int, int, qreal *)), Qt::UniqueConnection);
}

void PropertyWidget_GroupShape::disconnectSignals()
{
        disconnect(textFlowBtnGroup, SIGNAL(buttonClicked(int))   , this, SLOT(handleTextFlow()));
        disconnect(editShape  , SIGNAL(clicked())                 , this, SLOT(handleShapeEdit()));
        disconnect(roundRect  , SIGNAL(valueChanged(double))      , this, SLOT(handleCornerRadius()));
        disconnect(evenOdd    , SIGNAL(clicked())                 , this, SLOT(handleFillRule()));
        disconnect(nonZero    , SIGNAL(clicked())                 , this, SLOT(handleFillRule()));
        disconnect(customShape, SIGNAL(FormSel(int, int, qreal *)), this, SLOT(handleNewShape(int, int, qreal *)));
}

void PropertyWidget_GroupShape::enableCustomShape()
{
        bool enabled = false;
        if (m_item)
        {
                enabled  = true;
                enabled &= !m_item->isArc();
                enabled &= !m_item->isLine();
                enabled &= !m_item->isPathText();
                enabled &= !m_item->isPolyLine();
                enabled &= !m_item->isSpiral();
                enabled &= !m_item->isRegularPolygon();
                enabled &= !m_item->locked();
        }
        customShape->setEnabled(enabled);
}

void PropertyWidget_GroupShape::enableFromSelection(void)
{
        bool enabled = false;

        if (!m_item || !m_doc)
        {
                editShape->setEnabled(false);
                customShape->setEnabled(false);
                roundRect->setEnabled(false);
                roundRect->showValue(0);

                setEnabled(false);
                return;
        }

        if (m_doc->m_Selection->count() > 1)
        {
                bool widgetEnabled = false;
                if (m_item)
                {
                        if ((m_item->isGroup()) && (!m_item->isSingleSel))
                                widgetEnabled = true;
                }
                setEnabled(widgetEnabled);
        }
        else
        {
                int itemType = m_item->itemType();

                switch (itemType)
                {
                case PageItem::Symbol:
                        setEnabled(true);
                        break;
                default:
                        setEnabled(false);
                        roundRect->setEnabled(false);
                        roundRect->showValue(0);
                }
        }

        if ((m_item->isGroup()) && (!m_item->isSingleSel))
        {
                customShape->setEnabled(true);
                editShape->setEnabled(true);
                textFlowDisabled->setEnabled(true);
                textFlowUsesFrameShape->setEnabled(true);
                textFlowUsesBoundingBox->setEnabled(true);
                textFlowUsesContourLine->setEnabled(true);
                textFlowUsesImageClipping->setEnabled(false);
        }
        if (m_item->asSymbolFrame())
        {
                customShape->setEnabled(true);
                editShape->setEnabled(true);
                textFlowDisabled->setEnabled(true);
                textFlowUsesFrameShape->setEnabled(true);
                textFlowUsesBoundingBox->setEnabled(true);
                textFlowUsesContourLine->setEnabled(true);
                textFlowUsesImageClipping->setEnabled(false);
        }
}

void PropertyWidget_GroupShape::setCustomShapeIcon(int submode)
{
        customShape->setIcon( customShape->getIconPixmap(submode) );
}

void PropertyWidget_GroupShape::setLocked(bool isLocked)
{
        QPalette pal(qApp->palette());
        if (isLocked)
                pal.setCurrentColorGroup(QPalette::Disabled);

        editShape->setEnabled(!isLocked);
        if (m_doc && m_item)
        {
                enableCustomShape();
                if (((m_item->asTextFrame()) || (m_item->asImageFrame()) || (m_item->asPolygon())) &&  (!m_item->ClipEdited) && ((m_item->FrameType == 0) || (m_item->FrameType == 2)))
                        roundRect->setEnabled(!isLocked);
                else
                        roundRect->setEnabled(false);
        }
}

void PropertyWidget_GroupShape::setRoundRectEnabled(bool enabled)
{
        roundRect->setEnabled(enabled);
}

void PropertyWidget_GroupShape::setCurrentItem(PageItem *item)
{
        if (!m_ScMW || m_ScMW->scriptIsRunning())
                return;
        //CB We shouldnt really need to process this if our item is the same one
        //maybe we do if the item has been changed by scripter.. but that should probably
        //set some status if so.
        //FIXME: This wont work until when a canvas deselect happens, m_item must be NULL.
        //if (m_item == i)
        //      return;

        if (!m_doc)
                setDoc(item->doc());

        m_item = item;

        disconnectSignals();
        enableFromSelection();

        if (m_item)
        {
                if (m_item->FrameType == 0)
                        customShape->setIcon(customShape->getIconPixmap(0));
                if (m_item->FrameType == 1)
                        customShape->setIcon(customShape->getIconPixmap(1));
                if (m_item->FrameType > 3)
                        customShape->setIcon(customShape->getIconPixmap(m_item->FrameType-2));

                roundRect->setValue(m_item->cornerRadius()*m_unitRatio);
                displayTextFlowMode(m_item->textFlowMode());

                setLocked(m_item->locked());
                nonZero->setChecked(!m_item->fillRule);
                evenOdd->setChecked(m_item->fillRule);

                connectSignals();
        }
}

void PropertyWidget_GroupShape::handleTextFlow()
{
        if (!m_ScMW || m_ScMW->scriptIsRunning())
                return;
        if (m_doc && m_item)
        {
                PageItem::TextFlowMode mode = PageItem::TextFlowDisabled;
                if (m_item->isGroup())
                {
                        if (textFlowDisabled->isChecked())
                                mode = PageItem::TextFlowDisabled;
                        if (textFlowUsesFrameShape->isChecked())
                                mode = PageItem::TextFlowUsesFrameShape;
                        if (textFlowUsesBoundingBox->isChecked())
                                mode = PageItem::TextFlowUsesBoundingBox;
                        if (textFlowUsesContourLine->isChecked())
                                mode = PageItem::TextFlowUsesContourLine;
                        if (textFlowUsesImageClipping->isChecked())
                                mode = PageItem::TextFlowUsesImageClipping;
                }
                m_item->setTextFlowMode(mode);
                m_ScMW->view->DrawNew();
                emit DocChanged();
        }
}

void PropertyWidget_GroupShape::handleShapeEdit()
{
        if (!m_ScMW || m_ScMW->scriptIsRunning())
                return;
        if (m_doc && m_item)
        {
                m_tmpSelection->clear();
                m_tmpSelection->copy(*m_doc->m_Selection, true);
                m_doc->m_Selection->clear();
                m_doc->m_Selection->addItem(m_item);
                m_item->isSingleSel = true;
                m_item->update();
                m_ScMW->view->requestMode(modeEditClip);
                connect(m_ScMW->nodePalette, SIGNAL(paletteClosed()), this, SLOT(handleShapeEditEnded()));
                emit shapeEditStarted();
        }
}

void PropertyWidget_GroupShape::handleShapeEditEnded()
{
        disconnect(m_ScMW->nodePalette, SIGNAL(paletteClosed()), this, SLOT(handleShapeEditEnded()));
        if (m_doc && m_item)
        {
                if (m_tmpSelection->count() > 0)
                {
                        m_doc->m_Selection->copy(*m_tmpSelection, false);
                        m_doc->m_Selection->connectItemToGUI();
                }
                m_tmpSelection->clear();
        }
}

void PropertyWidget_GroupShape::handleCornerRadius()
{
        if (!m_doc || !m_doc || !m_ScMW || m_ScMW->scriptIsRunning())
                return;
        m_item->setCornerRadius(roundRect->value() / m_unitRatio);
        m_ScMW->view->SetFrameRounded();
        emit DocChanged();
        m_doc->regionsChanged()->update(QRect());
}

void PropertyWidget_GroupShape::handleNewShape(int frameType, int count, qreal *points)
{
        if (!m_ScMW || m_ScMW->scriptIsRunning())
                return;
        if (m_doc && m_item)
        {
                if ((m_item->itemType() == PageItem::PolyLine) || (m_item->itemType() == PageItem::PathText))
                        return;

                m_doc->item_setFrameShape(m_item, frameType, count, points);
                roundRect->setEnabled(frameType == 0);

                //ScribusDoc::changed() is called in item_setFrameShape()
                //Hope this is enough
                //emit DocChanged();
                emit shapeChanged(frameType);
        }
}

void PropertyWidget_GroupShape::displayTextFlowMode(PageItem::TextFlowMode mode)
{
        if (!m_ScMW || m_ScMW->scriptIsRunning() || !m_item)
                return;
        if (m_item->isGroup())
        {
                if (mode == PageItem::TextFlowDisabled)
                        textFlowDisabled->setChecked(true);
                else if (mode == PageItem::TextFlowUsesFrameShape)
                        textFlowUsesFrameShape->setChecked(true);
                else if (mode == PageItem::TextFlowUsesBoundingBox)
                        textFlowUsesBoundingBox->setChecked(true);
                else if (mode == PageItem::TextFlowUsesContourLine)
                        textFlowUsesContourLine->setChecked(true);
                else if (mode == PageItem::TextFlowUsesImageClipping)
                        textFlowUsesImageClipping->setChecked(true);
                if ((m_item->asImageFrame()) && (m_item->imageClip.size() != 0))
                        textFlowUsesImageClipping->setEnabled(true);
                else
                        textFlowUsesImageClipping->setEnabled(false);
        }
}