GitLab

Added appropriate mutex locks and updated qt code to use Qt:QueuedConnection.

* ItemDefinition can now perform testing on its set of categories w/r to another set using passCategoryCheck(...)
* Added the ability to indicate if any or all of an ItemDefinition's categories need to be in the set passed into passCategoryCheck.  This is controlled by ItemDefinition::setCategoryCheckMode(...)
* Extended both Attribute and Item isValid methods to take in a set of categories.  If an item would fail it's passCategoryCheck based on the input set then isValid will return true since the item's state is being "filtered out"
* Added XML/JSON support for reading/writing ItemDefinition::categoryCheckMode
* Updated qtUIManager, qtAttributeView and qtInstanceView to make use of these new methods

This is now used by qtInputsItem to create new expressions without having to go the view that is displaying them.

Also fixed issue with group item tables not being resized vertically to make use of the extra space.

qtInputsItems::updateItemData now updates the underlying widgets if the associated attribute:Items are changed externally.  Note that expressions are not currently supported.

Using ItemViews you can now control how the double value item is displayed based using the following "attributes":

* Notation - general display behavior.  Supported values include:
 * Fixed - displays the value in fixed notation.  This is equivalent to printf's %f flag
 * Scientific - displays the value in scientific notation.  This is equivalent to printf's %e flag
 * Mixed - tries to determine the best notation to use.  This is equivalent to printf's %g flag
* Precision - controls the precision (in the case of Fixed and Scientific Notations) or significant digits (in the case of Mixed Notation) that are to be displayed when the value is not being edited.
* EditPrecision - controls the precision (in the case of Fixed and Scientific Notations) or significant digits (in the case of Mixed Notation) that are to be displayed when the value is being edited.

Example SBT Code:

```xml
    <View Type="Instanced" Title="General">
      <InstancedAttributes>
        <Att Name="numerics-att" Type="numerics">
          <ItemViews>
            <View Item="dt_init" Type="Default" Precision="6" EditPrecision="10"/>
            <View Item="dt_max" Type="Default" Precision="6" EditPrecision="10" Notation="Fixed"/>
            <View Item="dt_min" Type="Default" Precision="6" EditPrecision="10" Notation="Scientific"/>
          </ItemViews>
        </Att>
        <Att Name="outputs-att" Type="outputs" />
        <Att Name="simulation-control-att" Type="simulation-control" />
<!--         <Att Name="Mesh" Type="mesh" /> -->
      </InstancedAttributes>
    </View>
```

This way a qtItem can be update externally when its underlying item is modified

This also eliminates the wrapper's selection listener
which is no longer needed.

Some tests (especially those that deal with multiple threads and
timing) do not have a 100% pass rate. This MR adds a toggle for
enabling these tests independently from the rest of the tests in
SMTK.

ParaView's selection-handling rewrites the VTK selection created
during pick events, dropping information that SMTK needs to recover
component IDs. To address this, ParaView has moved its rewrite
logic into a new class, named `vtkPVEncodeSelectionForServers`,
which applications (or plugins) can override using the vtkObjectFactory.

SMTK now overrides creation of this class, returning a custom subclass
named `vtkSMTKEncodeSelection`. This class is created on the client
and dispatches ParaView selections to operations in a new group
(VTKSelectionRespondersGroup). These operations are provided access
to the client-side SMTK selection instance and the first operation
to process a given resource is accepted as the selection updater
for that resource.

This commit also adds a toolbar filter-option for selecting instance
entities and an icon for instances in the resource browser widget.

Added new method qtItem::markForDeletion - this method should replace deleteLater calls.

The problem was Observers definined in qtItem derived classes such as qtReferenceItemComboBox were being called even when the qtItem was in the process of being deleted.  This new method (and the ability to override it) provides an
oppertunity for the qtItem to remove its observers when it is marked to be deleted.  The default implemenetation simplies calls deleteLater.

In the original implementation the attribute resource that the "owns" the
reference item was not being taken into consideration when determining
what could be associated to the item when dealing with the case where the attribute
resource is explicitly associated to other resources.

This modification changes it so that it will include the attribute resource
even if there is no reosurce manager.

... that is focused on attribute-centric views.
This makes it possible to add other views such
as qtResourceBrowser.

XXX: Icons

If you clicked on the attribute's type column the widget would try to set the attribute's color.  This was due to a hard coded column number instead of using the color_column variable.  So when the status field was added everything was shifted.

The issue was that it was assumed a QTabelWidget's selectItems() method would return
the all of the item pointers in a selected row even if they were nullptr (as in the case
of a valid attrubute - its status column would be nullptr).  That is not the case.
Instead you need to look at the returned items to find the one in column you are looking for.

If a QLineEdit widget (generated from a qtValueItem) is being editted
and the user does not press Tab or Return to generate a editting finished signal but instead
proceeds to select objects from the Association Widget lists - you can generate a crash
if an item is selected and a previous item is trying to have its background set back to normal.

This appears to be a QT bug (currently using 5.12.3 on Mac) - this change
turns off the list highlighting mechanism.

* Also changed qtReferenceItemComboBox to display "Please Select" in red
* Also created const ints to indicate special columns in qtAttributeView's table of attributes

* If there is no workflow filter the operations would not be displayed as sorted - this fixes that
* Also tooltips are added if the operation has a brief description
* Added mechanism to display the operation using its Label instead - this is by default off
* Fixed Tooltips for oscillator session's operations.

The qtItem was emitting modification signals when the item's value was not changing.

* When underlying GroupItem was not extensible, the group was not deleting any of its children qtItems
* This change simplifies how the class does clean up and uses the functionality provided by qtItem
* Added a removeChildItem method to qtItem to remove and delete a child qtItem
* Made qtItem's childItem-based methods protected instead of public

* When the UIManager didn't have a Selection registered with it, the qtItem was not setting the item's value.

Because createWidget() is a special case for reference items

This changes makes qtReferenceItemCombo box behave like widgets that
use the Descriptive Phase approach.

In addition a new method (displayName() has been added that returns the label if its not empty, else it returns the name.

Also removed qtComponentItem from MOC HEADERS List since its isn't needed.

* Added qtReferenceItemComboBox - a new qtItem that uses a combox as a UI for setting ReferenceItems.  This simple interface is only for items that are not extensiable and whose number of required values is 1.  Has the ability to restrict possible choices based on the things associated with its Attribute
* Changed the way qtItems are deleted - qtAttribute now uses deleteLater instead of just calling delete on the qtItem
* Added a new slot for qtAttributeView and qtAssociationView so itemModified signals can be emitted when an attribute's associations are modified
* qtComponentItem has been simplified to just have a static factory method to either return a qtReferenceItem or a qtReferenceItemComboBox depending on its number of required values and extensibility

* None of the qtBaseView derived classess where cleaning up thier qtAttributes
* Added a hasAssociations() method to attribute::Resource to return true if resources were directly associated with it
* Needed to add the ability to ignore a resource when determining which objects could be asscoiated with an attribute (qtAssociationWidget) - main use case was if the widget was refreshing due to a resource being removed from the system we didn't want it to participate in the calculation.
* Removed some unnecessary includes