/***************************************************************************
 *   Copyright (c) 2006 Werner Mayer <wmayer[at]users.sourceforge.net>     *
 *                                                                         *
 *   This file is part of the FreeCAD CAx development system.              *
 *                                                                         *
 *   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; either          *
 *   version 2 of the License, or (at your option) any later version.      *
 *                                                                         *
 *   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., 59 Temple Place,         *
 *   Suite 330, Boston, MA  02111-1307, USA                                *
 *                                                                         *
 ***************************************************************************/


#include "PreCompiled.h"

#ifndef _PreComp_
# include <QApplication>
# include <QPixmap>
# include <QMessageBox>
#endif

#include <App/DocumentObjectGroup.h>
#include <App/Document.h>

/// Here the FreeCAD includes sorted by Base,App,Gui......
#include "ViewProviderDocumentObjectGroup.h"
#include "Application.h"
#include "Command.h"
#include "BitmapFactory.h"
#include "Document.h"
#include "Tree.h"
#include "View3DInventor.h"
#include "View3DInventorViewer.h"


using namespace Gui;


PROPERTY_SOURCE(Gui::ViewProviderDocumentObjectGroup, Gui::ViewProviderDocumentObject)


/**
 * Creates the view provider for an object group.
 */
ViewProviderDocumentObjectGroup::ViewProviderDocumentObjectGroup() : visible(false)
{
#if 0
    setDefaultMode(SO_SWITCH_ALL);
#endif
}

ViewProviderDocumentObjectGroup::~ViewProviderDocumentObjectGroup()
{
}

/**
 * Whenever a property of the group gets changed then the same property of all
 * associated view providers of the objects of the object group get changed as well.
 */
void ViewProviderDocumentObjectGroup::onChanged(const App::Property* prop)
{
    ViewProviderDocumentObject::onChanged(prop);
}

void ViewProviderDocumentObjectGroup::attach(App::DocumentObject *pcObj)
{
    ViewProviderDocumentObject::attach(pcObj);
}

void ViewProviderDocumentObjectGroup::updateData(const App::Property* prop)
{
#if 0
    if (prop->getTypeId() == App::PropertyLinkList::getClassTypeId()) {
        std::vector<App::DocumentObject*> obj =
            static_cast<const App::PropertyLinkList*>(prop)->getValues();
        Gui::Document* doc = Gui::Application::Instance->getDocument
            (&this->getObject()->getDocument());
        MDIView* mdi = doc->getActiveView();
        if (mdi && mdi->isDerivedFrom(View3DInventor::getClassTypeId())) {
            View3DInventorViewer* view = static_cast<View3DInventor*>(mdi)->getViewer();
            SoSeparator* scene_graph = static_cast<SoSeparator*>(view->getSceneGraph());
            std::vector<ViewProvider*> current_nodes;
            for (std::vector<App::DocumentObject*>::iterator it = obj.begin(); it != obj.end(); ++it)
                current_nodes.push_back(doc->getViewProvider(*it));
            std::sort(current_nodes.begin(), current_nodes.end());
            std::sort(this->nodes.begin(), this->nodes.end());
            // get the removed views
            std::vector<ViewProvider*> diff_1, diff_2;
            std::back_insert_iterator<std::vector<ViewProvider*> > biit(diff_2);
            std::set_difference(this->nodes.begin(), this->nodes.end(), 
                                current_nodes.begin(), current_nodes.end(), biit);
            diff_1 = diff_2;
            diff_2.clear();
            // get the added views
            std::set_difference(current_nodes.begin(), current_nodes.end(),
                                this->nodes.begin(), this->nodes.end(), biit);
            this->nodes = current_nodes;
            // move from root node to switch
            for (std::vector<ViewProvider*>::iterator it = diff_1.begin(); it != diff_1.end(); ++it) {
                view->addViewProviderToGroup(*it, scene_graph);
                view->removeViewProviderFromGroup(*it, this->pcModeSwitch);
            }
            // move from switch node to root node
            for (std::vector<ViewProvider*>::iterator it = diff_2.begin(); it != diff_2.end(); ++it) {
                view->addViewProviderToGroup(*it, this->pcModeSwitch);
                view->removeViewProviderFromGroup(*it, scene_graph);
            }
        }
    }
#endif
}

std::vector<App::DocumentObject*> ViewProviderDocumentObjectGroup::claimChildren(void)const
{
    return std::vector<App::DocumentObject*>(static_cast<App::DocumentObjectGroup*>(getObject())->Group.getValues());
}

