~mil/mepo

1.0 a day ago .tar.gz browse log

This release was focused on completing documentation and polishing
features to finalize the roadmap and address Milestone 6. In addition,
this release also added support for Plasma Mobile and alternative UI
environments by way of adding support for menuing to mepo's scripts via
zenity to address Milestone 8. A manpage documentation generator has been
added under a CLI flag and the markdown API documentation generator CLI
flag has been reworked to be more exhaustive. End-user documentation has
been moved to a separate repository mepo_website as part of the launch of
the new documentation website http://mepo.milesalan.com. Major features
changes in this release cycle are described below:

1. Mepo scripts customizable ENV variables
All ENV variables considered potentially privacy-concerning such as
URL endpoints connected to the default public instances of Nominatim,
Overpass, and GraphHopper have been updated to be user-customizable
rather then being hardcoded. These environment variables all start with
`MEPO_` and can be seen documented along with default values on the new
mepo documentation website's user guide or can be referenced from each
script directly.

In addition to URL endpoints and API keys now being customizable, a
number of feature-related ENV variables have been introduced such as
MEPO_USERPIN_ENABLED which allows for the enabling or disabling of the
default user pin location updating script. MEPO_USERPIN_ENABLED may be set
to 0 to disable the default user positioning pin dropping. Additionally,
a newly introduced  environment variable, MEPO_MENUING, allows for
customization of the menuing program (bemenu, dmenu, or zenity) used
for menuing and user input in scripts. The user may set MEPO_MENUING
to either inputbemenu, inputdmenu, or inputzenity to use bemenu, dmenu,
or zenity respectively.

2. Plasma Mobile & Alternative environments support: Zenity & OSK detection
Zenity has been added as a menuing/user input method for mepo's
scripts. Primarily the motivation behind adding zenity support is that
compatibility on Plasma Mobile is best with a proper separate window
rather then a dock menu. In addition, zenity is now used as a fallback
method where bemenu or dmenu is not available. As mentioned in (1),
the new MEPO_MENUING environment variable has been introduced to support
user customization of their preferred menuing method. Zenity is generally
the most UI platform cross-compatible menuing option and is additionally
used as the default in the newly added mepo flatpak.

In addition to changes made to support zenity, which is used for Plasma
Mobile..  testing has also taken place and minor changes have been made
in the Zig codebase similar to changes for Phosh to automatically hide
the onscreen keyboard when not necessary on Plasma Mobile.

