@legios/quartermaster 0.1.4 → 0.1.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/bin/qm-tray.ps1 CHANGED
@@ -22,9 +22,15 @@ Tres cosas que Windows hace distinto y conviene saber antes de leer el código:
22
22
  de batería), y el detalle va al tooltip y al menú.
23
23
 
24
24
  · No hay FileMonitor. El indicador de GNOME se entera en el acto porque vigila
25
- cada .claude.json con Gio.FileMonitor; desde Windows esos archivos están del
26
- otro lado del 9P de WSL, donde FileSystemWatcher no es confiable. Acá el
27
- sondeo es el mecanismo principal, no la red de seguridad.
25
+ cada .claude.json con Gio.FileMonitor; desde Windows esos archivos pueden
26
+ estar del otro lado del 9P de WSL, donde FileSystemWatcher no es confiable.
27
+ Acá el sondeo es el mecanismo principal, no la red de seguridad.
28
+
29
+ · Hay DOS lugares donde puede vivir qm, y la bandeja anda con los dos. En
30
+ Windows nativo corre `qm.cmd` (el que instala el instalador); desde WSL
31
+ corre `qm` adentro de la distro, que es como nació esto. La elección se
32
+ hace una sola vez en ResolverQm y no se repite en cada llamada — si no,
33
+ son tres lugares que pueden discrepar.
28
34
 
29
35
  · El calentado no puede bloquear. En macOS el refresco del endpoint va en una
30
36
  cola aparte; acá el timer corre en el hilo de la interfaz, así que
@@ -35,8 +41,17 @@ Tres cosas que Windows hace distinto y conviene saber antes de leer el código:
35
41
 
36
42
  [CmdletBinding()]
