Maparoni is a file-based app. Each collection is a file, using the standard GeoJSON format.
New collections created in Maparoni are stored either in its iCloud Drive folder, or locally on the device. Maparoni can also directly work with files stored in any of the locations in your Files app, including Box, Dropbox, Google Drive or Working Copy. You can use those to collaborate on collections with others.
When working with files that can be modified externally – no matter if it’s by you or someone else – Maparoni will always show the latest content of the file and auto-save any changes you make it.
Each collection is a plain text file using the GeoJSON format. This means that Maparoni can work with files generated with other desktop, mobile and web apps supporting that format or can also be used to display data from the various web APIs using this format.
You can for example:
- Display your files with custom map styles using Mapbox
- Import files created with the Google’s Simple GeoJSON editor or HERE’s GeoJSON tool
- Use it with geojson.io or HERE XYZ Studio
- Work with maps create with Jsonbix
- Visualise results from the Mapbox API or the Pelias geocoder
GeoJSON is a fairly generic and flexible format. When working with GeoJSON files directly it’s good to understand how Maparoni is using them:
When creating and modifying files, Maparoni will always use the
FeatureCollection style at the top level. Each item added to a collection is
Feature in that collection.
The rich representations of GeoJSON files in Maparoni are based on three concepts:
- Configuration of the collection itself, which stores the name and description of the collection, but also defines the look of the collection and which fields are available - which brings us to:
- Property Schemas that define each field, which means in GeoJSON terms that they define what kind of value is expected for a certain property within the
propertiesfield of a GeoJSON
- Actions are a special kind of property schema, that define what action buttons should be available for a location and what should happen when you tap them.
As you see, these work together: The Configurations of the collections have a list of Property Schemas, and Actions are a special type of Property Schemas.
The configuration of the collection is stores in a top level
maparoni dictionary, which has the following notable key-value pairs:
schemasdefines the available fields and is stored as described below
pretty-printboolean that tells Maparoni to write the GeoJSON in pretty-printed form
When opening a file, Maparoni will use the property schema defined by the file, or, if none, a small default set of schemas to look for names, URLs, address, and phone numbers.
A Property Schema defines how certain
properties entries should be interpreted and what editing field should be available for them. Each schema is made up of:
keystring which will be matched against the key used in the
titlestring which will be used when as the title when presenting the matched property.
typewhich is one of
Additionally, Maparoni will always look for and use the following fields:
maparoni-pin-coloris of type
colorand will be used to colour map markers
maparoni-pin-letteris of type
textand will be used as the text inside map markers
Per-location actions are added through property schemas of the
action type, which require a separate
action string. This will turn them into buttons on each locations which then trigger actions specific to that location. In those action strings you can use the following placeholders which will then get filled in according to the values of each item:
For example, a deep-link to get a route in TripGo would have this schema:
"title": "Route in TripGo",