These two changes (menuing support via zenity; and tweaks for Plasma
Mobile's OSK), makes Plasma Mobile a first-class supported target
for mepo. The 3 major mobile environments which mepo now supports
match postmarketOS's 3 major mobile UI environments of: Sxmo, Phosh,
and Plasma Mobile. Other environments will likely benefit as well from
zenity support too.

3. Manpage & Markdown API documentation generation
A new commandline flag -docman had been added to allow for the generation
of a manpage which covers all mepolang commands, preferences, commandline
flags, and the default config.  While the website is more exhaustive in
covering user guides, integrating images and demo videos; the manpage
can serve as a good entrypoint for beginner or advanced users who do
not wish to use the documentation website.

Packagers should use the manpage generator flag and save to a `.1` file
in the build process for the manpage to be distributed in documentation
packaging. For example: `mepo -docman > /usr/share/man/man1/mepo.1`. As
for end users, in distributions which documentation may not have been
properly installed, having the manpage doc be generated directly from
the binary now also allows direct viewing from mepo's CLI via man using
man's `-l` flag. For example to view the manpage directly from the mepo
CLI you can now simply run: `mepo -docman | man -l`.

In addition to the new -docman flag, the -docmd flag available in prior
versions of mepo which generates dynamic mepolang documentation has been
extended upon to include preference table generation, commandline flags
and the default config documentation to have parity with the generated
manpage. The markdown document generated from the -docmd commandline flag
is used in the build system for the new mepo documentation website and the
rendered result can be seen at http://mepo.milesalan.com/mepolang.html.

4. Documentation guides moved to mepo_website repository
All markdown-based documentation which previously resided
in the `doc/` folder has been moved to be hosted within the
new mepo_website repository. This repository is available at
http://sr.ht/~mil/mepo_website and is responsible for generating the
static site for http://mepo.milesalan.com

The new documentation mepo website at http://mepo.milesalan.com covers
an install guide, user guide, scripting guides, and more. Demo videos and
new screencasts have been created which are hosted at this site as well.
This new website is the official 'source-of-truth' for all things mepo
documentation rather then the previous `doc/` folder within the mepo
repository.

1.0_rc1 10 days ago .tar.gz browse log

Add 128x128 and 512x512 icons to install to build

1.0_rc0 11 days ago .tar.gz browse log

Typofix

0.5 a month ago .tar.gz browse log

This release was focused on polishing UI feature completeness including:
(1) a rework of the preference system and the introduction of save/restore
state, (2) interactive debugging via STDIN, (3) the introduction of an
async shellpipe variant (along with bookmarking and user positioning
shell scripts), and (4) several smaller miscellaneous features.

1. Preference system overhaul & introduction of save/restore state
The preference system has been reworked in order to support save/restore
state and internal state within the application now has a degree of
consistency not present in prior versions. 0.4 and prior versions of
mepo featured several separate commands for setting pingroup properties,
zoom-level, latitude/longitude and other preferences. As of this release,
all preferences can now be set with two commands: `prefset_n` and
`prefset_t`.

This consistency has paved the way for a new `filedump` command which
allows the user to save the current state of the application (zoom level,
latitude/longitude, pins, etc.) to an arbitrary file. In the new default
config, via a new `bind_quit` hook, the application's state is saved
on quitting and restored on boot. The net effect end-users will notice
is that closing the application and opening it back up will restore the
application positioning, pins, etc.

While save/restore state via `bind_quit` is the new default, this
functionality may be overridden by setting `bind_quit` to an empty
expression to nop.

2. Interactive debugging via STDIN
The main application loop has been reworked to handle reading mepolang
from STDIN continually rather then as a one-shot operation on boot as
was previously the case with prior versions. This serves two purposes:
1) to allow interactive debugging by end-users and 2) this allows for
scripting mepo non-interactively / without user interaction.

Mepolang expressions are parsed on newlines characters and commands can
be batched in this way. To test this functionality simply start mepo
using the `-i` commandline flag (e.g. `mepo -i`) and type any mepolang
expression into the console. For example: `prefset_n crosshair_size 40;`.
The `-i` STDIN debugging functionality can also be used by piping STDIN
into mepo on boot as well such as via: `echo "prefset_n crosshair_size
40" | mepo -i`.

3. Async shellpipe, user location script, and pin editing script
The command previously known as `shellpipe` has been renamed to
`shellpipe_sync`, and a new command, `shellpipe_async` has been added
to allow for running asynchronous shell commands. The `shellpipe_async`
command functions identically to shellpipe, in receiving particular ENV
vars to expose, and running any resulting STDOUT as mepolang.

The asynchronous version of shellpipe, `shellpipe_async`, was primarily
built out to support two new scripts included in the default config which
utilize this functionality, which are described below, these scripts are:
1) a user pin location updating script and 2) a pin editing script.

Firstly, the newly added user pin location updating script,
`mepo_ui_menu_user_pin_updater.sh`, drops a pin on the map based on
the user's location. The user's location is obtained either by GPSd,
Geoclue2, or Mozilla Location Services (in that order, moving from one
method to the next if the prior is unavailable). Note, if desired GPSd
and Geoclue2 are now optional dependencies for this script; meanwhile the
fallback to MLS works based on curl/jq so no additional dependencies are
necessary for this fallback method. Ideally on the Pinephone and other
mobile devices, if setup, you will get the best results with GPSd. In my
testing on the Pinephone on postmarketOS, GPSd may need to be manually
enabled via `sudo /etc/gpsd/device-hook "" ACTIVATE`. Note: while in the
background the user's location pin will automatically update via a new
`bind_timer` command in the default config; you may also press `x` or
click on the new UI button labeled `Center` to run this same script in
a synchronous fashion and also reposition the map on the user's location.

Secondly, the newly added pin editing script, `mepo_ui_menu_pin_editor.sh`
script allows for adding, removing, and editing pins location and
metadata by the user. This script can be used both for filtering and
editing existing searches (from Nominatim, Overpass, etc.) and also for
saving/restoring bookmark pins. This functionality uses the save/restore
state of the preference system mentioned above in (1).

