GitLab

# Take back the updateInfoWidget to its previous position and add a new updateColor function to just update the Color in the label.

# Add the ability to read the color when hovering the mouse into the canvas and dragging the right mouse button.

# Make a pointer from datacontainerinspectorwidget into datacontainerinspectorcanvas, as we need to call the updateInfoWidget() after updating the color.

# Make the updateInfoWidget() as public to be able to call it.

# Add the Capability to look up the color under the mouse button when one of the mouse buttons is pressed.

In its destructor, LogHighlighter first of all deleted its filter regex
explicitly, and then called `setFilterRegExp(0)`, triggering a second —
this time somewhat implicit — delete. If the filter regex pointer was
not NULL, this caused the application to crash due to a double-free.

Fix this error by not invoking `setFilterRegExp` in LogHighlighter's
destructor; the explicit delete performs the same cleanup as
`setFilterRegExp` anyways.

 * fixed 1D geometry TF editor
 * introduced OptionProperty to specify gradient computation mode
 * added s_changed signal of properties also being propagated to its shared properties
 * fixed sampling rate compensation when using adaptive sampling in simpleraycaster.frag

Fixed missing/wrong deregistration of GeometryXdTransferFcuntionEditors when their widgets are closed (and hence the GL contexts destroyed)

Fixes -Wswitch

Previously, when an MDI window was being dragged very fast and its state
changed from docked to floating (or vice versa), it wouldn't be placed
under the cursor, but instead some way behind it (with regards to the
drag direction). This happened because we decided where to place the
window's based on its last position in its previous state. Now we use
the cursor's position to calculate the window's new position, which
fixes the problem.

PipelineMdiSubWindow has been renamed MdiDockedWindow, and
refactored to make it easier to use it with arbitrary widgets.

To better group MDI-related classes, all of them have been moved to the
´gui/mdi´ directory.

VisualizationPipelineWidget has been renamed MdiFloatingWindow, and
refactored to make it easier to use it with arbitrary widgets.

VisualizationPipelineWrapper has been renamed MdiDockArea, and refactored
to make it easier to use it with arbitrary widgets. It now inherits from
QMdiArea, which removes an unnecessary layer of indirection. Moreover, it
creates MDI subwindows and floating windows only if necessary, i.e. when
a widget stored in it changes state.

Work on Issue #44: Removed GLContext interface and merged functionality into GlCanvas. Introducing abstract (Qt-free) tgt::GlContextManager interface, being implemented by tgt::QtContextManager. Further clean up of related code.

CampvisApplication manages multiple DataContainers, updated PipelineTreeWidget to show correct DataContainer/Pipeline/Processor hierarchy

Even though all integer-based properties derived from NumericProperty
used the same step value, T(1), it had to be specified when
instantiating them. To reduce boilerplate code in property
constructors, NumericProperty now uses T(1) as the default step value.

Revised event handling system: Got rid of campvis::AbstractEventHandler and replaced with functionality of tgt::EventListener and tgt::EventHandler

FloatPropertyWidget and VecPropertyWidget configure their adjusters to
display as many decimals as their properties have significant decimal
places. Moreover, they connect to the s_decimalsChanged signal in order
to reconfigure their adjusters when the number of significant decimal
places of their properties changes.

Floating point properties were previously typedef'd to specific
instantiations of NumericProperty. Now that we have
FloatingPointProperty, which extends NumericProperty to control how many
decimal places should be shown when displaying the property's value, all
typedefs for floating point properties have been updated to point to it
instead.

As a result, many processors and pipelines needed to have their includes
and/or constructors fixed to import and work with the new typedefs.

A new attribute has been added to all numeric properties: step value. It
determines the value of a single increment/decrement that numeric
property widgets use when their associated properties are modified using
sliders or spin boxes (users are still able to type any valid property
value in text edits).