bool ViewProviderDocumentObjectGroup::canDragObjects() const
{
    return true;
}

void ViewProviderDocumentObjectGroup::dragObject(App::DocumentObject* obj)
{
    Gui::Command::doCommand(Gui::Command::Doc,"App.getDocument(\"%s\").getObject(\"%s\").removeObject("
            "App.getDocument(\"%s\").getObject(\"%s\"))",
            getObject()->getDocument()->getName(), getObject()->getNameInDocument(), 
            obj->getDocument()->getName(), obj->getNameInDocument() );
}

bool ViewProviderDocumentObjectGroup::canDropObjects() const
{
    return true;
}

void ViewProviderDocumentObjectGroup::dropObject(App::DocumentObject* obj)
{
    Gui::Command::doCommand(Gui::Command::Doc,"App.getDocument(\"%s\").getObject(\"%s\").addObject("
            "App.getDocument(\"%s\").getObject(\"%s\"))",
            getObject()->getDocument()->getName(), getObject()->getNameInDocument(), 
            obj->getDocument()->getName(), obj->getNameInDocument() );
}

std::vector<std::string> ViewProviderDocumentObjectGroup::getDisplayModes(void) const
{
    // empty
    return std::vector<std::string>();
}

bool ViewProviderDocumentObjectGroup::onDelete(const std::vector<std::string> &)
{
    App::DocumentObjectGroup *group = static_cast<App::DocumentObjectGroup *> (getObject());
    // If the group is nonempty ask the user if he wants to delete it's content
    if ( group->Group.getSize () ) {
        QMessageBox::StandardButton choice = 
            QMessageBox::question ( 0, QObject::tr ( "Delete group content?" ), 
                QObject::tr ( "The %1 is not empty, delete it's content as well?")
                    .arg ( QString::fromUtf8 ( group->Label.getValue () ) ), 
                QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes );

        if ( choice == QMessageBox::Yes ) {
            Gui::Command::doCommand(Gui::Command::Doc,
                    "App.getDocument(\"%s\").getObject(\"%s\").removeObjectsFromDocument()"
                    ,getObject()->getDocument()->getName(), getObject()->getNameInDocument());
        }
    }
    return true;
}

bool ViewProviderDocumentObjectGroup::allowDrop(const std::vector<const App::DocumentObject*> &objList,Qt::KeyboardModifiers keys,Qt::MouseButtons mouseBts,const QPoint &pos)
{
    for( std::vector<const App::DocumentObject*>::const_iterator it = objList.begin();it!=objList.end();++it)
        if ((*it)->getTypeId().isDerivedFrom(App::DocumentObjectGroup::getClassTypeId())) {
            if (static_cast<App::DocumentObjectGroup*>(getObject())->isChildOf(
                static_cast<const App::DocumentObjectGroup*>(*it))) {
                return false;
            }
        }

    return true;
}
void ViewProviderDocumentObjectGroup::drop(const std::vector<const App::DocumentObject*> &objList,Qt::KeyboardModifiers keys,Qt::MouseButtons mouseBts,const QPoint &pos)
{
        // Open command
        App::DocumentObjectGroup* grp = static_cast<App::DocumentObjectGroup*>(getObject());
        App::Document* doc = grp->getDocument();
        Gui::Document* gui = Gui::Application::Instance->getDocument(doc);
        gui->openCommand("Move object");
        for( std::vector<const App::DocumentObject*>::const_iterator it = objList.begin();it!=objList.end();++it) {
            // get document object
            const App::DocumentObject* obj = *it;
            const App::DocumentObjectGroup* par = App::DocumentObjectGroup::getGroupOfObject(obj);
            if (par) {
                // allow an object to be in one group only
                QString cmd;
                cmd = QString::fromLatin1("App.getDocument(\"%1\").getObject(\"%2\").removeObject("
                                  "App.getDocument(\"%1\").getObject(\"%3\"))")
                                  .arg(QString::fromLatin1(doc->getName()))
                                  .arg(QString::fromLatin1(par->getNameInDocument()))
                                  .arg(QString::fromLatin1(obj->getNameInDocument()));
                Gui::Application::Instance->runPythonCode(cmd.toUtf8());
            }

            // build Python command for execution
            QString cmd;
            cmd = QString::fromLatin1("App.getDocument(\"%1\").getObject(\"%2\").addObject("
                              "App.getDocument(\"%1\").getObject(\"%3\"))")
                              .arg(QString::fromLatin1(doc->getName()))
                              .arg(QString::fromLatin1(grp->getNameInDocument()))
                              .arg(QString::fromLatin1(obj->getNameInDocument()));
            
            Gui::Application::Instance->runPythonCode(cmd.toUtf8());
        }
        gui->commitCommand();

}