4. Misc features: Visual tile progress indicators, -ndc & -h CLI flags,
   clipcopy/clippaste, and High-DPI cursor positioning bugfix

There are several miscellaneous but important features which have been
added in this release cycle which I'd like to mention in this section,
namely: visual tile progress indicators, two new CLI flags, the addition
of the `clipcopy`/`clippaste` mepolang commands, and the fix of a bug
related to high-DPI cursor positioning.

Firstly, tiles while loading now visually represent how much data has
been downloaded rather then just being a solid green color while loading
as with previous versions. With this change, the percentage and data in
kilobytes downloaded for each tile is shown and the background color
represents loading status where black is 0% loaded and white is 100%
and a gradient (of grays) indicates progress loading status.

Secondly, two new CLI flags have been added to the application. The
new `-ndc` flag allows you to run mepo without the 'default'
baked in mepolang configuration which automatically adds things such
keybindings/buttons/hooks for the bundled scripts and similar.  And the
new `-h` flag is a simple commandline help flag which shows the program
usage for all of the existing commandline flags.

Thirdly, two new commands have been added for environment-independent
clipboard access. The `clipcopy` command copies the current map's
coordinates to the clipboard; meanwhile, the `clippaste` command relocates
the map given coordinates in the clipboard, or alternatively if what's
in the clipboard is not coordinates.. will run the clipboard contents
as mepolang. This is a nice way to debug one-off mepolang expressions.
The `clipcopy` command is bound in the default config to the hotkey `y`
and the `clippaste` command is bound in the default config to the hotkey
`Shift-y`.

Finally, as of the 2.0.22 release of SDL it seems there was a regression
with High-DPI environments such as Phosh (which scales 1.5x by default)
where cursor positioning functionality would sometimes break. The root
cause of this issue is that it seems unscaled cursor positioning was
being reported in mouse motion events; this caused clicking on pins
and UI buttons in high-DPI environments to not function properly. As
of this release, this bug has been resolved via using properly scaled
coordinates based on the application's scaled resolution proportion.

0.4.2 4 months ago .tar.gz browse log

Fix issue causing commandline-based download mode (-d) to not work.

0.4.1 6 months ago .tar.gz browse log

Fix a minor bug relating to undefined colors for TTF_RenderText_Blended

0.4 6 months ago .tar.gz browse log

This release was focused on building out mobile support (for Phosh
and Sxmo primarily), which included switching to GPU-based rendering,
supporting HiDPI scaling, improving gesture support, handling UI-specific
quirks, and implementing clickable UI buttons support to complete the
4th Milestone (Wayland & Mobile Support). This release is built against
Zig 0.9.1. Major changes below:

1. GPU-based rendering & HiDPI support
In order to support mobile environments such as Sxmo (Sway/Wayland) and
Phosh, which both default to HiDPI scaling enabled at 2x, Mepo's default
SDL renderer has been switched to use GPU-based rendering (as opposed
to CPU/software-based rendering in 0.3 and earlier versions). GPU-based
rendering has better support for high DPI displays. No longer in the
underlying logic do we use the scaled window resolution but the true
pixel-based resolution based on getting the GL drawable size and scaling
coordinates similarly to the logical size.

The primary net effect users will notice is that resultingly,
on Phosh & Sxmo (Sway/Wayland), the UI now looks less blurry &
is high-quality/crisper.  With GPU-based rendering now the default,
end users may also notice a slight speed improvement depending on
system specifications. Software-based rendering, while no longer the
default, is still supported via the new `-sw` commandline flag. This
can be helpful for debugging or for use on systems with low amounts of
GPU memory. In addition to the change to support GPU-based rendering,
we also now default to using the Wayland SDL videodriver rather then
the X videodriver (e.g. mepo no longer uses XWayland by default). Note,
this can be overriden via using the SDL_VIDEODRIVER env variable.

2. Sxmo & Phosh support and UI improvements
Sxmo (both X & Wayland) & Phosh support has been implemented.

