@@ -145,7 +145,6 @@ journeys with 1, 2, 3 or more rides, walking between nearby stops for changes.
   - **Your trip**: once you start a trip, where you're up to (walk to the
     stop, the bus is 2 stops away, 4 stops to go), the rides ahead, when you'll
     get there, and End.
-  - **Train map**: the train diagram with every train on it, live.
   - **Search**: a search bar that opens straight into search.
 - **Quick settings tile**: "27H · 6 min" in the notification shade.
 - **App shortcuts**: long-press the icon for Directions, Live, Trains, Search
 
@@ -93,14 +93,5 @@
             <meta-data android:name="android.appwidget.provider" android:resource="@xml/favourites_widget" />
         </receiver>
 
-        <receiver
-            android:name=".system.TrainWidgetReceiver"
-            android:exported="true"
-            android:label="@string/train_widget_label">
-            <intent-filter>
-                <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
-            </intent-filter>
-            <meta-data android:name="android.appwidget.provider" android:resource="@xml/train_widget" />
-        </receiver>
     </application>
 </manifest>
@@ -295,7 +295,6 @@ class AppViewModel(app: Application) : AndroidViewModel(app) {
     private suspend fun refreshTrains() {
         try {
             val fresh = trainRepo.poll()
-            nz.aryan.akllive.system.TrainsNow.save(getApplication(), fresh)
             val old = _trains.value
             val elapsed = SystemClock.elapsedRealtime()
             // glide from wherever each marker is right now
 
@@ -19,7 +19,6 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.launch
 import nz.aryan.akllive.system.Glance
 import nz.aryan.akllive.system.Shortcuts
-import nz.aryan.akllive.system.TrainsNow
 import nz.aryan.akllive.ui.AklApp
 import kotlin.math.sqrt
 
@@ -57,7 +56,6 @@ class MainActivity : ComponentActivity(), SensorEventListener {
     override fun onStart() {
         super.onStart()
         vm.setVisible(true)
-        TrainsNow.appOpened(this)
     }
 
     override fun onResume() {
 
@@ -104,6 +104,8 @@ object Rail {
     private const val IN_M = 25.0            // rails this close and parallel are drawn as one track...
     private const val OUT_M = 40.0           // ...until they're this far apart
     private const val STEP_M = 20.0
+    private const val EASE_M = 200.0           // lines slide between slots over this far either side...
+    private const val EASE_STEPS = 10          // ...in this many steps
 
     val HUIA_STOPS = listOf(
         RailStation("The Strand", -36.84853, 174.77934, 1 shl HUIA, 1, true),
@@ -386,6 +388,12 @@ object Rail {
                 val run = at.subList(a, min(at.size, b + 2))
                 if (run.size > 1) out += RailPiece(g.line, ArrayList(run), w[slot], if (same) off else -off)
             }
+            // where lines meet and part, slide across between slots instead of stepping
+            if (out.size - first > 1) {
+                val eased = ease(out.subList(first, out.size).toList())
+                while (out.size > first) out.removeAt(out.size - 1)
+                out += eased
+            }
             if (g.line != HUIA) track[g.line] += DoubleArray(at.size) { at[it].x * KX } to DoubleArray(at.size) { at[it].y }
             for ((st, k) in g.stops) ends[st] += g.line to at[k]
             if (out.size > first && g.stops.isNotEmpty()) {
@@ -408,6 +416,65 @@ object Rail {
         return RailDrawing(out, markers, track)
     }
 
+    /**
+     * A line's pieces with the change in slot (offset and width) between one and the next
+     * spread over [EASE_M] either side, in [EASE_STEPS] little pieces, so a line glides
+     * across to its new place beside the others where they meet or part.
+     */
+    private fun ease(pieces: List<RailPiece>): List<RailPiece> {
+        val out = ArrayList<RailPiece>()
+        var cur = pieces[0]
+        for (i in 1 until pieces.size) {
+            val next = pieces[i]
+            val joined = metres(cur.coords.last(), next.coords.first()) < 1.0
+            val change = abs(cur.offset - next.offset) > 0.05 || abs(cur.width - next.width) > 0.05
+            val l = minOf(EASE_M, length(cur.coords) * 0.45, length(next.coords) * 0.45)
+            if (!joined || !change || l < 5) { out += cur; cur = next; continue }
+            val (keepA, tailA) = cut(cur.coords, length(cur.coords) - l)
+            val (headB, keepB) = cut(next.coords, l)
+            if (keepA.size > 1) out += RailPiece(cur.line, keepA, cur.width, cur.offset)
+            var rest: List<Pt> = tailA + headB.drop(1)
+            val step = length(rest) / EASE_STEPS
+            for (j in 0 until EASE_STEPS) {
+                val t = (j + 0.5) / EASE_STEPS
+                val split: Pair<List<Pt>, List<Pt>> = if (j == EASE_STEPS - 1) rest to emptyList() else cut(rest, step)
+                val (part, after) = split
+                rest = after
+                if (part.size > 1) out += RailPiece(cur.line, ArrayList(part), cur.width + (next.width - cur.width) * t,
+                                                    cur.offset + (next.offset - cur.offset) * t)
+            }
+            cur = RailPiece(next.line, ArrayList(keepB), next.width, next.offset)
+        }
+        out += cur
+        return out
+    }
+
+    private fun length(pts: List<Pt>): Double {
+        var d = 0.0
+        for (i in 1 until pts.size) d += metres(pts[i - 1], pts[i])
+        return d
+    }
+
+    /** A line cut [at] metres along it: the part before and the part after, both with the cut point. */
+    private fun cut(pts: List<Pt>, at: Double): Pair<MutableList<Pt>, MutableList<Pt>> {
+        val before = arrayListOf(pts[0])
+        var d = 0.0
+        for (i in 1 until pts.size) {
+            val seg = metres(pts[i - 1], pts[i])
+            if (d + seg >= at) {
+                val t = if (seg > 0) ((at - d) / seg).coerceIn(0.0, 1.0) else 0.0
+                val c = Pt(pts[i - 1].x + (pts[i].x - pts[i - 1].x) * t, pts[i - 1].y + (pts[i].y - pts[i - 1].y) * t)
+                before += c
+                val after = arrayListOf(c)
+                for (j in i until pts.size) after += pts[j]
+                return before to after
+            }
+            d += seg
+            before += pts[i]
+        }
+        return before to arrayListOf(pts.last())
+    }
+
     /**
      * Where a station's dot (or dots) go: its platforms on the lines showing. A
      * line's own ends there count once; lines on the same track share a dot.
 
@@ -1,7 +1,6 @@
 package nz.aryan.akllive.system
 
 import android.content.Context
-import androidx.glance.appwidget.GlanceAppWidgetManager
 import androidx.work.Constraints
 import androidx.work.CoroutineWorker
 import androidx.work.NetworkType
@@ -106,13 +105,6 @@ class WidgetWorker(ctx: Context, params: WorkerParameters) : CoroutineWorker(ctx
     override suspend fun doWork(): Result {
         Glance.fetch(applicationContext)
         NextBusWidget().updateAll(applicationContext)
-        try {
-            // the trains only when there's a train widget to show them
-            if (GlanceAppWidgetManager(applicationContext).getGlanceIds(TrainWidget::class.java).isNotEmpty()) {
-                TrainsNow.get(applicationContext, fresh = true)
-                TrainWidget().updateAll(applicationContext)
-            }
-        } catch (_: Exception) { }
         return Result.success()
     }
 }
@@ -100,154 +100,3 @@ class SearchWidget : GlanceAppWidget() {
 class SearchWidgetReceiver : GlanceAppWidgetReceiver() {
     override val glanceAppWidget: GlanceAppWidget = SearchWidget()
 }
-
-// ======================= the train map =======================
-
-/** The train network diagram with every train on it, live. */
-class TrainWidget : GlanceAppWidget() {
-    override val sizeMode = SizeMode.Exact
-
-    override suspend fun provideGlance(context: Context, id: GlanceId) {
-        val trains = TrainsNow.get(context)
-        val map = drawTrains(trains ?: emptyList())
-        provideContent { GlanceTheme { Body(context, map, trains) } }
-    }
-
-    @Composable
-    private fun Body(ctx: Context, map: Bitmap, trains: List<Train>?) {
-        Column(GlanceModifier.fillMaxSize().cornerRadius(24.dp).background(ColorProvider(Color(0xFF0B1220))).padding(10.dp)
-                   .clickable(open(ctx, "akllive://trains"))) {
-            Row(GlanceModifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically) {
-                Text("Ngā Tereina", GlanceModifier.defaultWeight(),
-                     style = TextStyle(color = ColorProvider(Color.White), fontWeight = FontWeight.Bold, fontSize = 14.sp))
-                Text(when {
-                    trains == null -> "Open the app first"
-                    else -> "${trains.size} running · ${Nz.time(TrainsNow.at)}"
-                }, style = TextStyle(color = ColorProvider(Color(0xFFB9C2CF)), fontSize = 11.sp))
-                Spacer(GlanceModifier.width(8.dp))
-                Text("↻", GlanceModifier.clickable(actionRunCallback<RefreshMore>()),
-                     style = TextStyle(color = ColorProvider(Color.White), fontWeight = FontWeight.Bold, fontSize = 18.sp))
-            }
-            Spacer(GlanceModifier.height(4.dp))
-            Image(ImageProvider(map), "Train map", GlanceModifier.fillMaxSize(), contentScale = ContentScale.Fit)
-        }
-    }
-}
-
-class TrainWidgetReceiver : GlanceAppWidgetReceiver() {
-    override val glanceAppWidget: GlanceAppWidget = TrainWidget()
-    override fun onEnabled(context: Context) { super.onEnabled(context); Glance.schedule(context) }
-}
-
-/** The latest trains, shared by the app and the widget. */
-object TrainsNow {
-    @Volatile var list: List<Train>? = null
-        private set
-    @Volatile var at = 0L
-        private set
-    private var lastWidget = 0L
-    private var repo: TrainRepo? = null
-
-    /** The app polled the trains: keep them, and redraw the widget now and then. */
-    fun save(ctx: Context, trains: List<Train>) {
-        list = trains
-        at = Nz.nowSec()
-        val now = System.currentTimeMillis()
-        if (now - lastWidget > 60_000) {
-            lastWidget = now
-            val app = ctx.applicationContext
-            CoroutineScope(Dispatchers.Default).launch { try { TrainWidget().updateAll(app) } catch (_: Exception) { } }
-        }
-    }
-
-    /** The app's been opened: a good time to draw the widget's map, with the internet sure to be there. */
-    fun appOpened(ctx: Context) {
-        val now = System.currentTimeMillis()
-        if (now - lastOpen < 10 * 60_000) return
-        lastOpen = now
-        val app = ctx.applicationContext
-        CoroutineScope(Dispatchers.Default).launch { try { TrainWidget().updateAll(app) } catch (_: Exception) { } }
-    }
-    private var lastOpen = 0L
-
-    /** Fetch and redraw in a job that waits for the internet. */
-    fun refresh(ctx: Context) {
-        val req = OneTimeWorkRequestBuilder<TrainWidgetWorker>()
-            .setConstraints(Constraints.Builder().setRequiredNetworkType(NetworkType.CONNECTED).build())
-            .build()
-        WorkManager.getInstance(ctx).enqueueUniqueWork("train-widget-refresh", ExistingWorkPolicy.REPLACE, req)
-    }
-
-    suspend fun get(ctx: Context, fresh: Boolean = false): List<Train>? {
-        if (!fresh && list != null && Nz.nowSec() - at < 60) return list
-        val s = Prefs(ctx).load()
-        if (s.apiKey.isBlank()) return list
-        val r = repo ?: TrainRepo(AtApi { Prefs(ctx).load().apiKey }).also { repo = it }
-        return try { r.poll().also { list = it; at = Nz.nowSec() } } catch (_: Exception) { list }
-    }
-}
-
-/** The post-CRL diagram and every train on it, drawn for the widget. */
-private fun drawTrains(trains: List<Train>): Bitmap {
-    val k = 2.4f
-    val w = (MapData.W * k).toInt()
-    val h = (MapData.H * k).toInt()
-    val bmp = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888)
-    val c = Canvas(bmp)
-    val line = Paint(Paint.ANTI_ALIAS_FLAG).apply { style = Paint.Style.STROKE; strokeWidth = 3.2f * k; strokeCap = Paint.Cap.ROUND; strokeJoin = Paint.Join.ROUND }
-    MapData.LINE_DRAW.forEachIndexed { li, pts ->
-        val p = Path()
-        for (i in 0 until pts.size / 2) {
-            val x = pts[i * 2] * k
-            val y = pts[i * 2 + 1] * k
-            if (i == 0) p.moveTo(x, y) else p.lineTo(x, y)
-        }
-        line.color = MapData.LINE_COLORS[li].toInt()
-        c.drawPath(p, line)
-    }
-    val dot = Paint(Paint.ANTI_ALIAS_FLAG)
-    val ring = Paint(Paint.ANTI_ALIAS_FLAG).apply { style = Paint.Style.STROKE; strokeWidth = 1.2f * k; color = 0xFF1A2744.toInt() }
-    val label = Paint(Paint.ANTI_ALIAS_FLAG).apply { color = 0xFFE6ECF5.toInt(); textSize = 6.5f * k; typeface = Typeface.DEFAULT_BOLD }
-    for (st in MapData.STATIONS) {
-        for (i in 0 until st.pts.size / 2) {
-            dot.color = 0xFFFFFFFF.toInt()
-            c.drawCircle(st.pts[i * 2] * k, st.pts[i * 2 + 1] * k, 2.2f * k, dot)
-            c.drawCircle(st.pts[i * 2] * k, st.pts[i * 2 + 1] * k, 2.2f * k, ring)
-        }
-        if (st.priority == 0) {
-            val tw = label.measureText(st.name)
-            val x = (st.x * k + st.dx * k).let { if (st.anchor == 'r') it - tw else if (st.anchor == 't' || st.anchor == 'b') it - tw / 2 else it }
-            c.drawText(st.name, x.coerceIn(2f, w - tw - 2f), st.y * k + st.dy * k + label.textSize / 3, label)
-        }
-    }
-    for (t in trains) {
-        val x = t.x * k
-        val y = t.y * k
-        dot.color = 0xFFFFFFFF.toInt()
-        c.drawCircle(x, y, 4.6f * k, dot)
-        dot.color = MapData.LINE_COLORS[t.line].toInt()
-        c.drawCircle(x, y, 3.4f * k, dot)
-        val late = t.delay ?: 0
-        if (late >= 120) {
-            dot.color = if (late >= 300) 0xFFE0412F.toInt() else 0xFFEFA20E.toInt()
-            c.drawCircle(x + 3.4f * k, y - 3.4f * k, 1.8f * k, dot)
-        }
-    }
-    return bmp
-}
-
-/** ↻ on the train widget: fetched in a job, which gets the internet even when the app's in the background. */
-class RefreshMore : ActionCallback {
-    override suspend fun onAction(context: Context, glanceId: GlanceId, parameters: ActionParameters) {
-        TrainsNow.refresh(context)
-    }
-}
-
-/** Fetches the trains and redraws the train widget. */
-class TrainWidgetWorker(ctx: Context, params: WorkerParameters) : CoroutineWorker(ctx, params) {
-    override suspend fun doWork(): Result {
-        TrainsNow.get(applicationContext, fresh = true)
-        TrainWidget().updateAll(applicationContext)
-        return Result.success()
-    }
-}