void ViewProviderDocumentObjectGroup::hide(void)
{
    // when reading the Visibility property from file then do not hide the
    // objects of this group because they have stored their visibility status, too
    if (!Visibility.testStatus(App::Property::User1) && this->visible) {
        App::DocumentObject * group = getObject();
        if (group && group->getTypeId().isDerivedFrom(App::DocumentObjectGroup::getClassTypeId())) {
            const std::vector<App::DocumentObject*> & links = static_cast<App::DocumentObjectGroup*>
                (group)->Group.getValues();
            Gui::Document* doc = Application::Instance->getDocument(group->getDocument());
            for (std::vector<App::DocumentObject*>::const_iterator it = links.begin(); it != links.end(); ++it) {
                ViewProvider* view = doc->getViewProvider(*it);
                if (view) view->hide();
            }
        }
    }

    ViewProviderDocumentObject::hide();
    this->visible = false;
}

void ViewProviderDocumentObjectGroup::show(void)
{
    // when reading the Visibility property from file then do not hide the
    // objects of this group because they have stored their visibility status, too
    if (!Visibility.testStatus(App::Property::User1) && !this->visible) {
        App::DocumentObject * group = getObject();
        if (group && group->getTypeId().isDerivedFrom(App::DocumentObjectGroup::getClassTypeId())) {
            const std::vector<App::DocumentObject*> & links = static_cast<App::DocumentObjectGroup*>
                (group)->Group.getValues();
            Gui::Document* doc = Application::Instance->getDocument(group->getDocument());
            for (std::vector<App::DocumentObject*>::const_iterator it = links.begin(); it != links.end(); ++it) {
                ViewProvider* view = doc->getViewProvider(*it);
                if (view) view->show();
            }
        }
    }

    ViewProviderDocumentObject::show();
    this->visible = true;
}

bool ViewProviderDocumentObjectGroup::isShow(void) const
{
    return Visibility.getValue();
}

void ViewProviderDocumentObjectGroup::Restore(Base::XMLReader &reader)
{
    Visibility.setStatus(App::Property::User1, true); // tmp. set
    ViewProviderDocumentObject::Restore(reader);
    Visibility.setStatus(App::Property::User1, false); // unset
}

/**
 * Extracts the associated view providers of the objects of the associated object group group. 
 */
void ViewProviderDocumentObjectGroup::getViewProviders(std::vector<ViewProviderDocumentObject*>& vp) const
{
    App::DocumentObject* doc = getObject();
    if (doc->getTypeId().isDerivedFrom(App::DocumentObjectGroup::getClassTypeId())) {
        Gui::Document* gd = Application::Instance->getDocument(doc->getDocument());
        App::DocumentObjectGroup* grp = (App::DocumentObjectGroup*)doc;
        std::vector<App::DocumentObject*> obj = grp->getObjects();
        for (std::vector<App::DocumentObject*>::iterator it = obj.begin(); it != obj.end(); ++it) {
            ViewProvider* v = gd->getViewProvider(*it);
            if (v && v->getTypeId().isDerivedFrom(ViewProviderDocumentObject::getClassTypeId()))
                vp.push_back((ViewProviderDocumentObject*)v);
        }
    }
}

/**
 * Returns the pixmap for the list item.
 */
QIcon ViewProviderDocumentObjectGroup::getIcon() const
{
    QIcon groupIcon;
    groupIcon.addPixmap(QApplication::style()->standardPixmap(QStyle::SP_DirClosedIcon),
                        QIcon::Normal, QIcon::Off);
    groupIcon.addPixmap(QApplication::style()->standardPixmap(QStyle::SP_DirOpenIcon),
                        QIcon::Normal, QIcon::On);
    return groupIcon;
}


// Python feature -----------------------------------------------------------------------

namespace Gui {
/// @cond DOXERR
PROPERTY_SOURCE_TEMPLATE(Gui::ViewProviderDocumentObjectGroupPython, Gui::ViewProviderDocumentObjectGroup)
/// @endcond

// explicit template instantiation
template class GuiExport ViewProviderPythonFeatureT<ViewProviderDocumentObjectGroup>;
}