In regards to Sxmo, prior versions had broken functionality in regards
to scaling, hotkeys/context menu, and overall polish; in this release
each of these points has been addressed. The default included scripts
have each been flagged with a new $HOTKEY variable (correlating to the
default bind_key config setting). Also an associated change in Sxmo's
codebase for the mepo contextmenu hook has been added based on these
$HOTKEY variables.  As such Sxmo now generates its context menu (on
swipe down / volume up) identical to the menu presented by central menu
hold-click functionality (& in 0.4 the new UI menu button). Additionally,
quirks have been worked out to support SDL's text input system (which
is necessary for compatibility with wtype on Sway). There is one pending
change for Sxmo/dwm which has been merged into the sxmo-dwm codebase to
have mepo launch as tiled by default; this change will be included with
the next tagged version of sxmo-dwm which will be released in about a
weeks time from publishing these notes.

As for Phosh, this is the first release in which Mepo is now generally
usable in this environment; support involved several changes. Firstly,
the default backing menuing script now uses busctl on Phosh to launch
Squeekboard (the OSK) for text input. As such you no longer have to
manually open/close the keyboard when looking for POIs and similar.
Secondly, a desktop file and an exciting new icon (!) has been added.
As such, installing Mepo by default, you'll now see a nice new icon appear
on the launcher. Finally, Phosh UI-specific quirks have been resolved. A
performance issue has been examined which caused Mepo to operate very
slowly in Phoc while panning the map; this bug had to do with overhead
for updating the window title, which is now updated on a periodic
interval. Additionally the application's defaults have been setup so
that the OSK automatically hides on boot & during window management etc.

3. Gesture support improved: bind_gesture command & better defaults
Gesture support has been vastly improved and is now customizable based
on a new bind_gesture mepolang command. Using bind_gesture you can bind
1-n fingers for pinch & rotate gestures. By default 2-finger pinching
will zoom the map in & out; and 3-finger rotate will adjust the UI's
fontsize. Additionally gestures are now able to be disabled if desired
by the user - as gesture support is no longer hardcoded since all logic
goes through the new bind_gesture mepolang command.

With 2-finger pinch to zoom, delta tracking has been implemented
and as such you can only zoom at max 2 zoom levels in one continuous
gesture. This is to prevent behavior in prior releases where-in zooming
in and out was unbounded and thus it was easy to zoom to the max/min zoom
level.  Defaults for gestures have been tested and are known to work well
on the Pinephone and the Motorola G4 Play (motorola-harpia). Additional
devices may require minor tweaking; however delta tracking should provide
a good baseline overall for cross-device support.

The last point to mention on gestures, is that while in previous versions
gestures often conflicted with panning.. causing the user to inadvertently
zoom in out while panning; this bug has been resolved. While using
two/three finger gestures, and double/triple tapping, the map is now fixed
in place and won't pan around; which feels more reliable in practice.

4. UI Buttons: bind_button command
Clickable graphical UI buttons have been implemented aligned to the
bottom right corner to provide easy to hit targets on mobile devices,
where keybindings are not available. Buttons can be arbitrarily added
via the new bind_button mepolang command and can execute arbitrary
mepolang code. As such if you want to create your own custom script
(say to reposition the map to a particular coordinate, search the map,
resolve bookmarks, or anything else you can think up); this is as simple
as placing the associated mepolang code in the bind_button command's
eval argument.

UI buttons have been added to default config to allow you to: launch
the central menu, relocate the map via Nominatim, search for POIs via
Nominatim or Overpass, and download all tiles in all zoom levels in
the current viewport. These buttons use the same scripts accessible via
keybindings and in the central menu. If you want a bare UI
or want to remove these buttons, this is feasible by using a custom
configuration since this functionality is completely built out through
the mepolang configuration system.

5. Misc UI improvements
A few additional miscellaneous polishing UI improvements not covered
above have been implemented which I'll mention here (note this is a
nonexhaustive list): 1) In the central menu, scripts labels have had
icons added. 2) The UI bottom bar now changes color while download tiles
(e.g. green for foreground downloading tiles or blue for background/queued
downloading tiles); the bar turns red while offline as was previously
implemented. 3) The Nominatim POI search script no longer provides
suggestions (which required an additional network call); this speed things
up substantially while launching this script. 4) A script has been added
to the central menu to drop a custom user pin arbitrarily on the map. And
5) STDERR debugging has been disabled by default to improve performance;
this debugging functionality is still available now through a new `-e`
commandline flag.

0.3 7 months ago .tar.gz browse log