Numerous processors and pipelines had to be updated to work with the
changed NumericProperty interface. However, choosing a well-suited step
value for each property can make it easier for users to modify the
property — using one step value for all properties leads to cases where
it is either too small, causing users to go through property values
which don't cause any visible change, or too big, making it difficult to
quickly determine the right property value.

Previously, widgets for int and vector<int> properties used only spin
boxes to display and let users modify the values of their associated
property.

Now that we have IntAdjusterWidget, IntPropertyWidget and all
IVecPropertyWidgets have been updated to use it to make it possible to
change the values of their components with not only a spin box, but also
a slider.

IntAdjusterWidget displays and provides two ways of modifying integers:
a slider that can be used to quickly change numeric values, and a spin
box, which is better suited for precise adjustments.

IntAdjusterWidget is a simple extension of AbstractAdjusterWidget<int>.
It is designed to be used by IntPropertyWidget and widgets for vector
properties storing integers.

DoubleAdjusterWidget used to inherit directly from QWidget. Rebasing it
on top of AbstractAdjusterWidget<double>, however, greatly simplified
its implementation and provided it with several additional API methods
for free.

AbstractAdjusterWidget is intended to be a base class for widgets
combining a slider with a spin box. It abstracts common functionality of
such widgets, leaving only signal/slot support and behaviour tweaks to
be added in concrete adjuster classes.

AbstractAdjusterWidget is a template class that can be parametrised with
either double or int. Its API closely follows that of QSpinBox/QSlider.

Due to its language extensions, MSVC is more permissive than GCC with
respect to C++ code that doesn't fully comply with the language
standard. LogHighlighter relied on 2 such extensions: non-const rvalue
references, and closing nested template argument lists with '>>'
(instead of '> >'). Its code has now been fixed to conform to the
standard, and compiles fine with GCC 4.7 as a result.

AbstractPropertyWidget's onPropertyChanged slot is invoked from non-GUI
threads. Previously, it would call updateWidgetFromProperty directly,
which resulted in Qt widgets being accessed from non-GUI threads. This
in turn led to random crashes when properties were modified quickly and
repeatedly from the GUI.

Now we invoke updateWidgetFromProperty via a signal-slot connection with
an internal signal, s_propertyChanged. This makes Qt take care of
queueing slot accesses in the GUI thread for us.

Fixes #36

Previously, property widgets have always had their components displayed
horizontally next to a label with the property name. However, that made
widgets consisting of many components (e.g. widgets for vector
properties) hard to use because their components were squeezed together.

Now AbstractPropertyWidget takes one additional optional argument,
displayBoxed. If it's false, the widget is displayed as before. When
it's true, the widget is laid out vertically in a QGroupBox. For now
only widgets for vector properties set displayBoxed to true.

Previously, widgets for double-valued vector properties used only spin
boxes to display and let users modify the values of their associated
property.

Now that we have DoubleAdjusterWidget, vector property widgets have been
updated to use it to make it possible to change the values of their
components with not only a spin box, but also a slider.

Previously, FloatPropertyWidget used standard spin boxes and sliders to
display and let users modify the value of its associated property.
Consequently, it had to synchronise the states of those widgets on its
own.

Now that we have a separate widget that implements the two ways of
changing double values that FloatPropertyWidget provides, it makes sense
to simplify FloatPropertyWidget's code by making it use
DoubleAdjusterWidget internally.

DoubleAdjusterWidget displays and provides two ways of modifying
double-precision floating-point numbers: a slider that can be used to
quickly change numeric values, and a spin box, which is better suited
for precise adjustments.

DoubleAdjusterWidget is designed to be used by FloatPropertyWidget and
widgets for vector properties storing floats.

The sizeHint method has been overridden in PipelineTreeWidget to return
a sensible height for the wigdet, while still reusing QTreeView's
hardcoded width.

The main window makes use of that to limit PipelineTreeWidget's maximum
height and give any vertical space reclaimed in this way over to the
widget displaying pipeline properties.