There are a lof of scenarios where it's not possible to perform an operation without throwing an exception. Reporting an exception as error is not only annoying but often confusing because the user assumes he did something wrong.
So, for the moment many of these exceptions are reported as log messages but serious things like memory exception, std. C++ exceptions or unknown C++ exceptions are still reported as errors
Add new argument to Application::newDocument() to create a temporary
document. Also exposed to Python API App.newDocument() with a named
argument 'temp'.
The temporary document is marked with status bit 'TempDoc'. The user
will not be prompt for saving when closing. The undo/redo is disabled.
The AutoSaver skips it. And the tree view will not show it.
PropertyXLink allows linking to/from object within a temporary document
without saving.
=============================================
New mechanism for on-demand signaling of undo/redo transaction finalisation.
The mechanism consists of:
1) A status bit that is set, when an object should receive this signaling (e.g. because changes during transaction have been inhibited)
2) The new function to be called by the Document undo/redo actions when the transaction is over (for those objects having the status bit set).
Note 1: The undo/redo signals are now outside the undoing FlagToggler, this means that:
1) a call to isPerformingTransaction will return false.
2) a recompute the slot of such a signal will not be inhibited.
Note 2: The undo/redo signals are called once the documentobjects that requested to be notified after the trasaction is over have been notified.
The consequence is that the viewprovider can rely on the documentobject having a correct status.
I think that the behaviour of Note and Note 2 is the wanted behaviour of this signals, I cannot rule out that other parts of FC rely on the old
implementation.
Dynamic property can be removed at any time, even during triggering of
onChanged() signal of the removing property. This patch introduced
static function Property::destroy() to make it safer by queueing any
removed property, and only deleting them when no onChanged() call is
active.
1 - Reports the error to the user in a popup.
2 - Names of the backups include the timstamp instead of a number. Names have more sense and the files can be sorted by names what is also the age order.
3 - Behaviors when changing configuration improved, the number of files present on the system was not reduced when reducing the number of backups or backups deactivated.
Found via `codespell -q 3 -L aci,ake,aline,alle,alledges,alocation,als,ang,anid,ba,beginn,behaviour,bloaded,byteorder,calculater,cancelled,cancelling,cas,cascade,centimetre,childs,colour,colours,commen,currenty,dof,doubleclick,dum,eiter,elemente,feld,freez,hist,iff,indicies,initialisation,initialise,initialised,initialises,initialisiert,ist,kilometre,lod,mantatory,methode,metres,millimetre,modell,nd,noe,normale,normaly,nto,numer,oder,orgin,orginx,orginy,ot,pard,pres,programm,que,recurrance,rougly,seperator,serie,sinc,strack,substraction,te,thist,thru,tread,uint,unter,vertexes,wallthickness,whitespaces -S ./.git,*.po,*.ts,./ChangeLog.txt,./src/3rdParty,./src/Mod/Assembly/App/opendcm,./src/CXX,./src/zipios++,./src/Base/swig*,./src/Mod/Robot/App/kdl_cp,./src/Mod/Import/App/SCL,./src/WindowsInstaller,./src/Doc/FreeCAD.uml`
Found via `codespell -q 3 -L aci,ake,aline,alle,alledges,alocation,als,ang,anid,ba,beginn,behaviour,bloaded,byteorder,calculater,cancelled,cancelling,cas,cascade,centimetre,childs,colour,colours,commen,currenty,dof,doubleclick,dum,eiter,elemente,feld,freez,hist,iff,indicies,initialisation,initialise,initialised,initialises,initialisiert,ist,kilometre,lod,mantatory,methode,metres,millimetre,modell,nd,noe,normale,normaly,nto,numer,oder,orgin,orginx,orginy,ot,pard,pres,programm,que,recurrance,rougly,seperator,serie,sinc,strack,substraction,te,thist,thru,tread,uint,unter,vertexes,wallthickness,whitespaces -S ./.git,*.po,*.ts,./ChangeLog.txt,./src/3rdParty,./src/Mod/Assembly/App/opendcm,./src/CXX,./src/zipios++,./src/Base/swig*,./src/Mod/Robot/App/kdl_cp,./src/Mod/Import/App/SCL,./src/WindowsInstaller,./src/Doc/FreeCAD.uml`
This patch adds support of recomputation with external linked object,
as well as external document auto loading and partial loading.
Application:
* Modified new/openDocument()/signalNewDocument to choose whether to
signal GUI for creating a view for the document. This makes it possible
to suppress view creation when opening external documents.
* New API openDocuments() which does the actual job of loading the
document together with any external dependencies. There are afew
extra arguments to allow setting FileName property differently from
the actual file path, which are required when auto loading
dependencies during document recovery (with future patch to
Gui::DocumentRecovery)
* openDocumentPrivate() is an internal helper for opening individual
document.
* New signalStart/FinishOpenDocument to be signaled before and after
opening a document. There may be multiple depending documents actually
opened in between these two signals.
* New signalBeforeRecomputeDocument signaled before recompute a
document.
* New API addPendingDocument() for use by external capable link
properties' to queue up external documents.
* isRestoring/isClosingAll(), for convenience status reporting.
Document:
* signalFinishImport/RestoreObjects, new signal triggered after imported
or restored all input objects
* signalBeforeRecompute, signaled before start recomputing this document
* Modified signalRecomputed with additional recomputed objects, this is
to make it more efficient for Gui::TreeWidget to check recomputation
result.
* signalSkipRecompute, signal to inform which objects are skipped
during recomputation because of their owner document SkipRecompute
setting.
* restore/save/read/writeObjects() modified to suport partial
loading. See [here](https://git.io/fj6PY) for more information.
* afterRestore(), internal function called to finish restore. The
function is separated from restore() because there is quite a few
critical steps needed to fully restore a document with external
linking. See [here](https://git.io/fj6P4) for more information.
* DocumentP::_RecomputeLog is modified to store more accurate object
recomputation error, including those happened during restore/import.
* isExporting(), new API for checking if an object is exporting.
External linking properties will use this function to decide how to
export.
* copyObject(), modified to support external linking objects, and
accepts multiple input objects.
* moveObject(), modified to support arbitary object moves. The original
implementation may cause crash if undo/redo is enabled. Furthermore,
because the original information fakes the object's deletion to break
its dependency, it does not work for objects that may auto delete their
children when being deleted. The new implementation copy the object,
and than paste it to the other document. It then deletes the input
objects from the original document. In case of recursive move, it only
deletes the depending object if it has an empty in list.
* importLinks(), new API to import any external object linked by the
input objects into this document. It will auto correct all link
references after importing.
* getDependencyList/_rebuildDependencyList(), these two APIs are unified
and implemented by an internal function _buildDependencyList() with a
new algorithm to handle external objects. The returned dependency list
will now include objects from external documents. In case of cyclic
dependencies, getDpendencyList() will report the actual objects
involved in dependency loops.
* mustExecute(), new API to check if there are any object requires
recomputation. This function will call _buildDependencyList() and
check for external objects as well.
* addRecomputeObject(), new API for marking changes during document
restore. It only marks the object but does not actually recompute
them for performance reason. One use case is for geo feature to
request for recomputation to generate geometry topological names.
* recompute(), support partial, external, and inverse dependency
recomputation. Improve error handling during recomputation.
See [here](https://git.io/fj6PO) for more information.
* _recomputeFeature(), suppoert user abort.
* getDependentDocuments/getInList(), new API to obtain an optional
dependency sorted list of depending documents.
DocumentObject:
* Add various ObjectStatus flags
* isExporting/getExportName(), return a safe name for exporting, in the
form of <ObjName>@<DocName>, which is guarrenteed to be unique.
Various link property will save linked object using this name if the
the linked object is exported together with the owner object, see
[PropertyLinkBase::restoreLabelReference()](https://git.io/fj6XO)
for more information.
* recomputeFeature(), add option to recompute this object together with
all its dependent objects.
* canLoadPartial(), new API for [partial document loading](https://git.io/fj6PY).
MergeDocuments:
* Move object name mapping logic to various link properties. See
Base::Sequencer:
* Add new API checkAbort() for checking user abort.
PropertyExpressionEngine is changed to derived from a new class
PropertyExpressionContainer, which is in turn derives from
PropertyXLinkContainer. This makes PropertyExpressionEngine a link type
property that is capable of external linking. It now uses the unified
link property APIs for dependency management and tracking of object
life time, re-labeling, etc.
ObjectIdentifier is modified to support sub-object reference, but is
not exposed to end-user, because expression syntax is kept mostly
unchanged, which will be submitted in future PR. There is, however,
one small change in expression syntax (ExpressionParser.y) to introduce
local property reference to avoid ambiguity mentioned in
FreeCAD/FreeCAD#1619
Modified Expression/ExpressionModifier interface to support various link
property API for link modification.
Introduce a new concept of transaction ID. Each transaction must be
unique inside the document. Multiple transactions from different
documents can be grouped together with the same transaction ID.
This makes it possible to undo/redo single operation that contains
changes from multiple documents due to external linking.
Application:
* get/set/closeActiveTransaction() is used to setup potential
transactions with a given name. The transaction is only created when
there is actual changes. If objects from multiple documents are
changed under the same active transaction, they will have the same
trasnaction ID, and can be undo/redo togtether later.
* signalUndo/signalRedo, new signals triggered once after an undo/redo
operation. Unlike signalUndo/RedoDocument, these signals will only be
triggered once even if there may be multiple documents involved during
undo/redo.
* signal(Before)CloseTransaction, new signals triggered before/after an
actual transaction is created or aborted.
AutoTransaction:
* Helper class to enable automatic management of transactions. See class
document for more details. This class will be used by Gui::Command
in later patches to allow better automation of transactions in
command.
Document:
* open/commit/abortTransaction() are now redirected to call
Application::get/set/closeActiveTransaction() instead.
* _openTransaction() is added to do the real creation of transaction.
* _checkTransaction() is modified to create transaction on actual change
of any property.
* getTransactionID() is used to find out the position of a transaction
with a given ID. When triggering undo in external document, it may be
necessary to perform multi-step undo/redo in order to match for the
transaction ID.
Transaction/TransactionObject:
* Various changes for the new transaction ID concept.
* Support undo/redo add/remove dynamic property
Property:
* Extended property status bitset. Mirror most of PropertyType and
allow dynamic change property type.
* Cache property name and type to improve performance
* Centralize property status change signalling
* Change aboutToSetValue()/hasSetValue() to virtual
* Add new API getFullName() to obtain full quanlified name of the property
AtomicPropertyChangeInterface:
* Allow calling aboutToSetValue()/hasSetValue() when actually changed
PropertyLists:
* Refactor implementation by an abstract class PropertyListBase and a
template class PropertyListsT, to allow better code reuse.
PropertyListT is derived from AtomicPropertyChangeInterface to allow
more efficient change on individual elements.
* All list type property now accept setting python value as a dictionary
with index as key to set individual element of a list.
* Add touch list for more efficient handling of value changes. The list
contains the index of changed value. And empty touch list should be
treated as the entire list is changed. PropertyContainerPy expose this
functionality with getPropertyTouchList().
PropertyPersistentObject:
* New property to allow dynamic creation of any FreeCAD object derived
from Base::Persistence, and use it as a property.
DynamicProperty:
* Use boost multi_index_container for efficient property lookup while
keeping order.
* Modify to be allowed to use in PropertyContainer directly
PropertyContainer:
* Use boost multi_index_container for efficient property lookup while
keeping order.
* Allow adding/removing dynamic property on all property container
* Modify Save/Restore() to persist property status, and better handle
transient property which can now be dynamically enabled/disabled per
object.
* Add new API getFullName() to obtain full quanlified name of the property.
Implemented by Document, DocumentObject, and also
ViewProviderDocumentObject if future patch
DocumentObject and FeaturePython are modified to accommondate the
dynamic property changes.
Removed get/setCustomAttribute() implementation from DocumentObjectPy,
and rely on PropertyContainerPy for the implementation, because of the
additional dynamic property support in property container.
Gui::ViewProviderDocumentObject, which is derived from
PropertyContainer, is also modified accordingly
DocumentObject:
* getSubObject(): the most important API for Link to work with
hierarchies. The function is a inspired from and replaces the
getPySubObjects(). It returns a child object following a dot separated
subname reference, and can optionally return accumulated
transformation, and/or a python object of the refered
sub-object/element. The default implementation here is to look for
link type property, and search for the referenced object. This patch also
include other specialized implementation of this API, such as
(GeoFeature)GroupExtension (through extensionGetSubObject()),
PartDesign::Body, and so on. A link type object is expected to
call the linked object's getSubObject() for resolving.
* getSubObjectList(): helper function to return a list of object
referenced in the given subname.
* getSubObjects(): return a list of subname references of all children
objects. The purpose of this function is similar to
ViewProvider::claimChildren(). Container type object is expected to
implement this function. The reason it returns subname references
instead of just object is to allow the container to skip hierarchies.
For example, the Assembly3 container uses this to skip the constraint
and element group.
* getLinkedObject(), obtain the linked object, and optionally with the
accumulated transformation. It is expected to return a linked object
or the object itself if it is not a link. In case there are multiple
levels of linking involved, this function allows the caller to retrieve
the linked object recursively.
* hasChildElement(), set/isElementVisible(), controls the children
visibility for a group type object. Because the child object may be
claimed by other objects, it is essential to have independent control
of children visibilities. These APIs are designed to abstract how
group manages the child visibility. For performance reason, these
function are meant to control only the immediate child object.
* resolve(), helper function to parse subname reference and resolve the
final object, and optionally the immediate parent of the final object,
the final object reference name (for calling `set/isElementVisible()`),
and the subname reference if there is one.
* touch(), add optional argument 'noRecompute' for better backward
compatibility with the NoRecompute flag. By default, touch() causes
recompute unless noRecompute is true
* signalChanged/signalBeforeChange, two new signal for tracking changes
of a specific object.
* getViewProviderNameOverride(), return a string of the view provider
type of this object. This allows Python class to override the view
provider of an object. This feature will be used by ViewProviderLink
which is designed to work with any object that has LinkBaseExtension.
* canLinkProperties(), will be used by Gui::PropertyView to display
linked object properties together with the object's own properties.
* redirectSubname(), will be used by Gui::Tree to allow an object to
redirect selection to some other object when (pre)selected in the tree
view.
* Visibility, new property serve as the same purpose as view provider
property of the same name. It is added here so that App namespace
code can check for visibility without Gui module. This is useful,
for example, when constructing a compound shape of a container that
respects the children visibility.
* (has)hasHiddenMarker(), return or check for a special sub-element
name used as marker for overriding sub-object visibility. Will be
used by Gui::ViewProvider, it is put here for the same reason as
adding Visibility property.
* getID(), return object internal identifier. Each object is now
assigned an integer identifier that is unique within its containing
document.
Document:
* ShowHidden, new property to tell tree view whether to show hidden
object items.
* signalTouchedObject, new signal triggered when manually touch an
object when calling its touch() function
* getObjectByID(), get object by its identifier
* addObject() is modified to allow overriding view provider
* has/getLinksTo(), helper function to obtain links to a given object.
Application:
* checkLinkDepth(), helper function to check recursive depth for link
traversal. The depth is checked against the total object count of
all opened documents. The count (_objCount) is internally updated
whenever object is added or removed.
* has/getLinksTo(), same as Document::has/getLinksTo() but return links
from all opened documents.
GroupExtension/OriginGroupExtension/DatumFeature/DatumCS/Part::Feature:
implement sepcialized getSubObject/getSubObjects().