This release was focused on extending pin functionality to complete the
3rd Milestone (Powerful, Robust Pin API) and additionally improving the
overall UI to expand mobile compatibility. Major changes below:

1. Pin groups implemented and ordered pin groups now supported
The pin system has been reworked to allow multiple pin groups rather then
always having pins placed within a single group. Each pin group may be
either ordered or unordered. Ordered pin groups support the concept of
'structural' pins which have no handle/title but allow curved / multiple
point paths in segments between instructive pins.  This is relevant for
routing support covered in these notes later on. Ordered pin groups are
rendered with connecting lines between each pin (thus allowing simple
routing).

In the default configuration, 10 pin groups may be accessed using the
hotkeys 0-9. The scripts for searching POI searches (e.g. Nomininatim
and Overpass scripts) have been updated to drop POI pins into pin group 1
(and are indicated in blue). Routing is reserved for pin group 2 in the
default configuration (and indicated in green).

2. Pin UI rework, metadata table, and click to activate support
In addition to now supporting multiple groups & ordered pin groups;
the way data (such as pin title, lat, lon, etc.) is displayed for the
currently selected pin has been reworked and the overlay for this data
has been moved to the top left of the screen and this data appears in a
table format. A new mepolang command has been added to allow attaching
arbitrary metadata to pins; and this metadata is rendered in the table
alongside the previous mentioned rudimentary pin data.

Additionally, pins rendered on the map now show up with a label (e.g. the
pin name) for all pins in the active group. This makes it easy to discern
different pins within a group and quickly identify different POIs. The
videos on the README are now a bit out of date and things looks quite a
bit more user-friendly. To get a sense of what the new overall UI looks
like, see these two screenshots:
- POIs: http://media.lrdu.org/mepo_demos/mepo_demo_0.3_pois.png
- Routing: http://media.lrdu.org/mepo_demos/mepo_demo_0.3_routing.png

In conjunction with these visual updates, click to activate has been added
for pins; clicking a pin will activate that pin (and its group). This
is particularly helpful on mobile where cycling between pins using the
p/n hotkeys is not easily accessible.

3. Initial routing support and public transit overlays improved
Since adding pin groups and the ordering capability to pin groups, the
ability to effectively route a trip within mepo is now possible. While
initially planned for a subsequent milestone, within this release,
I've added an initial routing script using GraphHopper which allows you
to route via car, bike, or walking. The GraphHopper script is built in
such as way that you can route between two points either taken from a
Nominatim lookup or via the cursor or centerpoint. In the latter option,
you don't need to enter (any) information to establish a route; simply
drag the centerpoint of the screen to the origin location; and then hold
the mouse (or your finger) on the destination location until the central
menu appears and you can route directly from 'centerpoint' to 'cursor'.
This pattern works equally well on mobile and desktop! There's room for
improvement (for example, routing directly to/from specific pins etc.),
but the current implementation can already handle a wide variety of
usecases and works well on the go on the Pinephone in my testing.

In addition to the GraphHopper script, the route via public transit /
via a specific OSM relation id script has been improved to load pins
properly into an ordered pin group. This script can be used for showing
the stops in a subway route, a metro, or similar. This script is not
fully complete as in the future I plan to build in functionality so that
the user can search their viewport for available public transit relations
(via Overpass or similar); but even in its current state it proves useful
by entering in your OSM relation id manually.

4. Mobile UI improvements: bind_click command and central menu implemented
Mobile UI compatibility has been greatly improved in this release by
the addition of a bind_click command paired which has been paired with a
new 'central menu' feature.  The new bind_click command allows binding
a given number of mouse clicks to run mepolang code. You can bind 1-n
number of successive clicks to execute arbitrary mepolang using this
command. And additionally, particularly relevant for the mobile context,
you can bind a 'hold' click which automatically dispatches after the
user has held down their cursor (on desktop) or finger (on mobile)
for a given threshold duration.

As previously mentioned, this new hold feature of bind_click, is paired
with a newly built 'central menu' script. The concept of the central
menu is a single menu script (e.g. via dmenu, bemenu, etc.) which allows
launching many other mepo scripts. While on desktop many of these same
scripts are available in the central menu via keybinding; on mobile you
don't need to remember any keybindings now and you can simply hold your
finger down on the map to launch the central menu. From this menu you
can access routing, POI searches, and other scripts.

