While dragging a vertex, the feature on the original layer is
not updated until the first pointer move after dragging. See
#1796. Previously, the Modify interaction did not set the
interacting hint on the view, so the feature was also updated
on the original layer. But now, the interacting hint is set,
which exposes this behaviour.
Because we have nodes sorted by segment distance from the
editing vertex in #handleMouseAtPixel(), it is cheap to create a
hash of intersecting segments there. Now in #handleDragStart(),
we do not need to measure the distance of the vertex to the
segment. Instead, we just test if the segment is in the hash.
By creating the ol3 map div in the html, there is no need any
more to wait for the custom GMaps control to append the ol3 map
to its parent. This also fixes an issue that sometimes prevented
the ol3 map to appear, when the GMaps tiles were loaded before
the custom control's div was appended to its parent.
The zoom in/out tooltips are clipped when a css reset sets the
box-sizing to anything other than content-box. This breaks the
sizing of these tooltips, because they rely on content-box
sizing. This issue can e.g. be seen when using a bootstrap 3.x
bootstrap.css
The context is at the bottom of the object stack. All entry
points to parsing (#readGeometryFromNode(),
#readFeaturesFromNode()) set up the context now, and parsers
always access the context at index 0 of the objectStack.
The makeChildAppender function is used for adding a node of a
type with maxOccurs=1. For adding nodes of a type with
maxOccurs>1, the new makeChildrenAppender function was added.
With this new function, it turned out that more convenience for
creating node factories is required. The makeChildNodeFactory
function was renamed to makeSimpleNodeFactory, and it now can
create node factories where not only the namespace, but also the
node name can be fixed.
This adds several helper functions for serializing to XML:
* ol.xml.serialize: Counterpart to ol.xml.parse. By splitting
the serialization process up into a node factory and a node
writer, note writers can easily be used for different
namespaces.
* ol.xml.pushSerializeAndPop: Counterpart to
ol.xml.pushParseAndPop.
* ol.xml.makeStructureNS: Works like ol.xml.createParsersNS,
but works for arbitrary structures.
* ol.xml.makeChildAppender: If the top item of the stack has
the new ol.xml.NodeStackItem type, this helper function
can be used to create a serializer that appends the current
node to its designated parent.
* ol.xml.makeChildNodeFactory: Creates a node factory which
produces child nodes from an array of node names which are
passed to ol.xml.serialize.
* ol.xml.makeSequence: A convenience function for creating
xsd:sequence structures. Takes an object literal and an
ordered list of the keys, and returns an array that can be
passed as values to ol.xml.serialize.
* ol.xml.makeSimpleTypeWriter: Using e.g. the new write*TextNode
functions from ol.format.XSD, this function creates a node
writer that writes simple type nodes for values like strings
or numbers.
The following commits will be using this new framework for
implementing ol.format.GPX.writeFeatures, and prose
documentation with instructions based on what was said above
will be added.
The code to detect CSS transforms requires a DOM to append an
element to. By performing this action when first called instead
of unconditionally upon library load, we can load OpenLayers in
the document's head again.
Especially on mobile devices, loading just a single tile can
cause major janks. During animations, it is fine to just skip
frames. But during user interaction (e.g. dragging), a more
instant visual feedback is desirable.
By simply defining the ol3 map as control on a GMaps map, we can
have a Google base map with arbitrary ol3 content on top. This
works with all ol3 renderers.
Reusing the iterator in a nested loop is not a good idea. And in
this case it is better to not have nested loops at all, because
we only have to create one array.
This is another attempt to bring master closer to the
vector-api branch. In anticipation of the ability to keep track
of modifications on ol.Object through a beforechange event
(d7e4be0), we will be able to manage originals on the
application level or in a separate component outside of
ol.Feature.
This reduces the API footprint of versioned parsers, because
only the base parser needs to be exported as symbol, and
versioned parsers can be accessed using the getParser() method.
This change also adds some type annotations for better type
checking, introduces different write options for writing
transactions and queries, and provides new writeGetFeature and
writeTransaction methods.
Instead of setting a dummy namespace, we can have setter methods
for the featureNS property to propagate them to sub-parsers. The
srsName is also a property which needs to be propagated to
sub-parsers.
This is one more step to bring the master and vector-api
branches closer together. I am well aware that the current
Modify interaction will probably be rewritten as part of the
vector-api effort, but with changes like this we will eventually
be able to remove ol.structs.RTree from master.
By providing a segment even for points, we have less distinction
points between points and other geometry types, and are able to
do the segment distance calculation also for points.
ahocevar