Instead of creating them for all items when composer window
is opened, instead just create and destroy them when
required. None are too heavy to have a noticable delay
when selecting items, but in contrast keeping them around
forever is wasteful on memory.
Also clean up a lot of duplicate composer/composition
code and remove unnecessary signals from api (use a single
itemAdded signal instead of multiple signals for every
item type)
This adds a new QgsLayoutManager class which is used for
storage and serializing/deserializing of compositions.
A QgsLayoutManager is attached to QgsProject. This allows
core code to access the compositions attached to a project.
The intention is to move all handling of compositions from
app to core, making it easy for server to access project
compositions without resorting to fragile xml parsing.
This enum value has not been in use since filter rects were
separated from other filter types. Leaving it in API is confusing
and leads to incorrect use.
geometry fetching
If request needs geometry but cache isn't fetching it then cache
is bypassed. This is a performance hit, so ensure that cache
and request are always in sync wrt to fetching geoms.
On behalf of Faunalia, sponsored by ENEL
In some cases canceling render jobs can take a long time. Eg when
using database layers over a sloooooow connection, canceling a job
can be blocked by minutes while waiting for the first batch of feature
fetching to finish. (Since eg postgres features are fetched in batches
of 2000 with no opportunity to abort mid-way through this).
This meant that while the first render allows the GUI to remain
responsive, any subsequent render operations which occured before
the first render completes locks up the whole ui until the first
render can finish cancellation.
With this change, the render cancelation happens with blocking.
It means that you can pan and zoom around a map over of slow
connection without any ui locks.
In a post-OTF-disabled world these are no longer required. The
map units are dictated by the map units for the destination
CRS.
It's dangerous to separate these two properties as setting
the incorrect map units for a given CRS will result in
incorrect scale calculations.
Because
- OTF reprojection is mature and stable
- Should be no cost when not required - transforms are shortcut
when not required
- Reduces code complexity
- Canvas OTF support was being incorrectly used as a flag for
whether measurements should be made in ellipsoidal mode. Instead
the project's ellipsoid setting should be checked for this.
- Should simplify behavior for new users
* [feature] QgsSettings QGIS QSettings replacement
This is the new QgsSettings class that adds an (optional)
Global Settings additional ini file where a system administrator
can store default values for the settings and provide
pre-configuration.
If an ini file named qgis_global_settings.ini is found
in the pkgDataPath directory it is automatically loaded,
this path can be overriden by a command line argument
( --globalsettingsfile path ) and through an environment
variable (QGIS_GLOBAL_SETTINGS_FILE).
This change is being driven by:
- need for consistent terminology in the api. Currently there's
a confusing mix of border/outline used
- need for consistent terminology in the gui - we have a mix
of "border"/"outline"/"pen"
- bringing QGIS into line with the standard terminology used
in other graphic editing programs
Handles scaling of input values to output values by using
a curve created from smoothly joining a number of set
control points.
This assists in creation of curve type transforms, typically
seen in raster image editing software (eg the curves dialog
in GIMP or Photoshop). Transforms are created by passing a
number of set control points through which the transform curve
must pass. The curve is guaranteed to exactly pass through
these control points. Between control points the curve is
smoothly interpolated so that no disjoint sections or
"corners" are present.
And add a new CLANG_TIDY_EXE cmake option. If this is set to the
path to the clang_tidy executable then a bunch of clang-tidy
checks will be run during compilation.