And as mentioned in the previous section, with routing now added via a
GraphHopper script; you can hold your finger down to initially launch
the central menu and this point becomes the 'cursor' position and as such
can be used in conjunction with the 'center' point to route between two
locations on the map without any typing or user input at all.

5. Misc UI Improvements: shellpipe responsiveness and bottom bar reworked
A longstanding annoyance with the shellpipe command (which effectively
launches all scripts) was that it provided no visual indication that it
is running. This has been changed and now when shellpipe is running,
there is a visual debug message so the user knows the UI is blocked
on whatever script shellpipe is currently executing. Additionally the
UI updates once the script returns (while mepolang code is executing
as a result of the script) so it is clear to the user whether the shell
script from shellpipe is running or produced mepolang code is executing
as a resultant from the shellpipe.

In regards to visual appearance, the bottom bar has been reworked to
incorporate latitude/longitude, and is less verbose; but provides more
debug information about the current application state. A single letter
indicates: O = online/offline, Q = number of UI tiles queued, B = number
of background tiles queued, D = number of currently downloading transfers,
and M = number of tiles loaded to memory. Additionally, the bottom bar
also now appears with a red background when the application is operating
in offline mode; and is white when online.

6. Userguide
A initial userguide written in markdown has been added to
the git repository and also available rendered online at:
https://git.sr.ht/~mil/mepo/tree/HEAD/doc/userguide.md . This guide
will be expanded on over time and is not currently complete but serves
as a good starting point for new users to get acquainted with the UI's
basic functionality even in its current state.

0.2 9 months ago .tar.gz browse log

This release centered around completing the second Milestone (Offline
Mode & Noninteractive Downloading). Major changes below:

1. Commandline-based downloading
Commandline-based (non-interactive) downloading has been added, exposed
under the `-d` commandline flag. Using this flag, you can pass a
bounding-box for mepo to download noninteractively. Under the hood, the
noninteractive downloading mode reuses mepo's core tile cache curl logic in
a single-threaded and simple way to download tiles to the filesystem.

Also - in addition to the new -d downloading comandline flag for
noninteractive downloading, a TUI/prompt-based style downloading script
has been added to the scripts directory allowing the user to interactively
search for a target to download via Nominatim (e.g. for instance if you
want to download all tiles for a city). You can search for any target
using this new prompt-driven mepo_dl.sh script. The mepo_dl.sh script
just passes off / is a wrapper for mepo -d; however is a nice convenience
for users who don't wish to manually lookup the bounding box of their
target city or download area.

2. Performance improvements & concurrency / datastructure rework
Performance has been re-examined and regular hangups notable in the
initial 0.1 release are no longer present; overall the application
is substantially "smoother" in normal operation. Locking has been
moved to be on a more granular level - operating at the underlying
hash map datastructure layer rather then in the higher level tile
cache abstraction layer. Additionally, downloading logic now uses
curl_multi_poll properly rather then a hardcoded timeout in between
download processing intervals. The net effect is that tiles are requested
instantly as transfers complete and room becomes available based on
the transfers limit.. rather then waiting for 50 milliseconds as was
previously the case with the old hardcoded delay logic. While I think there's
still a bit of room for improvement in performance; overall, I'm happy
with where things are, having been testing on the Pinephone. The UI is
generally quite responsive now in normal usage and quite a bit faster
then other OSM clients generally.

3. Offline mode
A new 'offline mode' has been implemented which is accessible via
the preference named `tile_cache_network`. Toggling this preference
between `0`/`1` terminates and respawns the downloading thread. While
the `tile_cache_network` preference is set to `0`, mepo runs entirely
offline and there is no downloading thread. While offline, in the UI
you'll see missing tiles show up as a red square with text indicating
that you're offline.  The rationale behind the offline mode is that if
you're on-the-go, have a limited dataplan cap, or simply have privacy
concerns on your current network, and/or wish to not use bandwidth,
you can opt to use the offline mode to ensure no bandwidth is used.
Tiles are still pulled from the filesystem while in offline mode; but
no network requests are made.

