FreeCAD

1
/***************************************************************************
2
 *   Copyright (c) 2015 Alexander Golubev (Fat-Zer) <fatzer2@gmail.com>    *
3
 *   Copyright (c) 2016 Stefan Tröger <stefantroeger@gmx.net>              *
4
 *                                                                         *
5
 *   This file is part of the FreeCAD CAx development system.              *
6
 *                                                                         *
7
 *   This library is free software; you can redistribute it and/or         *
8
 *   modify it under the terms of the GNU Library General Public           *
9
 *   License as published by the Free Software Foundation; either          *
10
 *   version 2 of the License, or (at your option) any later version.      *
11
 *                                                                         *
12
 *   This library  is distributed in the hope that it will be useful,      *
13
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
14
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
15
 *   GNU Library General Public License for more details.                  *
16
 *                                                                         *
17
 *   You should have received a copy of the GNU Library General Public     *
18
 *   License along with this library; see the file COPYING.LIB. If not,    *
19
 *   write to the Free Software Foundation, Inc., 59 Temple Place,         *
20
 *   Suite 330, Boston, MA  02111-1307, USA                                *
21
 *                                                                         *
22
 ***************************************************************************/
23

24
#include "PreCompiled.h"
25

26
#ifndef _PreComp_
27
#include <Inventor/actions/SoGetBoundingBoxAction.h>
28
#include <Inventor/nodes/SoSeparator.h>
29
#endif
30

31
#include <App/Document.h>
32
#include <App/Origin.h>
33
#include <App/OriginGroupExtension.h>
34
#include <Base/Console.h>
35

36
#include "ViewProviderOriginGroupExtension.h"
37
#include "Application.h"
38
#include "Document.h"
39
#include "View3DInventor.h"
40
#include "View3DInventorViewer.h"
41
#include "ViewProviderOrigin.h"
42
#include "ViewProviderOriginFeature.h"
43

44

45
using namespace Gui;
46
namespace sp = std::placeholders;
47

48

49
EXTENSION_PROPERTY_SOURCE(Gui::ViewProviderOriginGroupExtension, Gui::ViewProviderGeoFeatureGroupExtension)
50

51
ViewProviderOriginGroupExtension::ViewProviderOriginGroupExtension()
52
{
53
    initExtensionType(ViewProviderOriginGroupExtension::getExtensionClassTypeId());
54
}
55

56
ViewProviderOriginGroupExtension::~ViewProviderOriginGroupExtension()
57
{
58
    connectChangedObjectApp.disconnect();
59
    connectChangedObjectGui.disconnect();
60
}
61

62
std::vector<App::DocumentObject*> ViewProviderOriginGroupExtension::constructChildren (
63
        const std::vector<App::DocumentObject*> &children ) const
64
{
65
    auto* obj = getExtendedViewProvider()->getObject();
66
    auto* group = obj ? obj->getExtensionByType<App::OriginGroupExtension>() : nullptr;
67
    if(!group)
68
        return children;
69

70
    App::DocumentObject *originObj = group->Origin.getValue();
71

72
    // Origin must be first
73
    if (originObj) {
74
        std::vector<App::DocumentObject*> rv;
75
        rv.push_back (originObj);
76
        std::copy (children.begin(), children.end(), std::back_inserter (rv));
77
        return rv;
78
    } else { // Generally shouldn't happen but must be handled in case origin is lost
79
        return children;
80
    }
81
}
82

83

84
std::vector<App::DocumentObject*> ViewProviderOriginGroupExtension::extensionClaimChildren () const {
85
    return constructChildren ( ViewProviderGeoFeatureGroupExtension::extensionClaimChildren () );
86
}
87

88
std::vector<App::DocumentObject*> ViewProviderOriginGroupExtension::extensionClaimChildren3D () const {
89
    return constructChildren ( ViewProviderGeoFeatureGroupExtension::extensionClaimChildren3D () );
90
}
91

92
void ViewProviderOriginGroupExtension::extensionAttach(App::DocumentObject *pcObject) {
93
    ViewProviderGeoFeatureGroupExtension::extensionAttach ( pcObject );
94

95
    App::Document *adoc  = pcObject->getDocument ();
96
    Gui::Document *gdoc = Gui::Application::Instance->getDocument ( adoc ) ;
97

98
    assert ( adoc );
99
    assert ( gdoc );
100

101
    //NOLINTBEGIN
102
    connectChangedObjectApp = adoc->signalChangedObject.connect (
103
            std::bind ( &ViewProviderOriginGroupExtension::slotChangedObjectApp, this, sp::_1) );
104

105
    connectChangedObjectGui = gdoc->signalChangedObject.connect (
106
            std::bind ( &ViewProviderOriginGroupExtension::slotChangedObjectGui, this, sp::_1) );
107
    //NOLINTEND
108
}
109