37
43
  param(
44
+ # Ruta de `qm.cmd`, el lanzador NATIVO de Windows. Vacío = se busca solo: al
45
+ # lado de este archivo primero (que es como lo deja el instalador) y en el
46
+ # PATH después. Ver ResolverQm.
47
+ [string]$Qm = '',
48
+
38
49
  # Ruta de `qm` ADENTRO de WSL. Por defecto se resuelve por PATH en un shell
39
50
  # de login, que es donde vive ~/.local/bin.
51
+ #
52
+ # PASARLO ES ELEGIR WSL: es lo que hace el lanzador bin/qm-tray, y es lo que
53
+ # distingue «vengo de WSL» de «me arrancó el instalador». Sin él, la bandeja
54
+ # prefiere el qm nativo si lo encuentra.
40
55
  [string]$QmLinux = 'qm',
41
56
  # Distro de WSL. Vacío = la default.
42
57
  [string]$Distro = '',
@@ -44,12 +59,65 @@ param(
44
59
  [int]$Segundos = 30,
45
60
  [int]$Puerto = 7391,
46
61
  # Con esto no se le pide nada al endpoint: sólo se lee lo que haya en disco.
47
- [switch]$SinCalentar
62
+ [switch]$SinCalentar,
63
+
64
+ # Con esto la bandeja NO se relanza cuando el .ps1 cambia debajo.
65
+ #
66
+ # El reinicio automático existe para el caso del usuario —`git pull` o un
67
+ # gestor de paquetes reemplazan el archivo y si no, seguís con el código viejo
68
+ # para siempre— pero es hostil justo para quien está EDITANDO el archivo: cada
69
+ # guardado relanza la bandeja, y la relanza con el trabajo a medio hacer. El
70
+ # parseo previo atrapa un archivo roto; no atrapa uno que parsea y todavía no
71
+ # está terminado, que es la forma normal de un archivo mientras se lo escribe.
72
+ [switch]$SinAutoReinicio,
73
+
74
+ # Qué íconos poner en la bandeja, separados por coma.
75
+ #
76
+ # (vacío) el general MÁS uno por cuenta — lo que se ve por defecto
77
+ # general sólo el general, con todas las cuentas adentro
78
+ # main,codex sólo esas dos cuentas, sin general
79
+ # general,codex el general y codex
80
+ #
81
+ # El general lleva la marca de quartermaster y su panel es el de siempre:
82
+ # todas las cuentas, con la cabecera de lo primero que te frena. Los de cada
83
+ # cuenta llevan el glifo de su producto y su panel muestra ESA cuenta sola.
84
+ # Con cuatro cuentas en una barra de tareas angosta, cuatro paneles completos
85
+ # es cuatro veces la misma pantalla; el que importa es el que se abrió.
86
+ [string]$Iconos = '',
87
+
88
+ # ── el modo del gate ──────────────────────────────────────────────────
89
+ # Dibuja contra un JSON fijo, escribe el PNG y sale, sin bandeja ni menú ni
90
+ # bucle de mensajes. Es el equivalente de `--desde` y `--captura` en
91
+ # bin/qm-indicator, y existe por la misma razón: con una entrada fija lo que
92
+ # sale es comparable entre corridas y entre máquinas, así que se puede medir
93
+ # en CI. Sin esto, de las 1200 líneas de este archivo el CI comprobaba UNA
94
+ # función —la escalera de duración— y un error de dibujo en cualquier otra
95
+ # pasaba en verde.
96
+ [string]$Desde = '',
97
+ [string]$Captura = '',
98
+ # Cuál panel dibujar: 'general' o el nombre corto de una cuenta. Es la forma
99
+ # de comprobar, sin bandeja, que el ícono de una cuenta muestra ESA cuenta.
100
+ [string]$Panel = '',
101
+ # El tema es una lectura del registro, y en un runner de CI no está el que
102
+ # uno quiere comprobar. En modo captura se fuerza a mano.
103
+ [switch]$Oscuro,
104
+ [switch]$Claro
48
105
  )
49
106
 
50
107
  Set-StrictMode -Version Latest
51
108
  $ErrorActionPreference = 'Stop'
52
109
 
110
+ # ¿Pidieron explícitamente el qm de adentro de WSL? Se captura ACÁ, al nivel
111
+ # del script, y no adentro de ResolverQm: en una función $PSBoundParameters es
112
+ # el de la función, así que allá esta pregunta siempre daría «no».
113
+ $script:PidieronQmLinux = $PSBoundParameters.ContainsKey('QmLinux')
114
+
115
+ # El directorio donde vive este archivo, que es también donde el instalador
116
+ # deja qm.cmd. Va en una variable en vez de usar $PSScriptRoot directo por una
117
+ # razón concreta: así el gate puede apuntarlo a un directorio de mentira y
118
+ # comprobar la resolución entera sin instalar nada ni tener WSL.
119
+ $script:MiBin = $PSScriptRoot
120
+
53
121
  Add-Type -AssemblyName System.Windows.Forms
54
122
  Add-Type -AssemblyName System.Drawing
55
123
 
@@ -89,6 +157,38 @@ public static extern bool SetProcessDPIAware();
89
157
  # Sin esto Windows estira el mapa de bits del menú y todo sale borroso.
90
158
  try { [Qm.Nativo]::SetProcessDPIAware() | Out-Null } catch { }
91
159
 
160
+ # Que una excepción en el hilo de la interfaz NO mate la bandeja.
161
+ #
162
+ # Por defecto WinForms le muestra al usuario el cartel morado de «Unhandled
163
+ # exception has occurred in your application», y si aprieta Quit —o si el cartel
164
+ # aparece con la máquina bloqueada y nadie lo ve— la bandeja desaparece. Una
165
+ # bandeja muerta no deja ícono, y un ícono que no está se lee exactamente igual
166
+ # que una cuenta que va bien: es el silencio del que habla la primera sección
167
+ # del README, con otra causa.
168
+ #
169
+ # Así que se atrapa, se sigue andando con lo que había, y se DICE: una línea a
170
+ # stderr siempre —que es lo único que explica por qué un tick no actualizó— y un
171
+ # globo la primera vez, para que el usuario se entere sin tener que ir a buscar
172
+ # un log. Una sola vez: un repintado que falla lo hace muchas veces seguidas.
173
+ #
174
+ # Va acá arriba de todo a propósito: SetUnhandledExceptionMode se niega a correr
175
+ # una vez que existe la primera ventana del hilo.
176
+ [System.Windows.Forms.Application]::SetUnhandledExceptionMode(
177
+ [System.Windows.Forms.UnhandledExceptionMode]::CatchException)
178
+ $script:AvisoTropiezo = $false
179
+ [System.Windows.Forms.Application]::add_ThreadException({
180
+ param($quien, $ev)
181
+ [Console]::Error.WriteLine("[qm-tray] $($ev.Exception.GetType().Name): $($ev.Exception.Message)")
182
+ [Console]::Error.WriteLine($ev.Exception.StackTrace)
183
+ if (-not $script:AvisoTropiezo) {
184
+ $script:AvisoTropiezo = $true
185
+ try {
186
+ Globo 'quartermaster' ("la bandeja tropezó dibujando y sigue andando con lo anterior: " +
187
+ $ev.Exception.Message) $false
188
+ } catch { }
189
+ }
190
+ })
191
+
92
192
  # El texto del item que refresca. Está en una constante porque lo comparan el
93
193
  # handler que cancela el cierre y el que pone «Actualizando…», y un literal
94
194
  # repetido en tres lados es un renombre que rompe dos de ellos en silencio.
@@ -172,6 +272,10 @@ function BarraOscura {
172
272
  #
173
273
  # Se relee en cada tick, igual que el de la barra de tareas.
174
274
  function TemaAppsOscuro {
275
+ # Forzado desde la línea de comandos: el gate tiene que poder pedir los dos
276
+ # temas en una máquina que no es la de nadie.
277
+ if ($Oscuro) { return $true }
278
+ if ($Claro) { return $false }
175
279
  try {
176
280
  $v = Get-ItemProperty -ErrorAction Stop -Name AppsUseLightTheme `
177
281
  -Path 'HKCU:\SOFTWARE\Microsoft\Windows\CurrentVersion\Themes\Personalize'
@@ -179,6 +283,11 @@ function TemaAppsOscuro {
179
283
  } catch { return $false } # sin la clave, claro: es lo que hacía antes
180
284
  }
181
285
 
286
+ # Un menú por ícono de la bandeja, indexado por la misma clave que el ícono:
287
+ # 'general' y el nombre corto de cada cuenta. Se declara acá arriba porque
288
+ # AplicarTema lo recorre y puede correr antes de que exista ninguno.
289
+ $script:Menus = [ordered]@{}
290
+
182
291
  # Los tonos del menú de Windows 11 en oscuro. En claro se siguen usando los del
183
292
  # sistema, que ahí sí son los correctos.
184
293
  $script:MenuOscuro = $null
@@ -211,23 +320,30 @@ function AplicarTema {
211
320
  $script:Tinta2 = Mezclar $script:Tinta $script:Fondo 0.38
212
321
  $script:Tinta3 = Mezclar $script:Tinta $script:Fondo 0.58
213
322
  $script:Pista = Mezclar $script:Fondo $script:Tinta 0.14
214
- if ($null -ne $script:Menu) {
215
- $script:Menu.BackColor = $script:Fondo
216
- $script:Menu.ForeColor = $script:Tinta
217
- if ($oscuro) {
218
- [QmTabla]::Fondo = $script:Fondo
219
- [QmTabla]::Resalte = Mezclar $script:Fondo $script:Tinta 0.12
220
- [QmTabla]::Borde = Mezclar $script:Fondo $script:Tinta 0.22
221
- $script:Menu.Renderer = New-Object System.Windows.Forms.ToolStripProfessionalRenderer((New-Object QmTabla))
222
- } else {
223
- # De vuelta al de fábrica: la tabla oscura sobre un menú claro se ve
224
- # igual de mal que al revés.
225
- $script:Menu.RenderMode = [System.Windows.Forms.ToolStripRenderMode]::ManagerRenderMode
226
- }
323
+ if ($oscuro) {
324
+ [QmTabla]::Fondo = $script:Fondo
325
+ [QmTabla]::Resalte = Mezclar $script:Fondo $script:Tinta 0.12
326
+ [QmTabla]::Borde = Mezclar $script:Fondo $script:Tinta 0.22
227
327
  }
328
+ # Ahora hay un menú POR ÍCONO, así que el tema se aplica a todos: con uno
329
+ # solo actualizado, abrir otro ícono te daba el panel del tema anterior.
330
+ foreach ($mn in @($script:Menus.Values)) { VestirMenu $mn $oscuro }
228
331
  return $true
229
332
  }
230
333
 
334
+ function VestirMenu($mn, [bool]$oscuro) {
335
+ if ($null -eq $mn) { return }
336
+ $mn.BackColor = $script:Fondo
337
+ $mn.ForeColor = $script:Tinta
338
+ if ($oscuro) {
339
+ $mn.Renderer = New-Object System.Windows.Forms.ToolStripProfessionalRenderer((New-Object QmTabla))
340
+ } else {
341
+ # De vuelta al de fábrica: la tabla oscura sobre un menú claro se ve
342
+ # igual de mal que al revés.
343
+ $mn.RenderMode = [System.Windows.Forms.ToolStripRenderMode]::ManagerRenderMode
344
+ }
345
+ }
346
+
231
347
  # ── formato ─────────────────────────────────────────────────────────────
232
348
 
233
349
  function Corto([string]$nombre) {
@@ -259,6 +375,42 @@ function Dur([int]$segundos) {
259
375
  return "${segundos}s"
260
376
  }
261
377
 
378
+ function CuentaRegresiva([double]$segundos) {
379
+ # Como Dur, pero sin tirar los segundos abajo de la hora.
380
+ #
381
+ # Dur habla de duraciones que se REPORTAN —«reinicia en 2d14h»— y ahí los
382
+ # segundos son ruido. Esto es un reloj que baja a la vista: si dijera sólo los
383
+ # minutos cambiaría una vez por minuto, y una cuenta regresiva que no se mueve
384
+ # no parece una cuenta regresiva, parece un número roto. Es cuenta_regresiva()
385
+ # de bin/qm-indicator, y por eso NO entra en el gate de duraciones: es otra
386
+ # escalera a propósito.
387
+ $seg = [int][math]::Max(0, $segundos)
388
+ if ($seg -ge 3600) { return (Dur $seg) }
389
+ if ($seg -ge 60) { return ('{0}m {1:d2}s' -f [int][math]::Floor($seg / 60), ($seg % 60)) }
390
+ return "${seg}s"
391
+ }
392
+
393
+ function CadaCuanto($historia) {
394
+ # Cada cuánto se lee la cuota DE VERDAD, en segundos.
395
+ #
396
+ # No es la cadencia que este programa se propone: es la MEDIDA. El historial
397
+ # se indexa por `medidoEn` —el instante que informa el servidor, no el momento
398
+ # en que qm miró el disco— así que los huecos entre muestras son intervalos
399
+ # entre lectura y lectura reales. Va la MEDIANA y no el promedio: una sola
400
+ # pausa larga (la máquina suspendida) desplaza el promedio y no dice nada del
401
+ # ritmo normal. Es cada_cuanto() de bin/qm-indicator.
402
+ $ts = @(@($historia) | ForEach-Object { [double]$_.t } | Sort-Object)
403
+ if ($ts.Count -lt 2) { return $null }
404
+ $huecos = @()
405
+ for ($i = 1; $i -lt $ts.Count; $i++) {
406
+ $d = $ts[$i] - $ts[$i - 1]
407
+ if ($d -gt 0) { $huecos += $d }
408
+ }
409
+ if (-not $huecos.Count) { return $null }
410
+ $huecos = @($huecos | Sort-Object)
411
+ return $huecos[[int][math]::Floor($huecos.Count / 2)] / 1000
412
+ }
413
+
262
414
  function Faltan($iso) {
263
415
  if (-not $iso) { return $null }
264
416
  try { $cuando = [datetimeoffset]::Parse($iso) } catch { return $null }
@@ -273,6 +425,17 @@ function AlMinuto($iso) {
273
425
  try { return ([datetimeoffset]::Parse($iso)).ToString('yyyy-MM-ddTHH:mm') } catch { return $iso }
274
426
  }
275
427
 
428
+ function Reinicio($segundos) {
429
+ # «reinicia en vencido» no es castellano. Cuando ya pasó, se dice que pasó.
430
+ #
431
+ # Es reinicio() de bin/qm-indicator. Se ve en cuanto se mira una captura con
432
+ # una ventana ya reiniciada —el fixture tiene tres— y no se ve leyendo el
433
+ # código, que es por lo que sobrevivió acá después de estar arreglado allá.
434
+ if ($null -eq $segundos) { return '' }
435
+ if ($segundos -lt 0) { return 'reinicio vencido' }
436
+ return "reinicia en $(Dur $segundos)"
437
+ }
438
+
276
439
  function NombreVentana($v) {
277
440
  if ($v.nombre) { return $v.nombre }
278
441
  if ($v.alcance) { return "$($v.clave) ($($v.alcance))" }
@@ -284,7 +447,11 @@ function FraseRitmo($p) {
284
447
  if (-not $p) { return $null }
285
448
  if ($p.estado -eq 'sube') {
286
449
  $seg = Faltan $p.techo
287
- if ($null -eq $seg) { $seg = 0 }
450
+ # Una proyección con el techo en el PASADO ya no proyecta nada: se leía
451
+ # «100 % en vencido», que no quiere decir nada. Cuando ya tocaste el techo
452
+ # la pregunta es cuándo te liberás, y ésa la contesta la cabecera del panel.
453
+ # Mismo criterio que VistaCuenta.ritmo en bin/qm-indicator.
454
+ if ($null -eq $seg -or $seg -le 0) { return $null }
288
455
  # Invariante y no la cultura de la máquina: con `n1`, una Windows en
289
456
  # español escribe «1,8 pts/h» y una en inglés «1.8», así que las pantallas
290
457
  # dejaban de coincidir entre sí y con macOS, que usa %.1f. El separador de
@@ -298,6 +465,26 @@ function FraseRitmo($p) {
298
465
  return "todavía no sé el ritmo: $($p.motivo)"
299
466
  }
300
467
 
468
+ # El presupuesto diario: cuánto se puede gastar por día para que la ventana
469
+ # larga llegue entera al reinicio, y cuánto de eso queda hoy.
470
+ #
471
+ # Llega dividido del núcleo, incluido CUÁL ventana se reparte —la larga, nunca
472
+ # la de 5 h, que se reinicia cuatro veces por día y ahí «por día» no quiere
473
+ # decir nada—. Acá no se divide: se escribe.
474
+ function FrasePresupuesto($pre) {
475
+ if (-not $pre) { return $null }
476
+ # El JSON de una versión anterior de `qm` no trae el campo, y con StrictMode
477
+ # leer una propiedad que no está es una excepción en el hilo de la interfaz.
478
+ if (-not $pre.PSObject.Properties['estado']) { return $null }
479
+ if ($pre.estado -ne 'ok') { return "presupuesto: $($pre.motivo)" }
480
+ # Invariante y no la cultura de la máquina, por lo mismo que el ritmo: el
481
+ # separador decimal acá es parte del dibujo y tiene que coincidir entre
482
+ # pantallas.
483
+ $porDia = ([double]$pre.porDia).ToString('0.0', [cultureinfo]::InvariantCulture)
484
+ $hoy = ([double]$pre.quedaHoy).ToString('0.0', [cultureinfo]::InvariantCulture)
485
+ return "podés gastar $porDia %/día · hoy te queda $hoy %"
486
+ }
487
+
301
488
  # ── avisos ──────────────────────────────────────────────────────────────
302
489
  # La clave incluye el instante de reinicio: cuando la ventana se reinicia la
303
490
  # clave cambia sola y el mismo umbral puede volver a avisar. Sin eso, o
@@ -313,6 +500,16 @@ try {
313
500
  }
314
501
  } catch { $script:Vistos = @{} } # sin memoria se avisa de más, no de menos
315
502
 
503
+ $script:Globos = @()
504
+
505
+ function Globo([string]$titulo, [string]$cuerpo, [bool]$urgente) {
506
+ # No se muestra acá: se encola. Un globo necesita un item VISIBLE que lo
507
+ # emita, y los items se crean después de dibujar —recién ahí se sabe cuántas
508
+ # cuentas hay—. Mostrarlo en el momento perdía justo el aviso del primer
509
+ # tick, que es el que llega cuando arrancás la máquina ya frenado.
510
+ $script:Globos += @{ titulo = $titulo; cuerpo = $cuerpo; urgente = $urgente }
511
+ }
512
+
316
513
  function Avisar([string]$clave, [string]$titulo, [string]$cuerpo, [bool]$urgente) {
317
514
  if ($script:Vistos.ContainsKey($clave)) { return }
318
515
  $script:Vistos[$clave] = $true
@@ -321,14 +518,67 @@ function Avisar([string]$clave, [string]$titulo, [string]$cuerpo, [bool]$urgente
321
518
  if (-not (Test-Path $dir)) { New-Item -ItemType Directory -Path $dir -Force | Out-Null }
322
519
  ($script:Vistos.Keys | Sort-Object) | ConvertTo-Json | Set-Content $script:RutaAvisos -Encoding UTF8
323
520
  } catch { }
324
- # No se muestra acá: se encola. Un globo necesita un item VISIBLE que lo
325
- # emita, y los items se crean después de dibujar —recién ahí se sabe cuántas
326
- # cuentas hay—. Mostrarlo en el momento perdía justo el aviso del primer
327
- # tick, que es el que llega cuando arrancás la máquina ya frenado.
328
- $script:Globos += @{ titulo = $titulo; cuerpo = $cuerpo; urgente = $urgente }
521
+ Globo $titulo $cuerpo $urgente
329
522
  }
330
523
 
331
- $script:Globos = @()
524
+ # ── la memoria de la vuelta anterior ────────────────────────────────────
525
+ # Cuánto valía cada barra la última vez, para poder ver que se REINICIÓ.
526
+ #
527
+ # Un porcentaje solo no dice nada de eso: 3 % puede ser «recién empezás» o
528
+ # «acabás de salir de estar contra el techo», y la diferencia es justo lo que
529
+ # hay que avisar. Se guarda el minuto de reinicio junto al número: cuando el
530
+ # minuto cambia, la ventana es otra. Es Previos de bin/qm-indicator y
531
+ # previos.json de bin/qm-barra.swift, que era lo único de los avisos que la
532
+ # bandeja no tenía.
533
+
534
+ $script:RutaPrevios = Join-Path $env:LOCALAPPDATA 'quartermaster\previos.json'
535
+ $script:Previos = @{}
536
+ try {
537
+ if (Test-Path $script:RutaPrevios) {
538
+ $m = Get-Content $script:RutaPrevios -Raw -Encoding UTF8 | ConvertFrom-Json
539
+ foreach ($prop in $m.PSObject.Properties) { $script:Previos[$prop.Name] = @($prop.Value) }
540
+ }
541
+ } catch { $script:Previos = @{} } # sin memoria no se avisa de más: no se avisa
542
+
543
+ $script:PreviosSucio = $false
544
+
545
+ function GuardarPrevios {
546
+ if (-not $script:PreviosSucio) { return }
547
+ $script:PreviosSucio = $false
548
+ try {
549
+ $dir = Split-Path $script:RutaPrevios -Parent
550
+ if (-not (Test-Path $dir)) { New-Item -ItemType Directory -Path $dir -Force | Out-Null }
551
+ $script:Previos | ConvertTo-Json -Compress | Set-Content $script:RutaPrevios -Encoding UTF8
552
+ } catch { }
553
+ }
554
+
555
+ function RevisarLiberada([string]$perfil, $v) {
556
+ # El aviso que faltaba: YA PODÉS VOLVER A TRABAJAR.
557
+ #
558
+ # Todo lo demás avisa cuando subís. Éste avisa cuando la ventana se reinicia
559
+ # habiendo estado contra el techo, que es el único momento en que la noticia
560
+ # sirve para hacer algo distinto ahora mismo — y es justamente cuando dejaste
561
+ # de mirar la barra, porque no había nada que mirar.
562
+ #
563
+ # No pasa por Avisar: la deduplicación de Avisar es para siempre, y acá la
564
+ # condición ya es un FLANCO —sólo se cumple en la vuelta en que el minuto
565
+ # cambia— así que anotarla en `avisados.json` la silenciaría para el próximo
566
+ # reinicio, que es el que sí hay que avisar.
567
+ $clave = "$perfil|$(NombreVentana $v)"
568
+ $minuto = AlMinuto $v.reinicia
569
+ $pct = [double]$v.porcentaje
570
+ $antes = $script:Previos[$clave]
571
+ $script:Previos[$clave] = @($minuto, $pct)
572
+ $script:PreviosSucio = $true
573
+ if ($null -eq $antes -or @($antes).Count -ne 2) { return }
574
+ $minutoAntes = [string]@($antes)[0]
575
+ $pctAntes = [double]@($antes)[1]
576
+ # Ventana nueva, y en la anterior estabas contra el techo.
577
+ if ($minuto -eq $minutoAntes -or $pctAntes -lt 80 -or $pct -ge $pctAntes) { return }
578
+ Globo "${perfil}: se reinició $(NombreVentana $v)" `
579
+ ("Estabas {0:d} % y ahora vas {1:d} %." -f [int][math]::Round($pctAntes), [int][math]::Round($pct)) `
580
+ $false
581
+ }
332
582
 
333
583
  function SoltarGlobos {
334
584
  if (-not $script:Ni) { $script:Globos = @(); return }
@@ -351,16 +601,39 @@ $MARGEN = 15
351
601
  $ALTO_CABECERA = 17 + 14 + 8 # título + subtítulo + aire
352
602
  $ALTO_BARRA = 15 + 3 + 5 + 4 + 12 + 7
353
603
  $ALTO_RITMO = 16
354
- $ALTO_FRASE = 30
604
+ # El renglón del presupuesto diario, debajo del ritmo: mismo cuerpo de letra.
605
+ $ALTO_PRESUPUESTO = 16
355
606
  # 6 de aire + 16 de curva + 12 para los rótulos de abajo, igual que
356
607
  # VistaCuenta.ALTO_CURVA en Swift. Si esto no coincide con lo que dibuja
357
608
  # DibujarPerfil, los rótulos se comen el renglón siguiente.
358
609
  $ALTO_CURVA = 34
359
610
  # El anillo (44) más el aire de arriba y abajo: el alto de VistaResumen.
360
611
  $ALTO_RESUMEN = 74
612
+ # El renglón de «lecturas: cada ~5m · última hace 2m», que contesta «¿este
613
+ # número de cuándo es?» — una pregunta que un porcentaje no contesta.
614
+ $ALTO_LECTURAS = 15
615
+ # El renglón de «próxima lectura en 4m 12s», que va al pie del panel entero.
616
+ $ALTO_PIE = 20
361
617
 
362
618
  function Px([double]$v) { return [float]($v * $script:Escala) }
363
619
 
620
+ # Un Bitmap, con las dimensiones acotadas a 1 px como PISO.
621
+ #
622
+ # GDI+ tira «Parameter is not valid» si una dimensión es 0 — comprobado: el
623
+ # constructor de Bitmap(340, 0) da exactamente ese texto— y esa excepción, en el
624
+ # hilo de la interfaz, es el cartel morado de .NET que mata la bandeja entera.
625
+ # Una bandeja muerta no deja ícono, y un ícono que no está se lee igual que una
626
+ # cuenta que va bien: el silencio otra vez.
627
+ #
628
+ # Un lienzo de 1 px no dibuja nada y se nota, pero es un renglón vacío y no una
629
+ # aplicación cerrada. Que un alto dé 0 sigue siendo un bug de medida, y lo
630
+ # agarra scripts/gate-bandeja.ps1, que mide los píxeles que salen.
631
+ function Lienzo($ancho, $alto) {
632
+ return New-Object System.Drawing.Bitmap(
633
+ [int][math]::Max(1, [math]::Round([double]$ancho)),
634
+ [int][math]::Max(1, [math]::Round([double]$alto)))
635
+ }
636
+
364
637
  function CrearFuentes {
365
638
  $f = { param($px, $estilo) New-Object System.Drawing.Font('Segoe UI', (Px $px), $estilo, [System.Drawing.GraphicsUnit]::Pixel) }
366
639
  $script:FTitulo = & $f 14 ([System.Drawing.FontStyle]::Bold)
@@ -369,7 +642,6 @@ function CrearFuentes {
369
642
  $script:FActiva = & $f 12 ([System.Drawing.FontStyle]::Bold)
370
643
  $script:FPct = & $f 12 ([System.Drawing.FontStyle]::Bold)
371
644
  $script:FPie = & $f 10 ([System.Drawing.FontStyle]::Regular)
372
- $script:FFrase = & $f 11 ([System.Drawing.FontStyle]::Regular)
373
645
  $script:FRotulo = & $f 9 ([System.Drawing.FontStyle]::Bold)
374
646
  $script:FMini = & $f 9 ([System.Drawing.FontStyle]::Regular)
375
647
  $script:FCifra = & $f 20 ([System.Drawing.FontStyle]::Bold)
@@ -387,14 +659,36 @@ function RectRedondeado($g, $rect, [float]$r, $brocha) {
387
659
  $p.Dispose()
388
660
  }
389
661
 
390
- function Escribir($g, [string]$t, [float]$x, [float]$y, $fuente, $color, [float]$derecha = -1) {
662
+ # Escribe una línea. Con $ancho, la RECORTA con puntos suspensivos.
663
+ #
664
+ # GDI+ no recorta nada cuando se dibuja en un punto —igual que Cairo— así que un
665
+ # nombre de perfil más largo que la tarjeta se dibujaba por encima del borde y
666
+ # se salía del panel, y un nombre de ventana largo se metía por debajo del
667
+ # porcentaje de la derecha y quedaban los dos ilegibles. Se ve con el fixture de
668
+ # nombres largos y no se ve mirando el código, que es por lo que el panel de
669
+ # GNOME tiene un gate que mide los píxeles del margen en vez de confiar en el ojo.
670
+ function Escribir($g, [string]$t, [float]$x, [float]$y, $fuente, $color,
671
+ [float]$derecha = -1, [float]$ancho = -1) {
391
672
  if (-not $t) { return }
392
673
  $br = New-Object System.Drawing.SolidBrush($color)
393
674
  if ($derecha -ge 0) {
394
675
  $an = $g.MeasureString($t, $fuente).Width
676
+ if ($ancho -gt 0 -and $an -gt $ancho) { $an = $ancho }
395
677
  $x = $derecha - $an
396
678
  }
397
- $g.DrawString($t, $fuente, $br, $x, $y)
679
+ if ($ancho -gt 0) {
680
+ $fmt = New-Object System.Drawing.StringFormat
681
+ $fmt.Trimming = [System.Drawing.StringTrimming]::EllipsisCharacter
682
+ $fmt.FormatFlags = [System.Drawing.StringFormatFlags]::NoWrap
683
+ # El alto de UNA línea, del tipo de letra y no del texto: MeasureString de
684
+ # una cadena larga devuelve el alto que ocuparía envuelta, y con eso la caja
685
+ # dejaba de ser de una línea justo en el caso que hay que recortar.
686
+ $caja = New-Object System.Drawing.RectangleF($x, $y, $ancho, $fuente.GetHeight($g))
687
+ $g.DrawString($t, $fuente, $br, $caja, $fmt)
688
+ $fmt.Dispose()
689
+ } else {
690
+ $g.DrawString($t, $fuente, $br, $x, $y)
691
+ }
398
692
  $br.Dispose()
399
693
  }
400
694
 
@@ -493,24 +787,46 @@ function DibujarCurva($g, $historia, [string]$nivel, $caja) {
493
787
  Escribir $g $cola 0 ($caja.Bottom + (Px 1)) $script:FMini $script:Tinta3 $caja.Right
494
788
  }
495
789
 
790
+ # «lecturas: cada ~5m · última hace 2m».
791
+ #
792
+ # La pregunta «¿este número de cuándo es?» no la contesta un porcentaje, y la
793
+ # edad del cache sola tampoco: «hace 40 minutos» es tranquilizador si se lee
794
+ # cada hora y alarmante si se lee cada cinco minutos. Las dos juntas sí. Es
795
+ # VistaCuenta.lecturas de bin/qm-indicator.
796
+ function FraseLecturas($cuota) {
797
+ if ($cuota.estado -ne 'ok') { return $null }
798
+ $partes = @()
799
+ $cada = CadaCuanto $cuota.historia
800
+ if ($null -ne $cada) { $partes += "cada ~$(Dur ([int]$cada))" }
801
+ if ($cuota.PSObject.Properties['edadSegundos'] -and $null -ne $cuota.edadSegundos) {
802
+ $e = [int]$cuota.edadSegundos
803
+ $partes += "última hace $(Dur $e)" + $(if ($e -ge $VIEJO_SEGUNDOS) { ' · viejo' } else { '' })
804
+ }
805
+ if (-not $partes.Count) { return $null }
806
+ return 'lecturas: ' + ($partes -join ' · ')
807
+ }
808
+
809
+ function Presupuesto($p) {
810
+ if (-not $p.PSObject.Properties['presupuesto']) { return $null }
811
+ return $p.presupuesto
812
+ }
813
+
496
814
  function AltoPerfil($p) {
497
815
  $alto = (Px $MARGEN) + (Px $ALTO_CABECERA)
498
816
  $cuota = $p.cuota
499
- if ($cuota.estado -ne 'ok') {
500
- $alto += (Px $ALTO_FRASE)
501
- } else {
502
- $alto += (Px $ALTO_BARRA) * (@($cuota.mostrar)).Count
503
- # La curva es de la barra que frena, así que suma una vez y no por barra.
504
- if ((@($cuota.historia)).Count -ge 3) { $alto += (Px $ALTO_CURVA) }
505
- if (FraseRitmo $p.proyeccion) { $alto += (Px $ALTO_RITMO) }
506
- }
817
+ $alto += (Px $ALTO_BARRA) * (@($cuota.mostrar)).Count
818
+ # La curva es de la barra que frena, así que suma una vez y no por barra.
819
+ if ((@($cuota.historia)).Count -ge 3) { $alto += (Px $ALTO_CURVA) }
820
+ if (FraseRitmo $p.proyeccion) { $alto += (Px $ALTO_RITMO) }
821
+ if (FrasePresupuesto (Presupuesto $p)) { $alto += (Px $ALTO_PRESUPUESTO) }
822
+ if (FraseLecturas $cuota) { $alto += (Px $ALTO_LECTURAS) }
507
823
  return [int]($alto + (Px 10))
508
824
  }
509
825
 
510
826
  function DibujarPerfil($p, [int]$indice) {
511
827
  $ancho = [int](Px $ANCHO_VISTA)
512
828
  $alto = AltoPerfil $p
513
- $bmp = New-Object System.Drawing.Bitmap($ancho, $alto)
829
+ $bmp = Lienzo $ancho $alto
514
830
  $g = [System.Drawing.Graphics]::FromImage($bmp)
515
831
  $g.SmoothingMode = [System.Drawing.Drawing2D.SmoothingMode]::AntiAlias
516
832
  $g.TextRenderingHint = [System.Drawing.Text.TextRenderingHint]::ClearTypeGridFit
@@ -523,26 +839,21 @@ function DibujarPerfil($p, [int]$indice) {
523
839
  # El del MENÚ, que va sobre el fondo del menú.
524
840
  $colorCuenta = ColorCuenta $indice $script:MenuOscuro
525
841
  GlifoProducto $g $p.producto $colorCuenta $m ($y + (Px 2)) (Px 13)
526
- Escribir $g (Corto $p.perfil) ($m + (Px 19)) $y $script:FTitulo $script:Tinta
842
+ $anchoCabecera = $der - $m - (Px 19)
843
+ Escribir $g (Corto $p.perfil) ($m + (Px 19)) $y $script:FTitulo $script:Tinta -1 $anchoCabecera
527
844
  $y += Px 17
528
845
 
529
846
  $partes = @()
530
847
  if ($p.cuenta) { $partes += $p.cuenta }
531
848
  if ($p.plan) { $partes += $p.plan }
532
- Escribir $g ($partes -join ' · ') ($m + (Px 19)) $y $script:FSub $script:Tinta3
849
+ Escribir $g ($partes -join ' · ') ($m + (Px 19)) $y $script:FSub $script:Tinta3 -1 $anchoCabecera
533
850
  $y += Px 22
534
851
 
852
+ # Acá sólo llegan cuentas CON número: las mudas van a DibujarSinCuota, que
853
+ # las junta en una tarjeta sola. Esta función tenía una rama para dibujarles
854
+ # la frase y quedó muerta con ese cambio; se saca en vez de dejarla, porque
855
+ # una rama que no se ejecuta es una rama que nadie va a notar cuando se rompa.
535
856
  $cuota = $p.cuota
536
- if ($cuota.estado -ne 'ok') {
537
- # Silencio es el bug: si no hay número, hay una frase.
538
- $frase = if ($cuota.PSObject.Properties['frase']) { $cuota.frase } else { 'sin cuota' }
539
- $caja = New-Object System.Drawing.RectangleF($m, $y, ($der - $m), (Px ($ALTO_FRASE + 4)))
540
- $br = New-Object System.Drawing.SolidBrush($script:Tinta2)
541
- $g.DrawString($frase, $script:FFrase, $br, $caja)
542
- $br.Dispose(); $g.Dispose()
543
- return $bmp
544
- }
545
-
546
857
  $peor = $cuota.frena
547
858
  $chocas = [bool]($p.proyeccion -and $p.proyeccion.estado -eq 'sube' -and $p.proyeccion.chocasAntesDelReinicio)
548
859
 
@@ -552,9 +863,14 @@ function DibujarPerfil($p, [int]$indice) {
552
863
  $activa = [bool]$v.activa
553
864
 
554
865
  $nombre = if ($activa) { (NombreVentana $v) + ' ▸' } else { NombreVentana $v }
866
+ # El porcentaje se dibuja PRIMERO —es lo que se viene a leer— y el nombre se
867
+ # recorta contra el hueco que dejó. Al revés, un nombre de ventana largo se
868
+ # metía por debajo del número y quedaban los dos ilegibles.
869
+ $cifra = '{0:d}%' -f [int][math]::Round($v.porcentaje)
870
+ Escribir $g $cifra 0 $y $script:FPct $script:Tinta $der
871
+ $anchoNombre = $der - $m - $g.MeasureString($cifra, $script:FPct).Width - (Px 8)
555
872
  Escribir $g $nombre $m $y $(if ($activa) { $script:FActiva } else { $script:FNombre }) `
556
- $(if ($activa) { $script:Tinta } else { $script:Tinta2 })
557
- Escribir $g ('{0:d}%' -f [int][math]::Round($v.porcentaje)) 0 $y $script:FPct $script:Tinta $der
873
+ $(if ($activa) { $script:Tinta } else { $script:Tinta2 }) -1 $anchoNombre
558
874
  $y += Px 18
559
875
 
560
876
  # El medidor: pista tenue y relleno con el color del estado.
@@ -569,16 +885,12 @@ function DibujarPerfil($p, [int]$indice) {
569
885
  $brLleno.Dispose()
570
886
  $y += Px 9
571
887
 
572
- $pie = ''
573
- $seg = Faltan $v.reinicia
574
- if ($null -ne $seg) { $pie = "reinicia en $(Dur $seg)" }
575
- if ($esPeor -and $cuota.PSObject.Properties['edadSegundos']) {
576
- $e = [int]$cuota.edadSegundos
577
- if ($pie) { $pie += ' · ' }
578
- $pie += "cache de hace $(Dur $e)"
579
- if ($e -ge $VIEJO_SEGUNDOS) { $pie += ' · viejo' }
580
- }
581
- Escribir $g $pie $m $y $script:FPie $script:Tinta3
888
+ # La edad del cache ya NO va acá: se mudó al renglón de «lecturas», abajo,
889
+ # donde va acompañada de cada cuánto se lee. Sola decía la mitad —«hace
890
+ # 40 m» es tranquilizador si se lee cada hora y alarmante si se lee cada
891
+ # cinco minutos— y encima la repetía una vez por perfil en el renglón de
892
+ # una barra que no es la suya.
893
+ Escribir $g (Reinicio (Faltan $v.reinicia)) $m $y $script:FPie $script:Tinta3
582
894
  $y += Px 19
583
895
 
584
896
  # La curva va pegada a la barra que frena: es de ella, no del perfil.
@@ -591,7 +903,22 @@ function DibujarPerfil($p, [int]$indice) {
591
903
 
592
904
  $ritmo = FraseRitmo $p.proyeccion
593
905
  if ($ritmo) {
594
- Escribir $g $ritmo $m $y $script:FPie $(if ($chocas) { $PALETA['critico'] } else { $script:Tinta3 })
906
+ Escribir $g $ritmo $m $y $script:FPie `
907
+ $(if ($chocas) { $PALETA['critico'] } else { $script:Tinta3 }) -1 ($der - $m)
908
+ $y += Px $ALTO_RITMO
909
+ }
910
+
911
+ # El ritmo dice hacia dónde vas; el presupuesto, a cuánto tendrías que ir para
912
+ # que la cuota llegue al reinicio. Van pegados: son la misma pregunta.
913
+ $presupuesto = FrasePresupuesto (Presupuesto $p)
914
+ if ($presupuesto) {
915
+ Escribir $g $presupuesto $m $y $script:FPie $script:Tinta2 -1 ($der - $m)
916
+ $y += Px $ALTO_PRESUPUESTO
917
+ }
918
+
919
+ $lecturas = FraseLecturas $cuota
920
+ if ($lecturas) {
921
+ Escribir $g $lecturas $m $y $script:FPie $script:Tinta3 -1 ($der - $m)
595
922
  }
596
923
 
597
924
  $g.Dispose()
@@ -624,7 +951,7 @@ function DibujarResumen($perfiles) {
624
951
 
625
952
  $ancho = [int](Px $ANCHO_VISTA)
626
953
  $alto = [int](Px $ALTO_RESUMEN)
627
- $bmp = New-Object System.Drawing.Bitmap($ancho, $alto)
954
+ $bmp = Lienzo $ancho $alto
628
955
  $g = [System.Drawing.Graphics]::FromImage($bmp)
629
956
  $g.SmoothingMode = [System.Drawing.Drawing2D.SmoothingMode]::AntiAlias
630
957
  $g.TextRenderingHint = [System.Drawing.Text.TextRenderingHint]::ClearTypeGridFit
@@ -648,18 +975,22 @@ function DibujarResumen($perfiles) {
648
975
  $lap.Dispose()
649
976
 
650
977
  $x = $m + $lado + (Px 14)
651
- Escribir $g 'LO PRIMERO QUE TE FRENA' $x (Px 11) $script:FRotulo $script:Tinta3
978
+ $der = $ancho - $m
979
+ Escribir $g 'LO PRIMERO QUE TE FRENA' $x (Px 11) $script:FRotulo $script:Tinta3 -1 ($der - $x)
652
980
  $cifra = '{0:d}%' -f $pct
653
981
  Escribir $g $cifra $x (Px 22) $script:FCifra $script:Tinta
654
- # El nombre va a la derecha de la cifra, apoyado en su misma línea de base.
982
+ # El nombre va a la derecha de la cifra, apoyado en su misma línea de base, y
983
+ # recortado contra el margen: es el texto más largo del panel —perfil más
984
+ # ventana— y era el que primero se salía.
985
+ $xNombre = $x + $g.MeasureString($cifra, $script:FCifra).Width
655
986
  Escribir $g (' {0} · {1}' -f (Corto $mejorP.perfil), (NombreVentana $mejor)) `
656
- ($x + $g.MeasureString($cifra, $script:FCifra).Width) (Px 30) $script:FSub $script:Tinta2
987
+ $xNombre (Px 30) $script:FSub $script:Tinta2 -1 ($der - $xNombre)
657
988
 
658
989
  # Cuando ya te frenó, lo que importa no es cuándo «reinicia»: es cuándo
659
990
  # volvés a poder trabajar. Es la misma fecha y una pregunta distinta.
660
991
  $seg = Faltan $mejor.reinicia
661
- $texto = if ($pct -ge 95 -and $null -ne $seg) { "libre en $(Dur $seg)" }
662
- elseif ($null -ne $seg) { "reinicia en $(Dur $seg)" }
992
+ $texto = if ($pct -ge 95 -and $null -ne $seg -and $seg -gt 0) { "libre en $(Dur $seg)" }
993
+ elseif ($null -ne $seg) { Reinicio $seg }
663
994
  else { 'sin reinicio informado' }
664
995
  Escribir $g $texto $x (Px 50) $script:FPie $(if ($pct -ge 95) { $c } else { $script:Tinta3 })
665
996
 
@@ -667,6 +998,79 @@ function DibujarResumen($perfiles) {
667
998
  return $bmp
668
999
  }
669
1000
 
1001
+ # Las cuentas que no dejaron número, JUNTAS en una tarjeta.
1002
+ #
1003
+ # Es VistaSinCuota de bin/qm-indicator. Antes cada perfil mudo se llevaba una
1004
+ # tarjeta entera de 340 px para decir una línea, y con cuatro perfiles el panel
1005
+ # se iba de pantalla mostrando sobre todo lo que NO se sabe. La respuesta a
1006
+ # «¿por qué esta cuenta no tiene número?» es una frase corta, y cuatro frases
1007
+ # cortas son una lista, no cuatro tarjetas.
1008
+ #
1009
+ # Ojo: esto agrupa el PANEL solamente. En la bandeja cada perfil mudo conserva
1010
+ # su propio item, y eso es a propósito — está explicado en Refrescar.
1011
+ function DibujarSinCuota($calladas) {
1012
+ $cal = @($calladas)
1013
+ if (-not $cal.Count) { return $null }
1014
+
1015
+ $ancho = [int](Px $ANCHO_VISTA)
1016
+ $m = Px $MARGEN
1017
+ $der = $ancho - $m
1018
+
1019
+ # Medir antes de dibujar: el alto depende de cuántas líneas ocupa cada frase.
1020
+ $medidor = New-Object System.Drawing.Bitmap(1, 1)
1021
+ $gm = [System.Drawing.Graphics]::FromImage($medidor)
1022
+ $altos = @()
1023
+ foreach ($c in $cal) {
1024
+ $an = $der - $m - (Px 84)
1025
+ $altos += [math]::Max((Px 15), $gm.MeasureString($c.frase, $script:FPie, [int]$an).Height)
1026
+ }
1027
+ $gm.Dispose(); $medidor.Dispose()
1028
+
1029
+ $alto = [int]((Px $MARGEN) + (Px 15) + ($altos | Measure-Object -Sum).Sum + (Px ($cal.Count * 5)) + (Px 10))
1030
+ $bmp = Lienzo $ancho $alto
1031
+ $g = [System.Drawing.Graphics]::FromImage($bmp)
1032
+ $g.SmoothingMode = [System.Drawing.Drawing2D.SmoothingMode]::AntiAlias
1033
+ $g.TextRenderingHint = [System.Drawing.Text.TextRenderingHint]::ClearTypeGridFit
1034
+ $g.Clear($script:Fondo)
1035
+
1036
+ $y = Px $MARGEN
1037
+ Escribir $g 'SIN NÚMERO' $m $y $script:FRotulo $script:Tinta3
1038
+ $y += Px 15
1039
+
1040
+ for ($i = 0; $i -lt $cal.Count; $i++) {
1041
+ $c = $cal[$i]
1042
+ Escribir $g $c.nombre $m $y $script:FNombre $script:Tinta2 -1 (Px 78)
1043
+ $caja = New-Object System.Drawing.RectangleF(
1044
+ ($m + (Px 84)), $y, ($der - $m - (Px 84)), $altos[$i])
1045
+ $br = New-Object System.Drawing.SolidBrush($script:Tinta3)
1046
+ $g.DrawString($c.frase, $script:FPie, $br, $caja)
1047
+ $br.Dispose()
1048
+ $y += $altos[$i] + (Px 5)
1049
+ }
1050
+
1051
+ $g.Dispose()
1052
+ return $bmp
1053
+ }
1054
+
1055
+ # El pie del panel: CUÁNDO DEJA DE SER CIERTO ESTE NÚMERO.
1056
+ #
1057
+ # Cada cuenta dice de cuándo es su número; esto dice cuándo deja de serlo. Es
1058
+ # la otra mitad de la misma pregunta, y es el renglón que baja solo mientras el
1059
+ # panel está abierto — por eso se dibuja aparte y no adentro de una tarjeta.
1060
+ function DibujarPieLectura([double]$falta) {
1061
+ $ancho = [int](Px $ANCHO_VISTA)
1062
+ $alto = [int](Px $ALTO_PIE)
1063
+ $bmp = Lienzo $ancho $alto
1064
+ $g = [System.Drawing.Graphics]::FromImage($bmp)
1065
+ $g.SmoothingMode = [System.Drawing.Drawing2D.SmoothingMode]::AntiAlias
1066
+ $g.TextRenderingHint = [System.Drawing.Text.TextRenderingHint]::ClearTypeGridFit
1067
+ $g.Clear($script:Fondo)
1068
+ Escribir $g "próxima lectura en $(CuentaRegresiva $falta)" (Px $MARGEN) (Px 4) `
1069
+ $script:FPie $script:Tinta3
1070
+ $g.Dispose()
1071
+ return $bmp
1072
+ }
1073
+
670
1074
  # ── los íconos de la bandeja ────────────────────────────────────────────
671
1075
  # Nunca un número, y uno por cuenta.
672
1076
  #
@@ -682,38 +1086,57 @@ function DibujarResumen($perfiles) {
682
1086
  # a mirar. En un item de bandeja no cabe, porque no tiene etiqueta de texto y
683
1087
  # es un cuadrado de 16x16. Así que la tira se reparte: un item por cuenta, con
684
1088
  # el glifo de su producto y el medidor de su semanal, y el número de la sesión
685
- # en el tooltip. HacerIcono quedó para el único caso sin cuenta que mostrar:
686
- # cuando qm no contesta.
1089
+ # en el tooltip. Y arriba de todos, el general, que dice lo de la máquina entera
1090
+ # con la marca — incluso cuando qm no contesta y es el único que queda.
687
1091
  #
688
1092
  # La pista es gris al 41 % de alfa a propósito: la barra de tareas puede ser
689
1093
  # clara u oscura y el ícono no se entera, así que un gris translúcido es lo
690
1094
  # único que se ve en las dos.
691
1095
 
692
- function HacerIcono([double]$pct, [string]$nivel) {
1096
+ # El ícono general: la marca de quartermaster, que ya es un medidor.
1097
+ #
1098
+ # El logo (docs/logo-mono.svg) es un anillo INCOMPLETO con una cola en diagonal
1099
+ # —un manómetro—, así que la marca y el medidor son el mismo dibujo: el arco se
1100
+ # llena hasta el peor porcentaje de la máquina y se pinta con el color de ese
1101
+ # estado, y la cola va siempre porque es lo que hace que se lea como la marca y
1102
+ # no como un donut más. Un logo que nunca cambia de color sería una marca y no
1103
+ # un indicador, y en una bandeja el ícono tiene que decir algo de un vistazo.
1104
+ #
1105
+ # Las medidas salen del SVG, que está en un viewBox de 64: centro (32,32),
1106
+ # radio 20, trazo 9, cola de (41,41) a (51.5,51.5). Acá se dibuja a 32 px, o
1107
+ # sea la mitad de todo.
1108
+ function IconoGeneral([double]$pct, [string]$nivel) {
693
1109
  $lado = 32
694
- $grosor = 8.0
695
- $bmp = New-Object System.Drawing.Bitmap($lado, $lado)
1110
+ $k = $lado / 64.0
1111
+ $bmp = Lienzo $lado $lado
696
1112
  $g = [System.Drawing.Graphics]::FromImage($bmp)
697
1113
  $g.SmoothingMode = [System.Drawing.Drawing2D.SmoothingMode]::AntiAlias
698
1114
  $g.Clear([System.Drawing.Color]::Transparent)
699
1115
 
700
- $m = $grosor / 2 + 0.5
701
- $caja = New-Object System.Drawing.RectangleF($m, $m, ($lado - 2 * $m), ($lado - 2 * $m))
1116
+ $grosor = [float](9 * $k)
1117
+ $r = 20 * $k
1118
+ $c = 32 * $k
1119
+ $caja = New-Object System.Drawing.RectangleF(($c - $r), ($c - $r), (2 * $r), (2 * $r))
1120
+
1121
+ # La pista, igual que en el logo: el mismo trazo al 20 %. Gris y no del color
1122
+ # del estado, porque la barra de tareas puede ser clara u oscura.
702
1123
  $lapPista = New-Object System.Drawing.Pen([System.Drawing.Color]::FromArgb(105, 128, 128, 128), $grosor)
703
1124
  $g.DrawEllipse($lapPista, $caja)
704
1125
 
705
- $lap = New-Object System.Drawing.Pen($PALETA[$nivel], $grosor)
1126
+ $col = $PALETA[$nivel]
1127
+ $lap = New-Object System.Drawing.Pen($col, $grosor)
706
1128
  $lap.StartCap = [System.Drawing.Drawing2D.LineCap]::Round
707
1129
  $lap.EndCap = [System.Drawing.Drawing2D.LineCap]::Round
708
- # Un mínimo de arco: a 1 % un barrido exacto no dibuja nada, y "no dibuja
709
- # nada" se lee igual que "no hay datos", que es justo lo que no es.
710
- $barrido = [float]([math]::Max(4, [math]::Min(360, $pct * 3.6)))
1130
+ # El logo abre el anillo a los 240°, así que el medidor llena ESE recorrido y
1131
+ # no los 360: el hueco de arriba a la izquierda es parte de la marca.
1132
+ $barrido = [float]([math]::Max(4, [math]::Min(240, $pct * 2.4)))
711
1133
  $g.DrawArc($lap, $caja, -90, $barrido)
712
1134
 
1135
+ # La cola, que es lo que distingue la marca de un anillo cualquiera.
1136
+ $g.DrawLine($lap, [float](41 * $k), [float](41 * $k), [float](51.5 * $k), [float](51.5 * $k))
1137
+
713
1138
  $h = $bmp.GetHicon()
714
1139
  $ico = [System.Drawing.Icon]::FromHandle($h)
715
- # Se clona para poder destruir el handle ya mismo: GetHicon() entrega un
716
- # handle que el GC no libera, y esto se rehace cada tick.
717
1140
  $clon = $ico.Clone()
718
1141
  [Qm.Nativo]::DestroyIcon($h) | Out-Null
719
1142
  $ico.Dispose(); $g.Dispose(); $bmp.Dispose(); $lapPista.Dispose(); $lap.Dispose()
@@ -732,7 +1155,7 @@ function HacerIcono([double]$pct, [string]$nivel) {
732
1155
  # a 16 cuando hace falta. Por eso el trazo del glifo va explícito y grueso.
733
1156
  function IconoCuenta([string]$producto, $colorCuenta, $semanal, [string]$nivelSemanal) {
734
1157
  $lado = 32
735
- $bmp = New-Object System.Drawing.Bitmap($lado, $lado)
1158
+ $bmp = Lienzo $lado $lado
736
1159
  $g = [System.Drawing.Graphics]::FromImage($bmp)
737
1160
  $g.SmoothingMode = [System.Drawing.Drawing2D.SmoothingMode]::AntiAlias
738
1161
  $g.Clear([System.Drawing.Color]::Transparent)
@@ -775,16 +1198,135 @@ function ArgsWsl([string]$cmd) {
775
1198
  return "$prefijo-e bash -lc `"$cmd`""
776
1199
  }
777
1200
 
1201
+ # ── de dónde sale el número: Windows nativo o WSL ───────────────────────
1202
+ #
1203
+ # Hasta acá esto era WSL y nada más: `wsl.exe` estaba escrito a mano en los tres
1204
+ # lugares que corren qm. Eso deja afuera al usuario de Windows NATIVO —el que
1205
+ # instala por winget y tiene Claude Code del lado de Windows— que es justo a
1206
+ # quien apunta tener un instalador. Y el CLI ya andaba nativo: está medido en
1207
+ # numeros/h4-windows.md, con `plataforma: win32`. Lo único que faltaba era
1208
+ # `qm.cmd`, que ahora existe.
1209
+ #
1210
+ # Cómo se elige, en orden, y por qué ese orden:
1211
+ #
1212
+ # 1. -Qm <ruta> lo que el usuario pidió explícitamente, gana siempre.
1213
+ # 2. -QmLinux <ruta> pedir el de adentro de WSL ES pedir WSL. Es lo que pasa
1214
+ # el lanzador bin/qm-tray, así que quien viene de WSL
1215
+ # sigue exactamente como antes.
1216
+ # 3. qm.cmd al lado el instalador deja los dos archivos en el mismo bin\.
1217
+ # 4. qm.cmd en el PATH un `scoop install` o un PATH puesto a mano.
1218
+ # 5. WSL lo de siempre, si hay wsl.exe.
1219
+ #
1220
+ # Si no hay ninguno NO se dibuja un cero: se devuelve una frase. Un ícono que
1221
+ # no encontró a qm y un ícono que encontró un 0 % se ven parecido y significan
1222
+ # cosas opuestas (SOUL.md: silencio es el bug).
1223
+ $script:QmResuelto = $null
1224
+
1225
+ function ResolverQm {
1226
+ if ($null -ne $script:QmResuelto) { return $script:QmResuelto }
1227
+
1228
+ $r = [pscustomobject]@{ Modo = 'ninguno'; Qm = ''; Web = ''; Motivo = '' }
1229
+ $nativo = ''
1230
+
1231
+ if ($Qm) {
1232
+ # 1. Lo que pidieron. Si no está, se dice cuál falta y se termina acá: ir a
1233
+ # buscar otro sería contestar una pregunta distinta de la que hicieron.
1234
+ if (Test-Path -LiteralPath $Qm) { $nativo = $Qm }
1235
+ else { $r.Motivo = "no existe el qm que me pasaste: $Qm" }
1236
+ } elseif ($script:PidieronQmLinux) {
1237
+ # 2. Pedir el de adentro de WSL es pedir WSL, exista o no wsl.exe. No se
1238
+ # comprueba a propósito: si falta, la frase que sale de intentar correrlo
1239
+ # dice qué pasó, y eso es mejor diagnóstico que «no encuentro nada».
1240
+ $r.Modo = 'wsl'
1241
+ $r.Qm = $QmLinux
1242
+ $r.Web = 'qm-web'
1243
+ } else {
1244
+ # 3 y 4. El qm.cmd que dejó el instalador al lado, o uno en el PATH.
1245
+ $alLado = Join-Path $script:MiBin 'qm.cmd'
1246
+ if (Test-Path -LiteralPath $alLado) {
1247
+ $nativo = $alLado
1248
+ } else {
1249
+ $enPath = Get-Command 'qm.cmd' -CommandType Application -ErrorAction SilentlyContinue |
1250
+ Select-Object -First 1
1251
+ if ($enPath) { $nativo = $enPath.Source }
1252
+ }
1253
+ # 5. Y si no hay nada nativo, WSL, que es de donde viene esta bandeja.
1254
+ if (-not $nativo) {
1255
+ if (Get-Command 'wsl.exe' -CommandType Application -ErrorAction SilentlyContinue) {
1256
+ $r.Modo = 'wsl'
1257
+ $r.Qm = $QmLinux
1258
+ $r.Web = 'qm-web'
1259
+ } else {
1260
+ $r.Motivo = 'no encuentro qm.cmd ni wsl.exe: instalá quartermaster o pasame -Qm <ruta>'
1261
+ }
1262
+ }
1263
+ }
1264
+
1265
+ if ($nativo) {
1266
+ $r.Modo = 'nativo'
1267
+ $r.Qm = $nativo
1268
+ # qm-web.cmd vive al lado de qm.cmd, siempre: los instala el mismo paquete.
1269
+ $web = Join-Path (Split-Path -Parent $nativo) 'qm-web.cmd'
1270
+ $r.Web = if (Test-Path -LiteralPath $web) { $web } else { '' }
1271
+ }
1272
+
1273
+ $script:QmResuelto = $r
1274
+ return $r
1275
+ }
1276
+
1277
+ <#
1278
+ Un ProcessStartInfo listo para correr qm (o qm-web) donde sea que esté.
1279
+
1280
+ Los tres lugares que corren qm —leer, calentar y abrir el tablero— pasan por
1281
+ acá, así que el modo se decide UNA vez y no tres. Es la misma razón por la que
1282
+ `mostrar` y `frena` se resuelven en el CLI y no en cada renderer: una regla en
1283
+ tres lugares es una regla que el día que se edita uno da tres respuestas.
1284
+
1285
+ En nativo va por cmd.exe y no directo: un .cmd no es un ejecutable para
1286
+ CreateProcess. Las comillas de más alrededor de todo son las que documenta
1287
+ `cmd /?` para que /s deje el resto intacto, y hacen falta porque la ruta de
1288
+ instalación por defecto tiene espacios.
1289
+ #>
1290
+ function PsiQm([string]$argumentos, [string]$programa = 'qm') {
1291
+ $r = ResolverQm
1292
+ if ($r.Modo -eq 'ninguno') { return $null }
1293
+
1294
+ $psi = New-Object System.Diagnostics.ProcessStartInfo
1295
+ if ($r.Modo -eq 'wsl') {
1296
+ $exe = if ($programa -eq 'web') { $r.Web } else { $r.Qm }
1297
+ $psi.FileName = 'wsl.exe'
1298
+ $psi.Arguments = ArgsWsl "$exe $argumentos"
1299
+ } else {
1300
+ $exe = if ($programa -eq 'web') { $r.Web } else { $r.Qm }
1301
+ if (-not $exe) { return $null }
1302
+ $comspec = $env:ComSpec
1303
+ if (-not $comspec) { $comspec = 'cmd.exe' }
1304
+ $psi.FileName = $comspec
1305
+ $psi.Arguments = "/d /s /c `"`"$exe`" $argumentos`""
1306
+ }
1307
+ $psi.UseShellExecute = $false
1308
+ $psi.CreateNoWindow = $true
1309
+ return $psi
1310
+ }
1311
+
778
1312
  function Leer {
779
1313
  # Devuelve el objeto del JSON, o un string con la frase del problema.
780
1314
  # Silencio es el bug (SOUL.md): si no hay número, hay una frase.
781
- $psi = New-Object System.Diagnostics.ProcessStartInfo
782
- $psi.FileName = 'wsl.exe'
783
- $psi.Arguments = ArgsWsl "$QmLinux --json --breve"
1315
+
1316
+ # El JSON de un archivo en vez del de qm. Acá se LEVANTA si no se puede leer,
1317
+ # al revés que todo lo demás en esta función: una frase se dibujaría como un
1318
+ # panel de una línea y el gate la mediría como si fuera un panel válido, que
1319
+ # es exactamente la falla que el gate tiene que encontrar. Mismo criterio que
1320
+ # leer_desde() en bin/qm-indicator.
1321
+ if ($Desde) {
1322
+ $texto = [System.IO.File]::ReadAllText($Desde, [System.Text.Encoding]::UTF8)
1323
+ return ($texto | ConvertFrom-Json)
1324
+ }
1325
+
1326
+ $psi = PsiQm '--json --breve'
1327
+ if ($null -eq $psi) { return (ResolverQm).Motivo }
784
1328
  $psi.RedirectStandardOutput = $true
785
1329
  $psi.RedirectStandardError = $true
786
- $psi.UseShellExecute = $false
787
- $psi.CreateNoWindow = $true
788
1330
  $psi.StandardOutputEncoding = [System.Text.Encoding]::UTF8
789
1331
  $psi.StandardErrorEncoding = [System.Text.Encoding]::UTF8
790
1332
  try {
@@ -846,16 +1388,133 @@ function Calentar([switch]$Forzado) {
846
1388
  # Sólo las cuentas que se mueven. Refrescar una que va al 9 % es gastar un
847
1389
  # pedido para confirmar que no pasó nada.
848
1390
  $cmd = if ($script:CuentasQueMueven.Count) {
849
- "$QmLinux --calentar --cuentas=" + ($script:CuentasQueMueven -join ',')
850
- } else { "$QmLinux --calentar" }
851
- $psi = New-Object System.Diagnostics.ProcessStartInfo
852
- $psi.FileName = 'wsl.exe'
853
- $psi.Arguments = ArgsWsl $cmd
854
- $psi.UseShellExecute = $false
855
- $psi.CreateNoWindow = $true
1391
+ '--calentar --cuentas=' + ($script:CuentasQueMueven -join ',')
1392
+ } else { '--calentar' }
1393
+ $psi = PsiQm $cmd
1394
+ if ($null -eq $psi) { return $null }
856
1395
  try { return [System.Diagnostics.Process]::Start($psi) } catch { return $null }
857
1396
  }
858
1397
 
1398
+ # ── «el número está, pero no se ve» ─────────────────────────────────────
1399
+ # Windows decide POR ÍCONO si va a la barra o al desplegable de escondidos, y a
1400
+ # los nuevos los manda al desplegable. Eso ya estaba dicho en el README como el
1401
+ # costo de la tira; lo que faltaba es que se enterara el usuario. Un ícono que
1402
+ # Windows escondió y un ícono que no arrancó se ven exactamente igual: nada. Es
1403
+ # la misma clase de silencio que motivó el repo, y macOS ya la cubre por el otro
1404
+ # lado con revisarSiSeVe() —la barra llena y la muesca— en bin/qm-barra.swift.
1405
+ #
1406
+ # Se puede MEDIR y no hay que suponerlo: cada item vive en
1407
+ # HKCU\Control Panel\NotifyIconSettings con su UID y un `IsPromoted` que vale 1
1408
+ # si está en la barra. El UID lo reparte WinForms y lo guarda en un campo
1409
+ # privado, así que se lee por reflexión — el mismo camino que ya se usa para
1410
+ # ShowContextMenu, y por la misma razón.
1411
+ $script:AvisoEscondido = $false
1412
+ $script:CampoUid = [System.Windows.Forms.NotifyIcon].GetField(
1413
+ 'id', [System.Reflection.BindingFlags]'Instance,NonPublic')
1414
+
1415
+ function RevisarSiSeVe {
1416
+ # Una sola vez por corrida: un ícono que el usuario esconde y muestra no tiene
1417
+ # que avisar en cada vuelta. Es la misma decisión que `avisoBarraLlena` en
1418
+ # Swift, y por el mismo motivo — ahí se tomó después de que avisara en bucle.
1419
+ if ($script:AvisoEscondido -or $null -eq $script:CampoUid) { return }
1420
+ if (-not $script:Bandeja.Count) { return }
1421
+
1422
+ $uids = @()
1423
+ foreach ($ni in @($script:Bandeja.Values)) {
1424
+ try { $uids += [int]$script:CampoUid.GetValue($ni) } catch { }
1425
+ }
1426
+ if (-not $uids.Count) { return }
1427
+
1428
+ # La clave guarda la ruta con un GUID de carpeta conocida adelante
1429
+ # ({1AC14E77-...}\WindowsPowerShell\v1.0\powershell.exe), así que se compara
1430
+ # por el nombre del ejecutable y se desempata por UID.
1431
+ try {
1432
+ $exe = [System.IO.Path]::GetFileName(
1433
+ [System.Diagnostics.Process]::GetCurrentProcess().MainModule.FileName)
1434
+ } catch { return }
1435
+
1436
+ $vistos = 0; $promovidos = 0
1437
+ try {
1438
+ foreach ($k in (Get-ChildItem 'HKCU:\Control Panel\NotifyIconSettings' -ErrorAction Stop)) {
1439
+ $p = Get-ItemProperty $k.PSPath -ErrorAction SilentlyContinue
1440
+ if ($null -eq $p) { continue }
1441
+ if (-not $p.PSObject.Properties['ExecutablePath']) { continue }
1442
+ if (-not $p.PSObject.Properties['UID']) { continue }
1443
+ if (([string]$p.ExecutablePath) -notlike "*\$exe") { continue }
1444
+ if ($uids -notcontains [int]$p.UID) { continue }
1445
+ $vistos++
1446
+ if ($p.PSObject.Properties['IsPromoted'] -and [int]$p.IsPromoted -eq 1) { $promovidos++ }
1447
+ }
1448
+ } catch { return }
1449
+
1450
+ # Cero vistos no es «está escondido», es «Windows todavía no los anotó»: se
1451
+ # vuelve a mirar en la vuelta siguiente en vez de avisar de algo que no se sabe.
1452
+ if ($vistos -eq 0 -or $promovidos -gt 0) { return }
1453
+ $script:AvisoEscondido = $true
1454
+ Globo 'quartermaster' `
1455
+ ('el número está, pero Windows dejó los íconos en el desplegable de ' +
1456
+ 'escondidos: arrastrá uno a la barra de tareas y se queda ahí. ' +
1457
+ 'Mientras tanto el panel se abre desde el desplegable.') $false
1458
+ }
1459
+
1460
+ # ── cuando el archivo cambia debajo ─────────────────────────────────────
1461
+ # `git pull`, `apt upgrade` y `npm update` reemplazan los archivos y se van; el
1462
+ # proceso que ya está corriendo tiene el guión LEÍDO y sigue igual hasta que
1463
+ # alguien lo reinicie a mano — que no lo hace nadie, porque la bandeja es
1464
+ # justamente lo que se deja andando y se olvida. Es vigilar_version() de
1465
+ # bin/qm-indicator.
1466
+ #
1467
+ # Va por sondeo y NO por FileSystemWatcher, al revés que la versión de GNOME.
1468
+ # Es la misma razón que explica el encabezado de este archivo: el guión puede
1469
+ # estar del otro lado del 9P de WSL —\\wsl.localhost\...— donde FileSystemWatcher
1470
+ # no es confiable. Y acá no cuesta nada: ya hay un tick cada 30 s.
1471
+ $script:Yo = $PSCommandPath
1472
+ $script:SelloYo = $null
1473
+ try { $script:SelloYo = (Get-Item $script:Yo).LastWriteTimeUtc } catch { }
1474
+
1475
+ function RevisarVersion {
1476
+ if ($SinAutoReinicio) { return }
1477
+ if (-not $script:Yo -or $null -eq $script:SelloYo) { return }
1478
+ try { $ahora = (Get-Item $script:Yo -ErrorAction Stop).LastWriteTimeUtc } catch { return }
1479
+ if ($ahora -eq $script:SelloYo) { return }
1480
+
1481
+ # Compila antes de saltar. Si la versión nueva está rota, reiniciar deja al
1482
+ # usuario SIN bandeja; quedarse con la vieja lo deja con una que anda. Entre
1483
+ # las dos, la que anda. Es la misma decisión que _reiniciar() en Python, y de
1484
+ # paso resuelve gratis el otro problema: un gestor de paquetes escribe en
1485
+ # varios pasos, y un archivo a medio escribir no parsea, así que esto es
1486
+ # también la espera a que la escritura termine.
1487
+ $errores = $null
1488
+ try {
1489
+ [System.Management.Automation.Language.Parser]::ParseFile(
1490
+ $script:Yo, [ref]$null, [ref]$errores) | Out-Null
1491
+ } catch { return }
1492
+ if ($errores -and $errores.Count) {
1493
+ # No se anota el sello: se vuelve a probar en la vuelta siguiente, que es
1494
+ # cuando el gestor de paquetes terminó de escribir.
1495
+ return
1496
+ }
1497
+
1498
+ $script:SelloYo = $ahora
1499
+ try {
1500
+ $exe = [System.Diagnostics.Process]::GetCurrentProcess().MainModule.FileName
1501
+ } catch { return }
1502
+ # `$args` no: es una variable automática de PowerShell y pisarla adentro de una
1503
+ # función es la clase de colisión silenciosa que este archivo ya tuvo dos veces.
1504
+ $lanzar = @('-NoProfile', '-ExecutionPolicy', 'Bypass', '-WindowStyle', 'Hidden',
1505
+ '-File', $script:Yo) + $script:MisArgs
1506
+ # El candado se suelta ANTES de lanzar: si no, la instancia nueva se encuentra
1507
+ # el nombre tomado por la vieja y se va enseguida, y el usuario se queda sin
1508
+ # bandeja — que es justo lo que las dos protecciones quieren evitar.
1509
+ SoltarCandado
1510
+ try {
1511
+ Start-Process -FilePath $exe -ArgumentList $lanzar -WindowStyle Hidden | Out-Null
1512
+ } catch {
1513
+ return # el candado ya se soltó, pero seguimos siendo la única viva
1514
+ }
1515
+ $script:Ctx.ExitThread()
1516
+ }
1517
+
859
1518
  # Abrir el panel a mano. `ShowContextMenu` es interno, así que va por reflexión;
860
1519
  # es lo mismo que hace el click izquierdo sobre un item.
861
1520
  function MostrarMenu($ni) {
@@ -890,11 +1549,15 @@ function ActualizarAhora {
890
1549
  if ($null -eq $proc) { Refrescar; return }
891
1550
  $script:EsperaProc = $proc
892
1551
  $script:EsperaDesde = Get-Date
893
- # La señal de que está pasando algo, en el item que se apretó.
894
- foreach ($it in @($script:Menu.Items)) {
895
- if ($it -is [System.Windows.Forms.ToolStripMenuItem] -and $it.Text -eq $ETIQUETA_ACTUALIZAR) {
896
- $it.Text = 'Actualizando…'
897
- $it.Enabled = $false
1552
+ # La señal de que está pasando algo, en el item que se apretó. Se pone en
1553
+ # TODOS los menús y no sólo en el visible: el calentado es uno para toda la
1554
+ # máquina, así que abrir otro ícono mientras corre tiene que mostrar lo mismo.
1555
+ foreach ($mn in @($script:Menus.Values)) {
1556
+ foreach ($it in @($mn.Items)) {
1557
+ if ($it -is [System.Windows.Forms.ToolStripMenuItem] -and $it.Text -eq $ETIQUETA_ACTUALIZAR) {
1558
+ $it.Text = 'Actualizando…'
1559
+ $it.Enabled = $false
1560
+ }
898
1561
  }
899
1562
  }
900
1563
  $script:Espera = New-Object System.Windows.Forms.Timer
@@ -929,6 +1592,51 @@ function FilaImagen($bmp) {
929
1592
  return $fila
930
1593
  }
931
1594
 
1595
+ # ── el pie que baja solo ────────────────────────────────────────────────
1596
+ # Cada cuenta dice de cuándo es su número; el pie dice cuándo deja de serlo.
1597
+ #
1598
+ # El panel de Windows se rehace entero cada 30 s, así que un número acá se
1599
+ # quedaría quieto medio minuto y después daría un salto — y una cuenta regresiva
1600
+ # que no se mueve no parece una cuenta regresiva, parece un número roto. Se
1601
+ # redibuja SÓLO este renglón una vez por segundo, y sólo mientras el panel está
1602
+ # abierto: el resto del panel no cambió, así que no hay nada más que rehacer.
1603
+ # Es la misma decisión que _tic() en bin/qm-indicator.
1604
+ # El mapa de bits del pie es UNO y lo comparten todos los menús —el mismo Image
1605
+ # se puede mostrar en varios PictureBox— así que el latido lo redibuja una vez
1606
+ # por segundo y no una vez por menú abierto.
1607
+ $script:PbPies = @()
1608
+ $script:BmpPie = $null
1609
+ $script:Latido = $null
1610
+
1611
+ function FaltaParaLectura {
1612
+ # Segundos hasta el próximo calentado, o $null si no hay uno previsto.
1613
+ if ($SinCalentar) { return $null }
1614
+ if ($script:UltimoCalentar -eq [datetime]::MinValue) { return $null }
1615
+ $falta = (Cadencia) - ((Get-Date) - $script:UltimoCalentar).TotalSeconds
1616
+ return [math]::Max(0, $falta)
1617
+ }
1618
+
1619
+ # El pie se dibuja UNA vez por vuelta y lo comparten todos los menús.
1620
+ #
1621
+ # Antes lo creaba ArmarMenu, o sea una vez POR MENÚ, y cada llamada liberaba el
1622
+ # bitmap anterior — el que el menú de la vuelta anterior acababa de recibir. Con
1623
+ # cuatro íconos, tres de los cuatro pies quedaban apuntando a una imagen muerta:
1624
+ # el renglón salía en blanco y, al repintarse, GDI+ tiraba «Parameter is not
1625
+ # valid». Es el mismo error de razonamiento que el de las tarjetas —liberar algo
1626
+ # que todavía tiene dueños— cometido dos veces en el mismo archivo.
1627
+ #
1628
+ # Ahora el dueño es uno solo: Refrescar lo crea, ArmarMenu lo usa, y el viejo se
1629
+ # libera con las tarjetas viejas, al final, cuando ya no lo mira nadie.
1630
+ function LatirPie {
1631
+ if (-not $script:PbPies.Count) { return }
1632
+ $falta = FaltaParaLectura
1633
+ if ($null -eq $falta) { return }
1634
+ $antes = $script:BmpPie
1635
+ $script:BmpPie = DibujarPieLectura $falta
1636
+ foreach ($pb in @($script:PbPies)) { try { $pb.Image = $script:BmpPie } catch { } }
1637
+ if ($antes) { try { $antes.Dispose() } catch { } }
1638
+ }
1639
+
932
1640
  function ItemTexto([string]$t) {
933
1641
  $it = New-Object System.Windows.Forms.ToolStripMenuItem($t)
934
1642
  $it.Enabled = $false
@@ -938,17 +1646,33 @@ function ItemTexto([string]$t) {
938
1646
  return $it
939
1647
  }
940
1648
 
941
- function RevisarAvisos([string]$perfil, $v, $proy, [bool]$chocas) {
942
- $base = "$perfil|$(NombreVentana $v)|$(AlMinuto $v.reinicia)"
943
- $pct = $v.porcentaje
944
- foreach ($u in $UMBRALES) {
945
- if ($pct -ge $u) {
946
- $seg = Faltan $v.reinicia
947
- $cola = if ($null -ne $seg) { " Se reinicia en $(Dur $seg)." } else { '' }
948
- Avisar "$base|$u" ("{0}: {1:d}% de {2}" -f $perfil, [int]$pct, (NombreVentana $v)) "Pasaste el $u%.$cola" ($u -ge 95)
1649
+ # Recorre TODAS las ventanas visibles, no sólo la que frena.
1650
+ #
1651
+ # Antes esto recibía una sola ventana —`frena`— y ahí se perdían avisos: `peor()`
1652
+ # en src/core/tipos.ts devuelve la más alta, así que con la sesión al 96 % y una
1653
+ # semanal al 85 % la bandeja avisaba de la sesión y de la semanal no decía nada.
1654
+ # Las otras dos siempre recorrieron la lista (revisarAvisos en qm-barra.swift,
1655
+ # revisar_avisos en qm-indicator); ésta era la que se había quedado corta, y es
1656
+ # justo lo contrario del principio de SOUL.md que dice leer todas las barras.
1657
+ function RevisarAvisos([string]$perfil, $ventanas, $frena, $proy, [bool]$chocas) {
1658
+ foreach ($v in @($ventanas)) {
1659
+ $nombre = NombreVentana $v
1660
+ $minuto = AlMinuto $v.reinicia
1661
+ $base = "$perfil|$nombre|$minuto"
1662
+ $pct = [double]$v.porcentaje
1663
+ foreach ($u in $UMBRALES) {
1664
+ if ($pct -ge $u) {
1665
+ $seg = Faltan $v.reinicia
1666
+ $cola = if ($null -ne $seg) { " Se reinicia en $(Dur $seg)." } else { '' }
1667
+ Avisar "$base|$u" ("{0}: {1:d}% de {2}" -f $perfil, [int][math]::Round($pct), $nombre) `
1668
+ "Pasaste el $u%.$cola" ($u -ge 95)
1669
+ }
949
1670
  }
1671
+ RevisarLiberada $perfil $v
950
1672
  }
951
- if ($chocas -and $proy) {
1673
+
1674
+ if ($chocas -and $proy -and $null -ne $frena) {
1675
+ $base = "$perfil|$(NombreVentana $frena)|$(AlMinuto $frena.reinicia)"
952
1676
  $seg = Faltan $proy.techo
953
1677
  if ($null -eq $seg) { $seg = 0 }
954
1678
  Avisar "$base|choque" "${perfil}: a este ritmo llegás al 100%" `
@@ -967,168 +1691,126 @@ function ActualizarTira($tira) {
967
1691
  $vivas = @()
968
1692
  foreach ($t in $tira) {
969
1693
  $vivas += $t.clave
970
- if ($script:Iconos.Contains($t.clave)) {
971
- $ni = $script:Iconos[$t.clave]
1694
+ if ($script:Bandeja.Contains($t.clave)) {
1695
+ $ni = $script:Bandeja[$t.clave]
972
1696
  } else {
973
1697
  $ni = New-Object System.Windows.Forms.NotifyIcon
974
- # Los items comparten el MISMO menú: hacer click en cualquiera abre el
975
- # panel completo, con todas las cuentas.
976
- $ni.ContextMenuStrip = $script:Menu
977
1698
  $ni.Add_MouseUp($script:AbrirMenu)
978
1699
  $ni.Visible = $true
979
- $script:Iconos[$t.clave] = $ni
1700
+ $script:Bandeja[$t.clave] = $ni
980
1701
  }
1702
+ # Cada ícono abre SU panel: el general muestra todas las cuentas y el de
1703
+ # una cuenta muestra esa sola. Antes todos compartían un único menú, así
1704
+ # que con cuatro íconos en la barra los cuatro abrían la misma pantalla y
1705
+ # el ícono que clickeabas no quería decir nada.
1706
+ $ni.ContextMenuStrip = $script:Menus[$t.clave]
981
1707
  $anterior = $ni.Icon
982
1708
  $ni.Icon = $t.icono
983
- if ($anterior) { $anterior.Dispose() }
1709
+ # El mismo objeto no se libera: con una tira reusada —que es lo que pasa si
1710
+ # alguien llama a esto dos veces con la misma lectura— `$anterior` ES el
1711
+ # ícono recién asignado, y soltarlo dejaría el item apuntando a un handle
1712
+ # muerto. Es el mismo error que ya costó dos bugs con los mapas de bits.
1713
+ if ($anterior -and -not [object]::ReferenceEquals($anterior, $t.icono)) { $anterior.Dispose() }
984
1714
  # NotifyIcon.Text no acepta más de 63 caracteres.
985
1715
  $texto = [string]$t.texto
986
1716
  if ($texto.Length -gt 63) { $texto = $texto.Substring(0, 60) + '...' }
987
1717
  $ni.Text = $texto
988
1718
  }
989
1719
 
990
- foreach ($clave in @($script:Iconos.Keys)) {
1720
+ foreach ($clave in @($script:Bandeja.Keys)) {
991
1721
  if ($vivas -contains $clave) { continue }
992
- $ni = $script:Iconos[$clave]
1722
+ $ni = $script:Bandeja[$clave]
993
1723
  $ni.Visible = $false
994
1724
  if ($ni.Icon) { $ni.Icon.Dispose() }
995
1725
  $ni.Dispose()
996
- $script:Iconos.Remove($clave)
1726
+ $script:Bandeja.Remove($clave)
997
1727
  }
998
- # El que emite los globos. Cualquiera sirve; tiene que estar visible.
999
- $script:Ni = if ($script:Iconos.Count) { @($script:Iconos.Values)[0] } else { $null }
1728
+ # El que emite los globos. Tiene que estar visible; se prefiere el general
1729
+ # porque es el que habla de la máquina entera, y si no está, el primero.
1730
+ $script:Ni = $null
1731
+ if ($script:Bandeja.Contains('general')) { $script:Ni = $script:Bandeja['general'] }
1732
+ elseif ($script:Bandeja.Count) { $script:Ni = @($script:Bandeja.Values)[0] }
1000
1733
  }
1001
1734
 
1002
- function Refrescar {
1735
+ # Un menú por clave, creado cuando hace falta.
1736
+ #
1737
+ # Todos comparten los handlers: se arman una sola vez y se enganchan acá, en vez
1738
+ # de repetir los bloques por menú — que es como se consiguen tres menús que se
1739
+ # comportan distinto sin que nadie lo haya decidido.
1740
+ function MenuDe([string]$clave) {
1741
+ if ($script:Menus.Contains($clave)) { return $script:Menus[$clave] }
1742
+ $mn = New-Object System.Windows.Forms.ContextMenuStrip
1743
+ # Sin esto el menú reserva una canaleta a la izquierda para tildes e íconos,
1744
+ # y el dibujo queda corrido y con un escalón que no es parte del diseño.
1745
+ $mn.ShowImageMargin = $false
1746
+ $mn.ShowCheckMargin = $false
1747
+ $mn.Add_ItemClicked($script:AlClickear)
1748
+ $mn.Add_Closing($script:AlCerrar)
1749
+ $mn.Add_Opened($script:AlAbrir)
1750
+ $mn.Add_Closed($script:AlCerrado)
1751
+ VestirMenu $mn ([bool]$script:MenuOscuro)
1752
+ $script:Menus[$clave] = $mn
1753
+ return $mn
1754
+ }
1755
+
1756
+ # Llena un menú: las tarjetas que le tocan, el pie y los tres botones.
1757
+ #
1758
+ # Es la MISMA función para el panel general y para el de una cuenta: lo único
1759
+ # que cambia es la lista de tarjetas que recibe. Con una función por caso, la
1760
+ # de la cuenta sola se hubiera quedado sin el pie y sin «Actualizar ahora» la
1761
+ # primera vez que alguien tocara una de las dos.
1762
+ function ArmarMenu($mn, $piezas, [string]$frase) {
1003
1763
  # Si el panel está abierto —«Actualizar ahora» lo deja así— hay que suspender
1004
1764
  # el layout mientras se cambian los items. Sin esto, cada Add() relayoutea y
1005
1765
  # reposiciona el menú visible: se ve saltar de tamaño una vez por sección.
1006
1766
  $abierto = $false
1007
- try { $abierto = $script:Menu.Visible } catch { $abierto = $false }
1008
- if ($abierto) { $script:Menu.SuspendLayout() }
1767
+ try { $abierto = $mn.Visible } catch { $abierto = $false }
1768
+ if ($abierto) { $mn.SuspendLayout() }
1009
1769
 
1010
- $datos = Leer
1011
- # Los dos temas, que son dos claves distintas del registro y pueden no
1012
- # coincidir. Si el de las apps cambió, AplicarTema rehace la paleta; el menú
1013
- # se redibuja igual acá abajo, así que no hace falta hacer nada más.
1014
- $null = AplicarTema
1015
- $script:BarraOscura = BarraOscura
1016
- $menu = $script:Menu
1017
1770
  # Items.Clear() saca los items de la lista pero no los libera, y acá se
1018
1771
  # reconstruye el menú entero cada tick.
1019
- foreach ($viejo in @($menu.Items)) { $viejo.Dispose() }
1020
- $menu.Items.Clear()
1021
- # Un PictureBox no libera su Image al morir, así que los mapas de bits del
1022
- # tick anterior se sueltan a mano. Con la cabecera son uno más por vuelta, y
1023
- # cada uno mide 340 px de ancho.
1024
- foreach ($b in @($script:Bitmaps)) { try { $b.Dispose() } catch { } }
1025
- $script:Bitmaps = @()
1026
-
1027
- $pico = 0.0
1028
- $script:MinutosAlTecho = $null
1029
- $mueven = @()
1030
- $tira = @()
1772
+ foreach ($viejo in @($mn.Items)) { $viejo.Dispose() }
1773
+ $mn.Items.Clear()
1031
1774
 
1032
- if ($datos -is [string]) {
1033
- $menu.Items.Add((ItemTexto $datos)) | Out-Null
1034
- # Sin datos no hay cuentas: queda un solo item, con el arco vacío.
1035
- $tira = @(@{ clave = '?'; icono = (HacerIcono 0 'atento'); texto = "qm · $datos" })
1775
+ if ($frase) {
1776
+ # Silencio es el bug: si no hay número, hay una frase.
1777
+ $mn.Items.Add((ItemTexto $frase)) | Out-Null
1036
1778
  } else {
1037
- $resumen = DibujarResumen $datos.perfiles
1038
- if ($resumen) {
1039
- $script:Bitmaps += $resumen
1040
- $menu.Items.Add((FilaImagen $resumen)) | Out-Null
1041
- $menu.Items.Add((New-Object System.Windows.Forms.ToolStripSeparator)) | Out-Null
1042
- }
1043
-
1044
- # El índice del color de cuenta avanza sólo con las que dejaron número,
1045
- # igual que iCuenta en qm-barra.swift: una cuenta muda no gasta un color,
1046
- # así que las que se ven conservan el suyo de una lectura a la otra.
1047
- $iCuenta = 0
1048
- foreach ($p in $datos.perfiles) {
1049
- $bmp = DibujarPerfil $p $iCuenta
1050
- $script:Bitmaps += $bmp
1051
- $menu.Items.Add((FilaImagen $bmp)) | Out-Null
1052
- $menu.Items.Add((New-Object System.Windows.Forms.ToolStripSeparator)) | Out-Null
1053
-
1054
- $cuota = $p.cuota
1055
- $nombre = Corto $p.perfil
1056
- # El del ÍCONO, que va sobre la barra de tareas y puede no ser el mismo.
1057
- $colorCuenta = ColorCuenta $iCuenta $script:BarraOscura
1058
-
1059
- # Un lugar en la tira POR PERFIL, tenga número o no.
1060
- #
1061
- # macOS puede dejar afuera a una cuenta muda porque su tira es un solo
1062
- # dibujo que se rehace entero. Acá cada lugar es un item de bandeja, y
1063
- # Windows lo identifica por el hash de (ejecutable + UID) donde el UID lo
1064
- # reparte WinForms POR ORDEN DE CREACIÓN. Medido en el registro, en
1065
- # Control Panel\NotifyIconSettings. O sea: sacar y volver a poner un item
1066
- # corre los UID de los que vienen después, y con eso se le muda de cuenta
1067
- # la decisión de "este ícono va fijo en la barra" que el usuario tomó
1068
- # arrastrándolo. Un lugar fijo por perfil, con el medidor vacío cuando no
1069
- # hay número, cuesta un cuadradito y salva esa decisión.
1070
- if ($cuota.estado -ne 'ok') {
1071
- $frase = if ($cuota.PSObject.Properties['frase']) { $cuota.frase } else { 'sin cuota' }
1072
- $tira += @{
1073
- clave = [string]$p.perfil
1074
- icono = (IconoCuenta $p.producto $colorCuenta $null 'ok')
1075
- texto = "$nombre · $frase"
1076
- }
1077
- continue
1078
- }
1079
- $iCuenta++
1080
-
1081
- $peor = $cuota.frena
1082
- $proy = $p.proyeccion
1083
- $chocas = [bool]($proy -and $proy.estado -eq 'sube' -and $proy.chocasAntesDelReinicio)
1084
- $viejo = if ($cuota.edadSegundos -gt $VIEJO_SEGUNDOS) { '~' } else { '' }
1085
-
1086
- # El medidor es SIEMPRE la semanal; el número de la sesión —que en macOS
1087
- # va al lado del medidor— acá no tiene dónde ir y se va al tooltip.
1088
- $ses = $cuota.sesion
1089
- $sem = $cuota.semanal
1090
- $nivelSem = if ($null -ne $sem) {
1091
- NivelDe ([int]$sem.porcentaje) `
1092
- ([bool]($sem.preocupa -or ($chocas -and $null -ne $peor -and $sem.clave -eq $peor.clave)))
1093
- } else { 'ok' }
1094
- $partes = @($nombre)
1095
- if ($null -ne $ses) { $partes += ('sesión {0}{1:d}%' -f $viejo, [int][math]::Round($ses.porcentaje)) }
1096
- if ($null -ne $sem) { $partes += ('{0} {1:d}%' -f (NombreVentana $sem), [int][math]::Round($sem.porcentaje)) }
1097
- $tira += @{
1098
- clave = [string]$p.perfil
1099
- icono = (IconoCuenta $p.producto $colorCuenta `
1100
- $(if ($null -ne $sem) { [int]$sem.porcentaje } else { $null }) $nivelSem)
1101
- texto = ($partes -join ' · ')
1102
- }
1103
-
1104
- if ($null -ne $peor) {
1105
- $pct = [double]$peor.porcentaje
1106
- if ($pct -ge 40) { $mueven += $nombre }
1107
- if ($pct -gt $pico) { $pico = $pct }
1108
- RevisarAvisos $nombre $peor $proy $chocas
1109
- }
1110
- if ($chocas) {
1111
- $seg = Faltan $proy.techo
1112
- if ($null -ne $seg) {
1113
- $min = $seg / 60
1114
- if ($null -eq $script:MinutosAlTecho -or $min -lt $script:MinutosAlTecho) { $script:MinutosAlTecho = $min }
1115
- }
1116
- }
1779
+ foreach ($b in @($piezas)) {
1780
+ $mn.Items.Add((FilaImagen $b)) | Out-Null
1781
+ $mn.Items.Add((New-Object System.Windows.Forms.ToolStripSeparator)) | Out-Null
1117
1782
  }
1783
+ }
1118
1784
 
1119
- $script:Alto = $pico
1120
- $script:CuentasQueMueven = $mueven
1785
+ # El pie va después de las tarjetas y antes de los botones, igual que en el
1786
+ # panel de GNOME. Su mapa de bits lo comparten todos los menús y lo reemplaza
1787
+ # el latido una vez por segundo, así que NO entra en $script:Bitmaps.
1788
+ if ($script:BmpPie) {
1789
+ $filaPie = FilaImagen $script:BmpPie
1790
+ $script:PbPies += $filaPie.Control
1791
+ $mn.Items.Add($filaPie) | Out-Null
1792
+ }
1121
1793
 
1122
- # Ahora cada perfil tiene su lugar, así que esto sólo salta si qm no
1123
- # encontró ni un perfil. La bandeja vacía es el silencio otra vez.
1124
- if (-not $tira.Count) {
1125
- $tira = @(@{ clave = '?'; icono = (HacerIcono 0 'atento'); texto = 'qm · sin cuota' })
1794
+ # El elegí-tus-íconos, en TODOS los paneles: se llega desde cualquier ícono,
1795
+ # que es lo que hace falta cuando el que sobra es justo el que estás mirando.
1796
+ # Un tilde por cuenta, más el general; clickear uno lo esconde o lo trae, se
1797
+ # guarda y se aplica en el acto — sin reiniciar nada.
1798
+ if (@($script:ClavesConocidas).Count) {
1799
+ $sub = New-Object System.Windows.Forms.ToolStripMenuItem('Íconos en la bandeja')
1800
+ $sub.ForeColor = $script:Tinta
1801
+ foreach ($k in @($script:ClavesConocidas)) {
1802
+ $rotulo = if ($k -eq 'general') { 'general (todas las cuentas)' } else { $k }
1803
+ $it = New-Object System.Windows.Forms.ToolStripMenuItem($rotulo)
1804
+ $it.Checked = QuieroIcono $k
1805
+ $it.ForeColor = $script:Tinta
1806
+ $it.Tag = $k
1807
+ $it.Add_Click({ AlternarIcono ([string]$this.Tag) })
1808
+ $sub.DropDownItems.Add($it) | Out-Null
1126
1809
  }
1810
+ VestirMenu $sub.DropDown ([bool]$script:MenuOscuro)
1811
+ $mn.Items.Add($sub) | Out-Null
1127
1812
  }
1128
1813
 
1129
- ActualizarTira $tira
1130
- SoltarGlobos
1131
-
1132
1814
  # El item que se apretó volvió a nacer con su texto normal, así que no hay
1133
1815
  # que deshacer el «Actualizando…»: se fue con el item viejo.
1134
1816
  foreach ($par in @(
@@ -1139,15 +1821,312 @@ function Refrescar {
1139
1821
  $it = New-Object System.Windows.Forms.ToolStripMenuItem($par.t)
1140
1822
  $it.ForeColor = $script:Tinta
1141
1823
  $it.Add_Click($par.a)
1142
- $menu.Items.Add($it) | Out-Null
1824
+ $mn.Items.Add($it) | Out-Null
1143
1825
  }
1144
1826
 
1145
1827
  if ($abierto) {
1146
- $script:Menu.ResumeLayout($true)
1828
+ $mn.ResumeLayout($true)
1147
1829
  # El panel cambió de alto, así que hay que reacomodarlo: sin esto se queda
1148
1830
  # con el tamaño de antes y recorta la última sección.
1149
- $script:Menu.PerformLayout()
1831
+ $mn.PerformLayout()
1832
+ }
1833
+ }
1834
+
1835
+ # ── qué íconos quiere el usuario, y que lo pueda decidir él ─────────────
1836
+ # Se guarda la lista de los ESCONDIDOS y no la de los visibles, a propósito: así
1837
+ # una cuenta nueva aparece sola. Al revés —guardando los visibles— un perfil que
1838
+ # se agrega después nacería invisible, y una cuenta que no se ve es exactamente
1839
+ # igual a una cuenta que va bien. El silencio otra vez, y encima permanente.
1840
+ $script:RutaIconos = Join-Path $env:LOCALAPPDATA 'quartermaster\iconos.json'
1841
+ $script:Ocultos = @{}
1842
+ $script:ClavesConocidas = @()
1843
+ try {
1844
+ if (Test-Path $script:RutaIconos) {
1845
+ $m = Get-Content $script:RutaIconos -Raw -Encoding UTF8 | ConvertFrom-Json
1846
+ if ($m.PSObject.Properties['ocultos']) {
1847
+ foreach ($k in @($m.ocultos)) { $script:Ocultos[[string]$k] = $true }
1848
+ }
1849
+ }
1850
+ } catch { $script:Ocultos = @{} } # sin memoria se ven todos, que es lo seguro
1851
+
1852
+ function GuardarOcultos {
1853
+ try {
1854
+ $dir = Split-Path $script:RutaIconos -Parent
1855
+ if (-not (Test-Path $dir)) { New-Item -ItemType Directory -Path $dir -Force | Out-Null }
1856
+ @{ ocultos = @($script:Ocultos.Keys | Sort-Object) } | ConvertTo-Json -Compress |
1857
+ Set-Content $script:RutaIconos -Encoding UTF8
1858
+ } catch { }
1859
+ }
1860
+
1861
+ function QuieroIcono([string]$clave) { return -not $script:Ocultos.ContainsKey($clave) }
1862
+
1863
+ function AlternarIcono([string]$clave) {
1864
+ if ($script:Ocultos.ContainsKey($clave)) {
1865
+ $script:Ocultos.Remove($clave)
1866
+ } else {
1867
+ # El último no se puede esconder. Una bandeja vacía no es una preferencia,
1868
+ # es la herramienta apagada sin decirlo — y desde una bandeja vacía no hay
1869
+ # menú desde donde volver a prenderla.
1870
+ $quedan = @(@($script:ClavesConocidas) | Where-Object { QuieroIcono $_ })
1871
+ if ($quedan.Count -le 1) { return }
1872
+ $script:Ocultos[$clave] = $true
1873
+ }
1874
+ GuardarOcultos
1875
+
1876
+ # Que el panel NO se cierre al tildar. Es el mismo mecanismo que «Actualizar
1877
+ # ahora»: WinForms cierra el menú al clickear cualquier item, y acá eso es
1878
+ # peor que en ningún lado — elegir qué íconos querés es justamente la tarea en
1879
+ # la que uno toca varios seguidos, y cerrar el panel después de cada tilde
1880
+ # obliga a volver a abrirlo una vez por cuenta.
1881
+ #
1882
+ # La bandera se prende acá y no en un handler del submenú: los eventos de un
1883
+ # ToolStripDropDown no suben al ContextMenuStrip, así que el padre nunca se
1884
+ # entera de qué nieto se clickeó. Quien sabe es esta función. El que cancela
1885
+ # sigue siendo AlCerrar, en el padre.
1886
+ $script:MantenerAbierto = $true
1887
+
1888
+ # Refrescar destruye los items del menú, incluido ÉSTE, que es desde donde
1889
+ # estamos corriendo. Se difiere un turno del bucle de mensajes — y para
1890
+ # entonces el cierre ya se canceló, así que rehace un menú VISIBLE, que es el
1891
+ # camino que ArmarMenu ya sabe manejar (SuspendLayout / PerformLayout).
1892
+ $t = New-Object System.Windows.Forms.Timer
1893
+ $t.Interval = 1
1894
+ $t.Add_Tick({ $this.Stop(); $this.Dispose(); Refrescar })
1895
+ $t.Start()
1896
+ }
1897
+
1898
+ # El modelo del panel: qué tarjetas van en cada ícono.
1899
+ #
1900
+ # Es modelo_panel() de bin/qm-indicator y existe por la misma razón: dibujar y
1901
+ # decidir-qué-dibujar son dos cosas, y el gate necesita la segunda sin bandeja.
1902
+ # Devuelve las tarjetas por clave, las frases de las cuentas mudas y la tira.
1903
+ #
1904
+ # Con $avisar en $false no notifica ni toca la cadencia: el modo captura arma
1905
+ # exactamente el mismo panel sin mandarle un globo a nadie.
1906
+ function ModeloPaneles($datos, [bool]$avisar) {
1907
+ $paneles = [ordered]@{}
1908
+ $frases = @{}
1909
+ $tira = @()
1910
+ $bitmaps = @()
1911
+
1912
+ if ($datos -is [string]) {
1913
+ # Sin datos no hay cuentas: queda el general solo, con el arco vacío.
1914
+ $paneles['general'] = @()
1915
+ $frases['general'] = $datos
1916
+ $tira += @{ clave = 'general'; icono = (IconoGeneral 0 'atento'); texto = "qm · $datos" }
1917
+ return @{ paneles = $paneles; frases = $frases; tira = $tira; bitmaps = $bitmaps }
1918
+ }
1919
+
1920
+ $pico = 0.0
1921
+ $alTecho = $null
1922
+ $mueven = @()
1923
+ $general = @()
1924
+
1925
+ $resumen = DibujarResumen $datos.perfiles
1926
+ if ($resumen) { $bitmaps += $resumen; $general += $resumen }
1927
+
1928
+ # El índice del color de cuenta avanza sólo con las que dejaron número, igual
1929
+ # que iCuenta en qm-barra.swift: una cuenta muda no gasta un color, así que
1930
+ # las que se ven conservan el suyo de una lectura a la otra.
1931
+ $iCuenta = 0
1932
+ $calladas = @()
1933
+ foreach ($p in $datos.perfiles) {
1934
+ $cuota = $p.cuota
1935
+ $nombre = Corto $p.perfil
1936
+ # El del ÍCONO, que va sobre la barra de tareas y puede no ser el mismo.
1937
+ $colorCuenta = ColorCuenta $iCuenta $script:BarraOscura
1938
+
1939
+ # Un lugar en la tira POR PERFIL, tenga número o no.
1940
+ #
1941
+ # macOS puede dejar afuera a una cuenta muda porque su tira es un solo
1942
+ # dibujo que se rehace entero. Acá cada lugar es un item de bandeja, y
1943
+ # Windows lo identifica por el hash de (ejecutable + UID) donde el UID lo
1944
+ # reparte WinForms POR ORDEN DE CREACIÓN. Medido en el registro, en
1945
+ # Control Panel\NotifyIconSettings. O sea: sacar y volver a poner un item
1946
+ # corre los UID de los que vienen después, y con eso se le muda de cuenta
1947
+ # la decisión de "este ícono va fijo en la barra" que el usuario tomó
1948
+ # arrastrándolo. Un lugar fijo por perfil, con el medidor vacío cuando no
1949
+ # hay número, cuesta un cuadradito y salva esa decisión.
1950
+ if ($cuota.estado -ne 'ok') {
1951
+ $frase = if ($cuota.PSObject.Properties['frase']) { $cuota.frase } else { 'sin cuota' }
1952
+ # En el PANEL general las mudas van juntas al final, en una sola tarjeta:
1953
+ # una tarjeta de 340 px por frase corta llenaba la pantalla de lo que NO
1954
+ # se sabe. En su panel propio va la frase sola, que es la respuesta
1955
+ # completa a por qué no hay número.
1956
+ $calladas += @{ nombre = $nombre; frase = $frase }
1957
+ # Su panel propio es la MISMA tarjeta que le toca en el general, con ella
1958
+ # sola adentro: así el menú y la captura dibujan lo mismo, que es la única
1959
+ # forma de que el gate esté comprobando lo que el usuario ve. Va aparte y
1960
+ # no reusa la tarjeta agrupada porque esa lleva las demás cuentas.
1961
+ $suya = DibujarSinCuota @(@{ nombre = $nombre; frase = $frase })
1962
+ $bitmaps += $suya
1963
+ $paneles[$nombre] = @($suya)
1964
+ $tira += @{
1965
+ clave = $nombre
1966
+ icono = (IconoCuenta $p.producto $colorCuenta $null 'ok')
1967
+ texto = "$nombre · $frase"
1968
+ }
1969
+ continue
1970
+ }
1971
+
1972
+ $bmp = DibujarPerfil $p $iCuenta
1973
+ $bitmaps += $bmp
1974
+ $general += $bmp
1975
+ $paneles[$nombre] = @($bmp)
1976
+ $iCuenta++
1977
+
1978
+ $peor = $cuota.frena
1979
+ $proy = $p.proyeccion
1980
+ $chocas = [bool]($proy -and $proy.estado -eq 'sube' -and $proy.chocasAntesDelReinicio)
1981
+ $viejo = if ($cuota.edadSegundos -gt $VIEJO_SEGUNDOS) { '~' } else { '' }
1982
+
1983
+ # El medidor es SIEMPRE la semanal; el número de la sesión —que en macOS va
1984
+ # al lado del medidor— acá no tiene dónde ir y se va al tooltip.
1985
+ $ses = $cuota.sesion
1986
+ $sem = $cuota.semanal
1987
+ $nivelSem = if ($null -ne $sem) {
1988
+ NivelDe ([int]$sem.porcentaje) `
1989
+ ([bool]($sem.preocupa -or ($chocas -and $null -ne $peor -and $sem.clave -eq $peor.clave)))
1990
+ } else { 'ok' }
1991
+ $partes = @($nombre)
1992
+ if ($null -ne $ses) { $partes += ('sesión {0}{1:d}%' -f $viejo, [int][math]::Round($ses.porcentaje)) }
1993
+ if ($null -ne $sem) { $partes += ('{0} {1:d}%' -f (NombreVentana $sem), [int][math]::Round($sem.porcentaje)) }
1994
+ $tira += @{
1995
+ clave = $nombre
1996
+ icono = (IconoCuenta $p.producto $colorCuenta `
1997
+ $(if ($null -ne $sem) { [int]$sem.porcentaje } else { $null }) $nivelSem)
1998
+ texto = ($partes -join ' · ')
1999
+ }
2000
+
2001
+ if ($avisar) { RevisarAvisos $nombre $cuota.mostrar $peor $proy $chocas }
2002
+ if ($null -ne $peor) {
2003
+ $pct = [double]$peor.porcentaje
2004
+ if ($pct -ge 40) { $mueven += $nombre }
2005
+ if ($pct -gt $pico) { $pico = $pct }
2006
+ }
2007
+ if ($chocas) {
2008
+ $seg = Faltan $proy.techo
2009
+ if ($null -ne $seg) {
2010
+ $min = $seg / 60
2011
+ if ($null -eq $alTecho -or $min -lt $alTecho) { $alTecho = $min }
2012
+ }
2013
+ }
2014
+ }
2015
+
2016
+ # Las mudas, todas juntas y al final del panel general: lo que no se sabe va
2017
+ # después de lo que sí.
2018
+ $sin = DibujarSinCuota $calladas
2019
+ if ($sin) { $bitmaps += $sin; $general += $sin }
2020
+
2021
+ if ($avisar) {
2022
+ $script:Alto = $pico
2023
+ $script:CuentasQueMueven = $mueven
2024
+ $script:MinutosAlTecho = $alTecho
2025
+ }
2026
+
2027
+ # El general va PRIMERO en la tira: Windows ordena los íconos por orden de
2028
+ # registro, así que éste es el orden en que aparecen, y el de la máquina
2029
+ # entera es el que uno busca cuando no sabe qué cuenta mirar.
2030
+ $nivelPico = NivelDe ([int][math]::Round($pico)) ([bool]($null -ne $alTecho))
2031
+ $paneles.Insert(0, 'general', $general)
2032
+ $tira = @(@{
2033
+ clave = 'general'
2034
+ icono = (IconoGeneral $pico $nivelPico)
2035
+ texto = ('quartermaster · {0} cuenta(s) · lo peor {1:d}%' -f $iCuenta, [int][math]::Round($pico))
2036
+ }) + $tira
2037
+ if (-not $general.Count) { $frases['general'] = 'qm no encontró ningún perfil' }
2038
+
2039
+ return @{ paneles = $paneles; frases = $frases; tira = $tira; bitmaps = $bitmaps }
2040
+ }
2041
+
2042
+ function Refrescar {
2043
+ $datos = Leer
2044
+ # Los dos temas, que son dos claves distintas del registro y pueden no
2045
+ # coincidir. Si el de las apps cambió, AplicarTema rehace la paleta y vuelve a
2046
+ # vestir todos los menús; se redibujan igual acá abajo.
2047
+ $null = AplicarTema
2048
+ $script:BarraOscura = BarraOscura
2049
+
2050
+ # Los mapas de bits del tick anterior se APARTAN acá y se liberan al final,
2051
+ # cuando ya no los mira nadie.
2052
+ #
2053
+ # Un PictureBox no libera su Image al morir, así que hay que soltarlos a mano
2054
+ # — pero soltarlos ACÁ fue un crash: entre este renglón y el ArmarMenu de más
2055
+ # abajo, los PictureBox de los menús siguen apuntando a los Bitmap viejos, y
2056
+ # si en ese hueco entra un repintado, GDI+ tira «Parameter is not valid» y
2057
+ # WinForms le muestra al usuario el cartel de excepción no manejada. El
2058
+ # original no tenía el problema porque liberaba los items del menú PRIMERO y
2059
+ # los bitmaps después; el refactor a varios menús invirtió el orden, y con N
2060
+ # menús compartiendo la misma tarjeta el hueco es más ancho todavía.
2061
+ #
2062
+ # Es el mismo cuidado que hay que tener con el pie del panel, aplicado donde
2063
+ # hacía falta: primero se dibuja lo nuevo, después se suelta lo viejo.
2064
+ $bitmapsViejos = @($script:Bitmaps)
2065
+ if ($script:BmpPie) { $bitmapsViejos += $script:BmpPie }
2066
+ $script:BmpPie = $null
2067
+ $script:Bitmaps = @()
2068
+ $script:PbPies = @()
2069
+
2070
+ $m = ModeloPaneles $datos $true
2071
+ $script:Bitmaps = $m.bitmaps
2072
+ $paneles = $m.paneles
2073
+ $frases = $m.frases
2074
+
2075
+ # Todas las claves que existen en esta lectura, escondidas o no: es lo que
2076
+ # lista el submenú, y sin esto no habría cómo volver a traer una escondida.
2077
+ $script:ClavesConocidas = @($m.tira | ForEach-Object { $_.clave })
2078
+
2079
+ # -Iconos siembra la elección UNA vez y después manda el menú. Así el flag
2080
+ # sigue sirviendo para arrancar con una combinación, pero no pelea contra lo
2081
+ # que el usuario elija después: sería un ajuste que se deshace solo en cada
2082
+ # arranque, que es peor que no tenerlo.
2083
+ if (@($script:BandejaPedidos).Count -and -not $script:PedidosAplicados) {
2084
+ $script:PedidosAplicados = $true
2085
+ $script:Ocultos = @{}
2086
+ foreach ($k in $script:ClavesConocidas) {
2087
+ if ($script:BandejaPedidos -notcontains $k.ToLower()) { $script:Ocultos[$k] = $true }
2088
+ }
2089
+ GuardarOcultos
2090
+ }
2091
+
2092
+ # El filtro. Se aplica a la TIRA y no a los paneles: el panel general sigue
2093
+ # mostrando todas las cuentas aunque no tengan ícono propio.
2094
+ $tira = @($m.tira | Where-Object { QuieroIcono $_.clave })
2095
+ if (-not $tira.Count) {
2096
+ # Una bandeja vacía es el silencio otra vez, y acá sería un silencio que se
2097
+ # causó el usuario con un -Iconos que no coincide con nada. Queda el general
2098
+ # y se dice por qué.
2099
+ $tira = @(@{ clave = 'general'; icono = (IconoGeneral 0 'atento')
2100
+ texto = 'quartermaster · no quedó ningún ícono elegido' })
2101
+ if (-not $paneles.Contains('general')) { $paneles['general'] = @() }
1150
2102
  }
2103
+
2104
+ # El pie, uno solo para todos los menús. Va antes de armarlos porque
2105
+ # ArmarMenu lo consume.
2106
+ $falta = FaltaParaLectura
2107
+ if ($null -ne $falta) { $script:BmpPie = DibujarPieLectura $falta }
2108
+
2109
+ # Los menús: uno por ícono que quedó, y se tiran los de los que ya no están.
2110
+ foreach ($t in $tira) {
2111
+ ArmarMenu (MenuDe $t.clave) $paneles[$t.clave] ([string]$frases[$t.clave])
2112
+ }
2113
+ $claves = @($tira | ForEach-Object { $_.clave })
2114
+ foreach ($clave in @($script:Menus.Keys)) {
2115
+ if ($claves -contains $clave) { continue }
2116
+ $mn = $script:Menus[$clave]
2117
+ foreach ($viejo in @($mn.Items)) { $viejo.Dispose() }
2118
+ $mn.Dispose()
2119
+ $script:Menus.Remove($clave)
2120
+ }
2121
+
2122
+ ActualizarTira $tira
2123
+ RevisarSiSeVe
2124
+ SoltarGlobos
2125
+ GuardarPrevios
2126
+
2127
+ # Recién ahora: todos los menús se rearmaron, así que ningún PictureBox sigue
2128
+ # apuntando a estos.
2129
+ foreach ($b in $bitmapsViejos) { try { $b.Dispose() } catch { } }
1151
2130
  }
1152
2131
 
1153
2132
  function AbrirTablero {
@@ -1159,72 +2138,218 @@ function AbrirTablero {
1159
2138
  $c.Close()
1160
2139
  } catch { $vivo = $false }
1161
2140
  if (-not $vivo) {
1162
- $psi = New-Object System.Diagnostics.ProcessStartInfo
1163
- $psi.FileName = 'wsl.exe'
1164
- $psi.Arguments = ArgsWsl "qm-web --sin-abrir --puerto=$Puerto"
1165
- $psi.UseShellExecute = $false
1166
- $psi.CreateNoWindow = $true
1167
- try { [System.Diagnostics.Process]::Start($psi) | Out-Null; Start-Sleep -Milliseconds 1200 } catch { }
2141
+ $psi = PsiQm "--sin-abrir --puerto=$Puerto" 'web'
2142
+ if ($null -ne $psi) {
2143
+ try { [System.Diagnostics.Process]::Start($psi) | Out-Null; Start-Sleep -Milliseconds 1200 } catch { }
2144
+ }
1168
2145
  }
1169
2146
  Start-Process "http://127.0.0.1:$Puerto"
1170
2147
  }
1171
2148
 
1172
2149
  # ── arranque ────────────────────────────────────────────────────────────
1173
2150
 
1174
- # El menú es uno solo y lo comparten todos los items de la tira, así que se
1175
- # arma antes que ellos.
1176
- $script:Menu = New-Object System.Windows.Forms.ContextMenuStrip
1177
- # Sin esto el menú reserva una canaleta a la izquierda para tildes e íconos, y
1178
- # el dibujo queda corrido y con un escalón que no es parte del diseño.
1179
- $script:Menu.ShowImageMargin = $false
1180
- $script:Menu.ShowCheckMargin = $false
1181
- $null = AplicarTema
2151
+ # Los argumentos con los que arrancamos, para poder relanzarnos iguales cuando
2152
+ # el archivo cambie debajo. Se reconstruyen de los parámetros ligados y no de
2153
+ # la línea original, que PowerShell no conserva de forma confiable.
2154
+ $script:MisArgs = @()
2155
+ foreach ($kv in $PSBoundParameters.GetEnumerator()) {
2156
+ if ($kv.Value -is [switch]) {
2157
+ if ($kv.Value.IsPresent) { $script:MisArgs += "-$($kv.Key)" }
2158
+ } else {
2159
+ $script:MisArgs += "-$($kv.Key)"
2160
+ $script:MisArgs += [string]$kv.Value
2161
+ }
2162
+ }
1182
2163
 
1183
- # Que «Actualizar ahora» no cierre el panel.
2164
+ # ── una bandeja por sesión, y la segunda se va ──────────────────────────
2165
+ # Sin esto, arrancarla dos veces —el arranque automático más un `make tray` a
2166
+ # mano, que es lo más fácil del mundo— deja DOS tiras enteras en la bandeja: un
2167
+ # ícono por cuenta repetido, los globos por duplicado, y los dos procesos
2168
+ # pisándose el mismo avisados.json y el mismo previos.json. En GNOME el mismo
2169
+ # problema se resuelve con un nombre en el bus (soy_el_unico en bin/qm-indicator)
2170
+ # y acá con un mutex nombrado, que es lo equivalente: si el proceso muere de
2171
+ # cualquier forma, Windows suelta el mutex solo. Un archivo con el PID hay que
2172
+ # limpiarlo, y nunca se limpia en el caso que importa.
1184
2173
  #
1185
- # WinForms cierra un menú al clickear cualquier item, y ahí se pierde justo lo
1186
- # que se venía a mirar. El cierre se puede cancelar, pero sólo se cancela para
1187
- # ESTE item: «Abrir tablero» y «Salir» tienen que seguir cerrándolo, y clickear
1188
- # afuera o apretar Escape también.
2174
+ # Global\ y no Local\: el alcance es la máquina y no la sesión de terminal.
2175
+ $script:Mutex = $null
2176
+ $script:TengoCandado = $false
2177
+
2178
+ function TomarCandado {
2179
+ $nuevo = $false
2180
+ try {
2181
+ $script:Mutex = New-Object System.Threading.Mutex($true, 'Global\ai.legios.quartermaster.tray', [ref]$nuevo)
2182
+ } catch {
2183
+ return $true # si el mutex no se puede crear, seguir es mejor que no arrancar
2184
+ }
2185
+ $script:TengoCandado = $nuevo
2186
+ return $nuevo
2187
+ }
2188
+
2189
+ function SoltarCandado {
2190
+ if (-not $script:TengoCandado -or $null -eq $script:Mutex) { return }
2191
+ $script:TengoCandado = $false
2192
+ try { $script:Mutex.ReleaseMutex() } catch { }
2193
+ try { $script:Mutex.Dispose() } catch { }
2194
+ $script:Mutex = $null
2195
+ }
2196
+
2197
+ # El modo captura no toca la bandeja ni el candado: dibuja, escribe y se va, así
2198
+ # que puede correr al lado de una bandeja viva (y en un runner de CI, donde no
2199
+ # hay ninguna).
2200
+ if (-not $Captura) {
2201
+ if (-not (TomarCandado)) {
2202
+ Write-Host 'ya hay una bandeja de quartermaster andando en esta máquina.'
2203
+ exit 0
2204
+ }
2205
+ }
2206
+
2207
+ # Qué íconos pidió el usuario. Vacío = todos, que es el caso normal.
2208
+ $script:BandejaPedidos = @(
2209
+ $Iconos -split ',' | ForEach-Object { $_.Trim().ToLower() } | Where-Object { $_ })
2210
+ $script:PedidosAplicados = $false
2211
+
2212
+ # Los handlers que comparten todos los menús. Se arman UNA vez y MenuDe los
2213
+ # engancha en cada menú nuevo.
2214
+ #
2215
+ # Que «Actualizar ahora» no cierre el panel: WinForms cierra un menú al clickear
2216
+ # cualquier item, y ahí se pierde justo lo que se venía a mirar. El cierre se
2217
+ # puede cancelar, pero sólo se cancela para ESE item: «Abrir tablero» y «Salir»
2218
+ # tienen que seguir cerrándolo, y clickear afuera o apretar Escape también.
1189
2219
  #
1190
2220
  # Hacen falta los dos handlers y no uno: ItemClicked corre antes que Closing y
1191
2221
  # es el único que sabe QUÉ se clickeó; Closing es el único que puede cancelar.
1192
2222
  $script:MantenerAbierto = $false
1193
- $script:Menu.Add_ItemClicked({
1194
- $script:MantenerAbierto = ($_.ClickedItem.Text -eq $ETIQUETA_ACTUALIZAR)
1195
- })
1196
- $script:Menu.Add_Closing({
1197
- if ($script:MantenerAbierto -and
1198
- $_.CloseReason -eq [System.Windows.Forms.ToolStripDropDownCloseReason]::ItemClicked) {
1199
- $_.Cancel = $true
1200
- }
1201
- $script:MantenerAbierto = $false
1202
- })
2223
+ # Sólo PRENDE la bandera, nunca la apaga: apagarla acá era un peligro de orden.
2224
+ # Un tilde del submenú la prende desde AlternarIcono, y si después llegara este
2225
+ # handler —por el item padre, o por la cascada de cierres— con un `=` la
2226
+ # apagaría justo antes de que AlCerrar la mire, y el panel se cerraría igual.
2227
+ # La apaga AlCerrar, que es el único que sabe que el cierre ya se resolvió.
2228
+ $script:AlClickear = {
2229
+ if ($_.ClickedItem.Text -eq $ETIQUETA_ACTUALIZAR) { $script:MantenerAbierto = $true }
2230
+ }
2231
+ $script:AlCerrar = {
2232
+ if ($script:MantenerAbierto -and
2233
+ $_.CloseReason -eq [System.Windows.Forms.ToolStripDropDownCloseReason]::ItemClicked) {
2234
+ $_.Cancel = $true
2235
+ }
2236
+ $script:MantenerAbierto = $false
2237
+ }
2238
+ # El latido del pie: sólo corre mientras hay un panel abierto, porque es lo
2239
+ # único que se mueve ahí y nadie lo mira cerrado.
2240
+ $script:AlAbrir = { if ($script:Latido) { $script:Latido.Start() } }
2241
+ $script:AlCerrado = { if ($script:Latido) { $script:Latido.Stop() } }
1203
2242
 
1204
- # La tira, indexada por perfil y en orden de aparición. Y el item que emite los
2243
+ # La tira, indexada por clave y en orden de aparición. Y el item que emite los
1205
2244
  # globos, que sale de ella.
1206
- $script:Iconos = [ordered]@{}
2245
+ #
2246
+ # Se llama $script:Bandeja y no $script:Iconos por la TERCERA colisión de
2247
+ # nombres de este archivo, y la peor de las tres: el parámetro -Iconos crea un
2248
+ # $script:Iconos tipado [string], así que asignarle un diccionario no fallaba —
2249
+ # lo CONVERTÍA a texto— y el error salía mucho después, al indexarlo, sin línea
2250
+ # ni nombre de variable. PowerShell no distingue mayúsculas y un parámetro vive
2251
+ # en el ámbito del script: cualquier $script:Algo que se llame como un parámetro
2252
+ # es el parámetro.
2253
+ $script:Bandeja = [ordered]@{}
1207
2254
  $script:Bitmaps = @()
1208
2255
  $script:Ni = $null
1209
2256
 
1210
2257
  # Click izquierdo también abre el menú: en la bandeja lo único que se ve es el
1211
2258
  # ícono, y esperar que el usuario adivine que va con botón derecho es la misma
1212
2259
  # clase de silencio que motivó el repo. `$this` es el item clickeado, que con
1213
- # varios en la tira ya no es siempre el mismo.
2260
+ # varios en la tira ya no es siempre el mismo — y ahora cada uno abre SU panel.
1214
2261
  $script:AbrirMenu = {
1215
2262
  if ($_.Button -eq [System.Windows.Forms.MouseButtons]::Left) { MostrarMenu $this }
1216
2263
  }
1217
2264
 
1218
- $script:Escala = [math]::Max(1.0, $script:Menu.DeviceDpi / 96.0)
2265
+ # El DPI sale de un menú cualquiera, así que se crea el general —que existe
2266
+ # siempre— antes de medir. AplicarTema viene después para que lo vista.
2267
+ $null = MenuDe 'general'
2268
+ $null = AplicarTema
2269
+ $script:Escala = [math]::Max(1.0, $script:Menus['general'].DeviceDpi / 96.0)
2270
+ # En modo captura la escala se fija: el DPI del runner no es el de nadie, y un
2271
+ # gate que mide píxeles necesita que la misma entrada dé el mismo tamaño en
2272
+ # todas las máquinas.
2273
+ if ($Captura) { $script:Escala = 1.0 }
1219
2274
  CrearFuentes
1220
2275
 
2276
+ # Un panel en un PNG, sin bandeja y sin bucle de mensajes.
2277
+ #
2278
+ # Arma las MISMAS piezas que Refrescar, con la misma ModeloPaneles y las mismas
2279
+ # funciones de dibujo: si esto dibujara por su cuenta, el gate estaría
2280
+ # comprobando un dibujo que nadie ve. Es capturar() de bin/qm-indicator y de
2281
+ # bin/qm-barra.swift, y existe por la razón que explica el comentario de esta
2282
+ # última: diseñar a ciegas fue el error.
2283
+ #
2284
+ # -Panel elige cuál: 'general' (el de todas las cuentas) o el nombre corto de
2285
+ # una, que es exactamente lo que muestra el ícono de esa cuenta.
2286
+ function Capturar([string]$ruta, [string]$cual) {
2287
+ $datos = Leer
2288
+ $m = ModeloPaneles $datos $false
2289
+ if (-not $cual) { $cual = 'general' }
2290
+ if (-not $m.paneles.Contains($cual)) {
2291
+ throw ("no hay panel '$cual'; los que hay: " + (@($m.paneles.Keys) -join ', '))
2292
+ }
2293
+
2294
+ $piezas = @($m.paneles[$cual])
2295
+ $frase = [string]$m.frases[$cual]
2296
+ if ($frase) {
2297
+ # Sólo el general puede quedarse sin tarjetas: es cuando qm no contestó, y
2298
+ # entonces lo que hay que dibujar es la frase del problema.
2299
+ throw "el panel '$cual' no tiene nada que dibujar: $frase"
2300
+ }
2301
+ # Un valor fijo y no la cadencia real: el pie tiene que salir igual en cada
2302
+ # corrida para que el gate pueda compararlo.
2303
+ $piezas += (DibujarPieLectura $SEGUNDOS_SONDEO)
2304
+ if (-not $piezas.Count) { throw 'el fixture no produjo ni una tarjeta' }
2305
+
2306
+ $ancho = ($piezas | ForEach-Object { $_.Width } | Measure-Object -Maximum).Maximum
2307
+ # Un píxel de separador entre piezas, que es lo que pone el menú.
2308
+ $alto = ($piezas | ForEach-Object { $_.Height } | Measure-Object -Sum).Sum + $piezas.Count - 1
2309
+
2310
+ $lienzo = Lienzo $ancho $alto
2311
+ $g = [System.Drawing.Graphics]::FromImage($lienzo)
2312
+ $g.Clear($script:Fondo)
2313
+ $brSep = New-Object System.Drawing.SolidBrush((Mezclar $script:Fondo $script:Tinta 0.22))
2314
+ $y = 0
2315
+ for ($i = 0; $i -lt $piezas.Count; $i++) {
2316
+ $g.DrawImageUnscaled($piezas[$i], 0, $y)
2317
+ $y += $piezas[$i].Height
2318
+ if ($i -lt $piezas.Count - 1) {
2319
+ $g.FillRectangle($brSep, 0, $y, [int]$ancho, 1)
2320
+ $y += 1
2321
+ }
2322
+ }
2323
+ $brSep.Dispose()
2324
+ $g.Dispose()
2325
+
2326
+ $dir = Split-Path $ruta -Parent
2327
+ if ($dir -and -not (Test-Path $dir)) { New-Item -ItemType Directory -Path $dir -Force | Out-Null }
2328
+ $lienzo.Save($ruta, [System.Drawing.Imaging.ImageFormat]::Png)
2329
+ Write-Host ("panel {0}: {1}x{2} en {3}" -f $cual, $lienzo.Width, $lienzo.Height, $ruta)
2330
+ Write-Host ("iconos: " + (@($m.tira | ForEach-Object { $_.clave }) -join ', '))
2331
+ foreach ($b in $m.bitmaps) { try { $b.Dispose() } catch { } }
2332
+ $lienzo.Dispose()
2333
+ }
2334
+
2335
+ if ($Captura) {
2336
+ Capturar $Captura $Panel
2337
+ exit 0
2338
+ }
2339
+
1221
2340
  $script:Ctx = New-Object System.Windows.Forms.ApplicationContext
1222
2341
 
1223
2342
  $timer = New-Object System.Windows.Forms.Timer
1224
2343
  $timer.Interval = $Segundos * 1000
1225
- $timer.Add_Tick({ $null = Calentar; Refrescar })
2344
+ # RevisarVersion va PRIMERO: si el archivo cambió, no tiene sentido gastar un
2345
+ # calentado y un redibujo con el código viejo antes de saltar al nuevo.
2346
+ $timer.Add_Tick({ RevisarVersion; $null = Calentar; Refrescar })
1226
2347
  $timer.Start()
1227
2348
 
2349
+ $script:Latido = New-Object System.Windows.Forms.Timer
2350
+ $script:Latido.Interval = 1000
2351
+ $script:Latido.Add_Tick({ LatirPie })
2352
+
1228
2353
  $null = Calentar
1229
2354
  Refrescar
1230
2355
 
@@ -1232,10 +2357,14 @@ try {
1232
2357
  [System.Windows.Forms.Application]::Run($script:Ctx)
1233
2358
  } finally {
1234
2359
  $timer.Stop()
1235
- foreach ($ni in @($script:Iconos.Values)) {
2360
+ $script:Latido.Stop()
2361
+ GuardarPrevios
2362
+ foreach ($ni in @($script:Bandeja.Values)) {
1236
2363
  $ni.Visible = $false
1237
2364
  if ($ni.Icon) { $ni.Icon.Dispose() }
1238
2365
  $ni.Dispose()
1239
2366
  }
1240
2367
  foreach ($b in @($script:Bitmaps)) { try { $b.Dispose() } catch { } }
2368
+ if ($script:BmpPie) { try { $script:BmpPie.Dispose() } catch { } }
2369
+ SoltarCandado
1241
2370
  }