4. Tile queuing improvements
Tile queuing has been reworked to be an asynchronous operation rather
then blocking. In 0.1 and earlier versions, if you tried to queue a
large bounding box for downloading (via the `cache_dlbbox` command)
you'd notice the entire UI would freeze up until the queuing operation
completed. This is no longer the case, and queuing runs in a background
thread and as such you'll notice the `cache_dlbbox` command now returns
instantly. You'll notice while queuing, the number of tiles in the queue
will be increasing as noted in the download bar. Also, in addition to
be made async; the underlying datastructure logic responsible for tile
queuing has been separated into two separate queues: one queue for
background tile downloads & another queue for UI tile downloads. In the
former case tiles are saved to the filesystem and in the latter case tiles
are loaded to SDL textures (and optionally cached in the filesystem). This
results is a net speed gain in UI responsiveness due to less locking.

Also, in addition to this change for asynchronous bounding box queuing,
two new commands related to queuing have been added: `cache_dlradius` and
`cache_queueclear`. The former command is a new variant for queuing which
allows you to simply specify a single lat/lon coordinate with zoom-levels
rather then a bounding-box to download. The latter command allows you to
purge the queue wholesale if you wish to cancel an in-progress queuing
operation.  Hotkeys have been added for both of these operations and
you can refer to the default config for usage information. The queuing
script (mepo_script_queuedownload.sh) also now supports queuing the
current bounding box you're viewing without prompting. See the default
configuration & scripts for usage.

5. Miscellaneous features: Signal binding, preftoggles, and tile expiry
There were a number of other miscellaneous features added in this release
which I'd like to mention here. For full updates check the git log
ofcourse.

Firstly, thanks to Julian Samaroo (~jpsamaroo), mepo supports a new
`bind_signal` command. This command allows you to run arbitrary mepolang
code when a USR1/USR2 signal is sent to mepo. By default USR1/USR2 are
bound to zoom in/out to demonstrate this functionality. One potential
usecase for this new `bind_signal` command is to enable long-running
scripts which interface with mepo, such as repositioning your pin
location on the map. Eventually `shellpipe` will have an async variant;
but this is a nice intermediate in the short term that should allow for
the concept of 'long-running' mepolang scripts to be feasible.

Secondly, a small but important feature added in this release is a new
`preftoggle` mepolang command.  What this does it bitflip boolean (0/1
number) preference values. This preftoggle command has been applied to
many hotkeys - check out the default config to see the new defaults or
press / to bring up the help menu showing these hotkeys. Using a toggle on
1 hotkey is more convenient then having 2 hotkeys for on/off (for setting
such as hiding/showing the download bar) as was the case prior.

Thirdly, a new tile expiry preference has been implemented named
`tile_cache_expiry_seconds`. Set by default to 1 month (2592000 seconds),
this setting allows you to specify how long a tile should be considered
'valid' data after downloading. Tiles aged over this interval are
set to download if requested again. This is helpful in that using this
preference, old downloaded data can be automatically invalidated without
user intervention to make sure you always have the latest OSM tiles.
If you want to disable this feature simply set this preference to `-1`.

6. Crash on boot related to 'glyph not found' fixed
Finally, there was a bug in 0.1 wherein the combination of the latest
versions of freetype/SDL_ttf caused mepo to crash with a message like
"glyph not found". The root cause of this issue is that bitmap font
support in freetype/SDL_ttf's latest version are defacto broken. Many
users flagged this to me and ~anjan opened ticket #10 to track this. As
this was a pretty blaring issue for the first release, in this release
I've opted to resolve this issue by switching to a scalable font rather
then using a bitmap font by default. As a result, this crash is no
longer present.

0.1 10 months ago .tar.gz browse log

Initial 0.1 release

Covers basic tile downloading, rendering, text display, & initial build
out of mepolang. Stability is expected in normal usage; existing bugs with
the mepolang parser crashing by passing invalid arguments (e.g. string for
number etc.) are known and to be addresses later on. Milestone 1 complete.

Branches

test-rand-ids-for-sdl-threadname
move-sdl-user-eventtypes-to-utilsdl
initialization-threading-rework
mepolang_errorhandling
keydown-textinput-rework
text-cache-experiment-2
text-cache-experiment
f/wip-table-rendering
scripts-rework-and-central-menu
linkedlist-backed-queuemap
cache-dir-hierarchy
tile-loading-experiment