110
void ViewProviderOriginGroupExtension::extensionUpdateData( const App::Property* prop ) {
111

112
    auto* obj = getExtendedViewProvider()->getObject();
113
    auto* group = obj ? obj->getExtensionByType<App::OriginGroupExtension>() : nullptr;
114
    if ( group && prop == &group->Group ) {
115
        updateOriginSize();
116
    }
117

118
    ViewProviderGeoFeatureGroupExtension::extensionUpdateData ( prop );
119
}
120

121
void ViewProviderOriginGroupExtension::slotChangedObjectApp ( const App::DocumentObject& obj) {
122
    auto* ext = getExtendedViewProvider()->getObject();
123
    auto* group = ext ? ext->getExtensionByType<App::OriginGroupExtension>() : nullptr;
124
    if ( group && group->hasObject (&obj, /*recursive=*/ true ) ) {
125
        updateOriginSize ();
126
    }
127
}
128

129
void ViewProviderOriginGroupExtension::slotChangedObjectGui ( const Gui::ViewProviderDocumentObject& vp) {
130
    if ( !vp.isDerivedFrom ( Gui::ViewProviderOriginFeature::getClassTypeId () )) {
131
        // Ignore origins to avoid infinite recursion (not likely in a well-formed document,
132
        //          but may happen in documents designed in old versions of assembly branch )
133
        auto* ext = getExtendedViewProvider()->getObject();
134
        auto* group = ext ? ext->getExtensionByType<App::OriginGroupExtension>() : nullptr;
135
        App::DocumentObject *obj = vp.getObject ();
136

137
        if ( group && obj && group->hasObject (obj, /*recursive=*/ true ) ) {
138
            updateOriginSize ();
139
        }
140
    }
141
}
142

143
void ViewProviderOriginGroupExtension::updateOriginSize () {
144
    auto owner = getExtendedViewProvider()->getObject();
145

146
    if(!owner->isAttachedToDocument() ||
147
       owner->isRemoving() ||
148
       owner->getDocument()->testStatus(App::Document::Restoring))
149
        return;
150

151
    auto* group = owner->getExtensionByType<App::OriginGroupExtension>();
152
    if(!group)
153
        return;
154

155
    // obtain an Origin and it's ViewProvider
156
    App::Origin* origin = nullptr;
157
    Gui::ViewProviderOrigin* vpOrigin = nullptr;
158
    try {
159
        origin = group->getOrigin ();
160
        assert (origin);
161

162
        Gui::ViewProvider *vp = Gui::Application::Instance->getViewProvider(origin);
163
        if (!vp) {
164
            Base::Console().Error ("No view provider linked to the Origin\n");
165
            return;
166
        }
167
        assert ( vp->isDerivedFrom ( Gui::ViewProviderOrigin::getClassTypeId () ) );
168
        vpOrigin = static_cast <Gui::ViewProviderOrigin *> ( vp );
169
    } catch (const Base::Exception &ex) {
170
        Base::Console().Error ("%s\n", ex.what() );
171
        return;
172
    }
173

174
    Gui::Document* gdoc = getExtendedViewProvider()->getDocument();
175
    if(!gdoc)
176
        return;
177

178
    Gui::MDIView* view = gdoc->getViewOfViewProvider(getExtendedViewProvider());
179
    if(!view)
180
        return;
181

182
    Gui::View3DInventorViewer* viewer = static_cast<Gui::View3DInventor*>(view)->getViewer();
183
    SoGetBoundingBoxAction bboxAction(viewer->getSoRenderManager()->getViewportRegion());
184

185
    // calculate the bounding box for out content
186
    SbBox3f bbox(0,0,0, 0,0,0);
187
    for(App::DocumentObject* obj : group->Group.getValues()) {
188
        ViewProvider *vp = Gui::Application::Instance->getViewProvider(obj);
189
        if (!vp) {
190
            continue;
191
        }
192

193
        bboxAction.apply ( vp->getRoot () );
194
        bbox.extendBy ( bboxAction.getBoundingBox () );
195
    };
196

197
    // get the bounding box values
198
    SbVec3f max = bbox.getMax();
199
    SbVec3f min = bbox.getMin();
200

201
    Base::Vector3d size;
202

203
    for (uint_fast8_t i=0; i<3; i++) {
204
        size[i] = std::max ( fabs ( max[i] ), fabs ( min[i] ) );
205
        if (size[i] < 1e-7) { // TODO replace the magic values (2015-08-31, Fat-Zer)
206
            size[i] = ViewProviderOrigin::defaultSize();
207
        }
208
    }
209

210
    vpOrigin->Size.setValue ( size * 1.3 );
211
}
212

213
namespace Gui {
214
EXTENSION_PROPERTY_SOURCE_TEMPLATE(Gui::ViewProviderOriginGroupExtensionPython, Gui::ViewProviderOriginGroupExtension)
215

216
// explicit template instantiation
217
template class GuiExport ViewProviderExtensionPythonT<ViewProviderOriginGroupExtension>;
218
}
219