@legios/quartermaster 0.1.3 → 0.1.5

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
@@ -44,7 +44,49 @@ param(
44
44
  [int]$Segundos = 30,
45
45
  [int]$Puerto = 7391,
46
46
  # Con esto no se le pide nada al endpoint: sólo se lee lo que haya en disco.
47
- [switch]$SinCalentar
47
+ [switch]$SinCalentar,
48
+
49
+ # Con esto la bandeja NO se relanza cuando el .ps1 cambia debajo.
50
+ #
51
+ # El reinicio automático existe para el caso del usuario —`git pull` o un
52
+ # gestor de paquetes reemplazan el archivo y si no, seguís con el código viejo
53
+ # para siempre— pero es hostil justo para quien está EDITANDO el archivo: cada
54
+ # guardado relanza la bandeja, y la relanza con el trabajo a medio hacer. El
55
+ # parseo previo atrapa un archivo roto; no atrapa uno que parsea y todavía no
56
+ # está terminado, que es la forma normal de un archivo mientras se lo escribe.
57
+ [switch]$SinAutoReinicio,
58
+
59
+ # Qué íconos poner en la bandeja, separados por coma.
60
+ #
61
+ # (vacío) el general MÁS uno por cuenta — lo que se ve por defecto
62
+ # general sólo el general, con todas las cuentas adentro
63
+ # main,codex sólo esas dos cuentas, sin general
64
+ # general,codex el general y codex
65
+ #
66
+ # El general lleva la marca de quartermaster y su panel es el de siempre:
67
+ # todas las cuentas, con la cabecera de lo primero que te frena. Los de cada
68
+ # cuenta llevan el glifo de su producto y su panel muestra ESA cuenta sola.
69
+ # Con cuatro cuentas en una barra de tareas angosta, cuatro paneles completos
70
+ # es cuatro veces la misma pantalla; el que importa es el que se abrió.
71
+ [string]$Iconos = '',
72
+
73
+ # ── el modo del gate ──────────────────────────────────────────────────
74
+ # Dibuja contra un JSON fijo, escribe el PNG y sale, sin bandeja ni menú ni
75
+ # bucle de mensajes. Es el equivalente de `--desde` y `--captura` en
76
+ # bin/qm-indicator, y existe por la misma razón: con una entrada fija lo que
77
+ # sale es comparable entre corridas y entre máquinas, así que se puede medir
78
+ # en CI. Sin esto, de las 1200 líneas de este archivo el CI comprobaba UNA
79
+ # función —la escalera de duración— y un error de dibujo en cualquier otra
80
+ # pasaba en verde.
81
+ [string]$Desde = '',
82
+ [string]$Captura = '',
83
+ # Cuál panel dibujar: 'general' o el nombre corto de una cuenta. Es la forma
84
+ # de comprobar, sin bandeja, que el ícono de una cuenta muestra ESA cuenta.
85
+ [string]$Panel = '',
86
+ # El tema es una lectura del registro, y en un runner de CI no está el que
87
+ # uno quiere comprobar. En modo captura se fuerza a mano.
88
+ [switch]$Oscuro,
89
+ [switch]$Claro
48
90
  )
49
91
 
50
92
  Set-StrictMode -Version Latest
@@ -89,6 +131,38 @@ public static extern bool SetProcessDPIAware();
89
131
  # Sin esto Windows estira el mapa de bits del menú y todo sale borroso.
90
132
  try { [Qm.Nativo]::SetProcessDPIAware() | Out-Null } catch { }
91
133
 
134
+ # Que una excepción en el hilo de la interfaz NO mate la bandeja.
135
+ #
136
+ # Por defecto WinForms le muestra al usuario el cartel morado de «Unhandled
137
+ # exception has occurred in your application», y si aprieta Quit —o si el cartel
138
+ # aparece con la máquina bloqueada y nadie lo ve— la bandeja desaparece. Una
139
+ # bandeja muerta no deja ícono, y un ícono que no está se lee exactamente igual
140
+ # que una cuenta que va bien: es el silencio del que habla la primera sección
141
+ # del README, con otra causa.
142
+ #
143
+ # Así que se atrapa, se sigue andando con lo que había, y se DICE: una línea a
144
+ # stderr siempre —que es lo único que explica por qué un tick no actualizó— y un
145
+ # globo la primera vez, para que el usuario se entere sin tener que ir a buscar
146
+ # un log. Una sola vez: un repintado que falla lo hace muchas veces seguidas.
147
+ #
148
+ # Va acá arriba de todo a propósito: SetUnhandledExceptionMode se niega a correr
149
+ # una vez que existe la primera ventana del hilo.
150
+ [System.Windows.Forms.Application]::SetUnhandledExceptionMode(
151
+ [System.Windows.Forms.UnhandledExceptionMode]::CatchException)
152
+ $script:AvisoTropiezo = $false
153
+ [System.Windows.Forms.Application]::add_ThreadException({
154
+ param($quien, $ev)
155
+ [Console]::Error.WriteLine("[qm-tray] $($ev.Exception.GetType().Name): $($ev.Exception.Message)")
156
+ [Console]::Error.WriteLine($ev.Exception.StackTrace)
157
+ if (-not $script:AvisoTropiezo) {
158
+ $script:AvisoTropiezo = $true
159
+ try {
160
+ Globo 'quartermaster' ("la bandeja tropezó dibujando y sigue andando con lo anterior: " +
161
+ $ev.Exception.Message) $false
162
+ } catch { }
163
+ }
164
+ })
165
+
92
166
  # El texto del item que refresca. Está en una constante porque lo comparan el
93
167
  # handler que cancela el cierre y el que pone «Actualizando…», y un literal
94
168
  # repetido en tres lados es un renombre que rompe dos de ellos en silencio.
@@ -172,6 +246,10 @@ function BarraOscura {
172
246
  #
173
247
  # Se relee en cada tick, igual que el de la barra de tareas.
174
248
  function TemaAppsOscuro {
249
+ # Forzado desde la línea de comandos: el gate tiene que poder pedir los dos
250
+ # temas en una máquina que no es la de nadie.
251
+ if ($Oscuro) { return $true }
252
+ if ($Claro) { return $false }
175
253
  try {
176
254
  $v = Get-ItemProperty -ErrorAction Stop -Name AppsUseLightTheme `
177
255
  -Path 'HKCU:\SOFTWARE\Microsoft\Windows\CurrentVersion\Themes\Personalize'
@@ -179,6 +257,11 @@ function TemaAppsOscuro {
179
257
  } catch { return $false } # sin la clave, claro: es lo que hacía antes
180
258
  }
181
259
 
260
+ # Un menú por ícono de la bandeja, indexado por la misma clave que el ícono:
261
+ # 'general' y el nombre corto de cada cuenta. Se declara acá arriba porque
262
+ # AplicarTema lo recorre y puede correr antes de que exista ninguno.
263
+ $script:Menus = [ordered]@{}
264
+
182
265
  # Los tonos del menú de Windows 11 en oscuro. En claro se siguen usando los del
183
266
  # sistema, que ahí sí son los correctos.
184
267
  $script:MenuOscuro = $null
@@ -211,23 +294,30 @@ function AplicarTema {
211
294
  $script:Tinta2 = Mezclar $script:Tinta $script:Fondo 0.38
212
295
  $script:Tinta3 = Mezclar $script:Tinta $script:Fondo 0.58
213
296
  $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
- }
297
+ if ($oscuro) {
298
+ [QmTabla]::Fondo = $script:Fondo
299
+ [QmTabla]::Resalte = Mezclar $script:Fondo $script:Tinta 0.12
300
+ [QmTabla]::Borde = Mezclar $script:Fondo $script:Tinta 0.22
227
301
  }
302
+ # Ahora hay un menú POR ÍCONO, así que el tema se aplica a todos: con uno
303
+ # solo actualizado, abrir otro ícono te daba el panel del tema anterior.
304
+ foreach ($mn in @($script:Menus.Values)) { VestirMenu $mn $oscuro }
228
305
  return $true
229
306
  }
230
307
 
308
+ function VestirMenu($mn, [bool]$oscuro) {
309
+ if ($null -eq $mn) { return }
310
+ $mn.BackColor = $script:Fondo
311
+ $mn.ForeColor = $script:Tinta
312
+ if ($oscuro) {
313
+ $mn.Renderer = New-Object System.Windows.Forms.ToolStripProfessionalRenderer((New-Object QmTabla))
314
+ } else {
315
+ # De vuelta al de fábrica: la tabla oscura sobre un menú claro se ve
316
+ # igual de mal que al revés.
317
+ $mn.RenderMode = [System.Windows.Forms.ToolStripRenderMode]::ManagerRenderMode
318
+ }
319
+ }
320
+
231
321
  # ── formato ─────────────────────────────────────────────────────────────
232
322
 
233
323
  function Corto([string]$nombre) {
@@ -259,6 +349,42 @@ function Dur([int]$segundos) {
259
349
  return "${segundos}s"
260
350
  }
261
351
 
352
+ function CuentaRegresiva([double]$segundos) {
353
+ # Como Dur, pero sin tirar los segundos abajo de la hora.
354
+ #
355
+ # Dur habla de duraciones que se REPORTAN —«reinicia en 2d14h»— y ahí los
356
+ # segundos son ruido. Esto es un reloj que baja a la vista: si dijera sólo los
357
+ # minutos cambiaría una vez por minuto, y una cuenta regresiva que no se mueve
358
+ # no parece una cuenta regresiva, parece un número roto. Es cuenta_regresiva()
359
+ # de bin/qm-indicator, y por eso NO entra en el gate de duraciones: es otra
360
+ # escalera a propósito.
361
+ $seg = [int][math]::Max(0, $segundos)
362
+ if ($seg -ge 3600) { return (Dur $seg) }
363
+ if ($seg -ge 60) { return ('{0}m {1:d2}s' -f [int][math]::Floor($seg / 60), ($seg % 60)) }
364
+ return "${seg}s"
365
+ }
366
+
367
+ function CadaCuanto($historia) {
368
+ # Cada cuánto se lee la cuota DE VERDAD, en segundos.
369
+ #
370
+ # No es la cadencia que este programa se propone: es la MEDIDA. El historial
371
+ # se indexa por `medidoEn` —el instante que informa el servidor, no el momento
372
+ # en que qm miró el disco— así que los huecos entre muestras son intervalos
373
+ # entre lectura y lectura reales. Va la MEDIANA y no el promedio: una sola
374
+ # pausa larga (la máquina suspendida) desplaza el promedio y no dice nada del
375
+ # ritmo normal. Es cada_cuanto() de bin/qm-indicator.
376
+ $ts = @(@($historia) | ForEach-Object { [double]$_.t } | Sort-Object)
377
+ if ($ts.Count -lt 2) { return $null }
378
+ $huecos = @()
379
+ for ($i = 1; $i -lt $ts.Count; $i++) {
380
+ $d = $ts[$i] - $ts[$i - 1]
381
+ if ($d -gt 0) { $huecos += $d }
382
+ }
383
+ if (-not $huecos.Count) { return $null }
384
+ $huecos = @($huecos | Sort-Object)
385
+ return $huecos[[int][math]::Floor($huecos.Count / 2)] / 1000
386
+ }
387
+
262
388
  function Faltan($iso) {
263
389
  if (-not $iso) { return $null }
264
390
  try { $cuando = [datetimeoffset]::Parse($iso) } catch { return $null }
@@ -273,6 +399,17 @@ function AlMinuto($iso) {
273
399
  try { return ([datetimeoffset]::Parse($iso)).ToString('yyyy-MM-ddTHH:mm') } catch { return $iso }
274
400
  }
275
401
 
402
+ function Reinicio($segundos) {
403
+ # «reinicia en vencido» no es castellano. Cuando ya pasó, se dice que pasó.
404
+ #
405
+ # Es reinicio() de bin/qm-indicator. Se ve en cuanto se mira una captura con
406
+ # una ventana ya reiniciada —el fixture tiene tres— y no se ve leyendo el
407
+ # código, que es por lo que sobrevivió acá después de estar arreglado allá.
408
+ if ($null -eq $segundos) { return '' }
409
+ if ($segundos -lt 0) { return 'reinicio vencido' }
410
+ return "reinicia en $(Dur $segundos)"
411
+ }
412
+
276
413
  function NombreVentana($v) {
277
414
  if ($v.nombre) { return $v.nombre }
278
415
  if ($v.alcance) { return "$($v.clave) ($($v.alcance))" }
@@ -284,7 +421,11 @@ function FraseRitmo($p) {
284
421
  if (-not $p) { return $null }
285
422
  if ($p.estado -eq 'sube') {
286
423
  $seg = Faltan $p.techo
287
- if ($null -eq $seg) { $seg = 0 }
424
+ # Una proyección con el techo en el PASADO ya no proyecta nada: se leía
425
+ # «100 % en vencido», que no quiere decir nada. Cuando ya tocaste el techo
426
+ # la pregunta es cuándo te liberás, y ésa la contesta la cabecera del panel.
427
+ # Mismo criterio que VistaCuenta.ritmo en bin/qm-indicator.
428
+ if ($null -eq $seg -or $seg -le 0) { return $null }
288
429
  # Invariante y no la cultura de la máquina: con `n1`, una Windows en
289
430
  # español escribe «1,8 pts/h» y una en inglés «1.8», así que las pantallas
290
431
  # dejaban de coincidir entre sí y con macOS, que usa %.1f. El separador de
@@ -298,6 +439,26 @@ function FraseRitmo($p) {
298
439
  return "todavía no sé el ritmo: $($p.motivo)"
299
440
  }
300
441
 
442
+ # El presupuesto diario: cuánto se puede gastar por día para que la ventana
443
+ # larga llegue entera al reinicio, y cuánto de eso queda hoy.
444
+ #
445
+ # Llega dividido del núcleo, incluido CUÁL ventana se reparte —la larga, nunca
446
+ # la de 5 h, que se reinicia cuatro veces por día y ahí «por día» no quiere
447
+ # decir nada—. Acá no se divide: se escribe.
448
+ function FrasePresupuesto($pre) {
449
+ if (-not $pre) { return $null }
450
+ # El JSON de una versión anterior de `qm` no trae el campo, y con StrictMode
451
+ # leer una propiedad que no está es una excepción en el hilo de la interfaz.
452
+ if (-not $pre.PSObject.Properties['estado']) { return $null }
453
+ if ($pre.estado -ne 'ok') { return "presupuesto: $($pre.motivo)" }
454
+ # Invariante y no la cultura de la máquina, por lo mismo que el ritmo: el
455
+ # separador decimal acá es parte del dibujo y tiene que coincidir entre
456
+ # pantallas.
457
+ $porDia = ([double]$pre.porDia).ToString('0.0', [cultureinfo]::InvariantCulture)
458
+ $hoy = ([double]$pre.quedaHoy).ToString('0.0', [cultureinfo]::InvariantCulture)
459
+ return "podés gastar $porDia %/día · hoy te queda $hoy %"
460
+ }
461
+
301
462
  # ── avisos ──────────────────────────────────────────────────────────────
302
463
  # La clave incluye el instante de reinicio: cuando la ventana se reinicia la
303
464
  # clave cambia sola y el mismo umbral puede volver a avisar. Sin eso, o
@@ -313,6 +474,16 @@ try {
313
474
  }
314
475
  } catch { $script:Vistos = @{} } # sin memoria se avisa de más, no de menos
315
476
 
477
+ $script:Globos = @()
478
+
479
+ function Globo([string]$titulo, [string]$cuerpo, [bool]$urgente) {
480
+ # No se muestra acá: se encola. Un globo necesita un item VISIBLE que lo
481
+ # emita, y los items se crean después de dibujar —recién ahí se sabe cuántas
482
+ # cuentas hay—. Mostrarlo en el momento perdía justo el aviso del primer
483
+ # tick, que es el que llega cuando arrancás la máquina ya frenado.
484
+ $script:Globos += @{ titulo = $titulo; cuerpo = $cuerpo; urgente = $urgente }
485
+ }
486
+
316
487
  function Avisar([string]$clave, [string]$titulo, [string]$cuerpo, [bool]$urgente) {
317
488
  if ($script:Vistos.ContainsKey($clave)) { return }
318
489
  $script:Vistos[$clave] = $true
@@ -321,14 +492,67 @@ function Avisar([string]$clave, [string]$titulo, [string]$cuerpo, [bool]$urgente
321
492
  if (-not (Test-Path $dir)) { New-Item -ItemType Directory -Path $dir -Force | Out-Null }
322
493
  ($script:Vistos.Keys | Sort-Object) | ConvertTo-Json | Set-Content $script:RutaAvisos -Encoding UTF8
323
494
  } 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 }
495
+ Globo $titulo $cuerpo $urgente
329
496
  }
330
497
 
331
- $script:Globos = @()
498
+ # ── la memoria de la vuelta anterior ────────────────────────────────────
499
+ # Cuánto valía cada barra la última vez, para poder ver que se REINICIÓ.
500
+ #
501
+ # Un porcentaje solo no dice nada de eso: 3 % puede ser «recién empezás» o
502
+ # «acabás de salir de estar contra el techo», y la diferencia es justo lo que
503
+ # hay que avisar. Se guarda el minuto de reinicio junto al número: cuando el
504
+ # minuto cambia, la ventana es otra. Es Previos de bin/qm-indicator y
505
+ # previos.json de bin/qm-barra.swift, que era lo único de los avisos que la
506
+ # bandeja no tenía.
507
+
508
+ $script:RutaPrevios = Join-Path $env:LOCALAPPDATA 'quartermaster\previos.json'
509
+ $script:Previos = @{}
510
+ try {
511
+ if (Test-Path $script:RutaPrevios) {
512
+ $m = Get-Content $script:RutaPrevios -Raw -Encoding UTF8 | ConvertFrom-Json
513
+ foreach ($prop in $m.PSObject.Properties) { $script:Previos[$prop.Name] = @($prop.Value) }
514
+ }
515
+ } catch { $script:Previos = @{} } # sin memoria no se avisa de más: no se avisa
516
+
517
+ $script:PreviosSucio = $false
518
+
519
+ function GuardarPrevios {
520
+ if (-not $script:PreviosSucio) { return }
521
+ $script:PreviosSucio = $false
522
+ try {
523
+ $dir = Split-Path $script:RutaPrevios -Parent
524
+ if (-not (Test-Path $dir)) { New-Item -ItemType Directory -Path $dir -Force | Out-Null }
525
+ $script:Previos | ConvertTo-Json -Compress | Set-Content $script:RutaPrevios -Encoding UTF8
526
+ } catch { }
527
+ }
528
+
529
+ function RevisarLiberada([string]$perfil, $v) {
530
+ # El aviso que faltaba: YA PODÉS VOLVER A TRABAJAR.
531
+ #
532
+ # Todo lo demás avisa cuando subís. Éste avisa cuando la ventana se reinicia
533
+ # habiendo estado contra el techo, que es el único momento en que la noticia
534
+ # sirve para hacer algo distinto ahora mismo — y es justamente cuando dejaste
535
+ # de mirar la barra, porque no había nada que mirar.
536
+ #
537
+ # No pasa por Avisar: la deduplicación de Avisar es para siempre, y acá la
538
+ # condición ya es un FLANCO —sólo se cumple en la vuelta en que el minuto
539
+ # cambia— así que anotarla en `avisados.json` la silenciaría para el próximo
540
+ # reinicio, que es el que sí hay que avisar.
541
+ $clave = "$perfil|$(NombreVentana $v)"
542
+ $minuto = AlMinuto $v.reinicia
543
+ $pct = [double]$v.porcentaje
544
+ $antes = $script:Previos[$clave]
545
+ $script:Previos[$clave] = @($minuto, $pct)
546
+ $script:PreviosSucio = $true
547
+ if ($null -eq $antes -or @($antes).Count -ne 2) { return }
548
+ $minutoAntes = [string]@($antes)[0]
549
+ $pctAntes = [double]@($antes)[1]
550
+ # Ventana nueva, y en la anterior estabas contra el techo.
551
+ if ($minuto -eq $minutoAntes -or $pctAntes -lt 80 -or $pct -ge $pctAntes) { return }
552
+ Globo "${perfil}: se reinició $(NombreVentana $v)" `
553
+ ("Estabas {0:d} % y ahora vas {1:d} %." -f [int][math]::Round($pctAntes), [int][math]::Round($pct)) `
554
+ $false
555
+ }
332
556
 
333
557
  function SoltarGlobos {
334
558
  if (-not $script:Ni) { $script:Globos = @(); return }
@@ -351,16 +575,39 @@ $MARGEN = 15
351
575
  $ALTO_CABECERA = 17 + 14 + 8 # título + subtítulo + aire
352
576
  $ALTO_BARRA = 15 + 3 + 5 + 4 + 12 + 7
353
577
  $ALTO_RITMO = 16
354
- $ALTO_FRASE = 30
578
+ # El renglón del presupuesto diario, debajo del ritmo: mismo cuerpo de letra.
579
+ $ALTO_PRESUPUESTO = 16
355
580
  # 6 de aire + 16 de curva + 12 para los rótulos de abajo, igual que
356
581
  # VistaCuenta.ALTO_CURVA en Swift. Si esto no coincide con lo que dibuja
357
582
  # DibujarPerfil, los rótulos se comen el renglón siguiente.
358
583
  $ALTO_CURVA = 34
359
584
  # El anillo (44) más el aire de arriba y abajo: el alto de VistaResumen.
360
585
  $ALTO_RESUMEN = 74
586
+ # El renglón de «lecturas: cada ~5m · última hace 2m», que contesta «¿este
587
+ # número de cuándo es?» — una pregunta que un porcentaje no contesta.
588
+ $ALTO_LECTURAS = 15
589
+ # El renglón de «próxima lectura en 4m 12s», que va al pie del panel entero.
590
+ $ALTO_PIE = 20
361
591
 
362
592
  function Px([double]$v) { return [float]($v * $script:Escala) }
363
593
 
594
+ # Un Bitmap, con las dimensiones acotadas a 1 px como PISO.
595
+ #
596
+ # GDI+ tira «Parameter is not valid» si una dimensión es 0 — comprobado: el
597
+ # constructor de Bitmap(340, 0) da exactamente ese texto— y esa excepción, en el
598
+ # hilo de la interfaz, es el cartel morado de .NET que mata la bandeja entera.
599
+ # Una bandeja muerta no deja ícono, y un ícono que no está se lee igual que una
600
+ # cuenta que va bien: el silencio otra vez.
601
+ #
602
+ # Un lienzo de 1 px no dibuja nada y se nota, pero es un renglón vacío y no una
603
+ # aplicación cerrada. Que un alto dé 0 sigue siendo un bug de medida, y lo
604
+ # agarra scripts/gate-bandeja.ps1, que mide los píxeles que salen.
605
+ function Lienzo($ancho, $alto) {
606
+ return New-Object System.Drawing.Bitmap(
607
+ [int][math]::Max(1, [math]::Round([double]$ancho)),
608
+ [int][math]::Max(1, [math]::Round([double]$alto)))
609
+ }
610
+
364
611
  function CrearFuentes {
365
612
  $f = { param($px, $estilo) New-Object System.Drawing.Font('Segoe UI', (Px $px), $estilo, [System.Drawing.GraphicsUnit]::Pixel) }
366
613
  $script:FTitulo = & $f 14 ([System.Drawing.FontStyle]::Bold)
@@ -369,7 +616,6 @@ function CrearFuentes {
369
616
  $script:FActiva = & $f 12 ([System.Drawing.FontStyle]::Bold)
370
617
  $script:FPct = & $f 12 ([System.Drawing.FontStyle]::Bold)
371
618
  $script:FPie = & $f 10 ([System.Drawing.FontStyle]::Regular)
372
- $script:FFrase = & $f 11 ([System.Drawing.FontStyle]::Regular)
373
619
  $script:FRotulo = & $f 9 ([System.Drawing.FontStyle]::Bold)
374
620
  $script:FMini = & $f 9 ([System.Drawing.FontStyle]::Regular)
375
621
  $script:FCifra = & $f 20 ([System.Drawing.FontStyle]::Bold)
@@ -387,14 +633,36 @@ function RectRedondeado($g, $rect, [float]$r, $brocha) {
387
633
  $p.Dispose()
388
634
  }
389
635
 
390
- function Escribir($g, [string]$t, [float]$x, [float]$y, $fuente, $color, [float]$derecha = -1) {
636
+ # Escribe una línea. Con $ancho, la RECORTA con puntos suspensivos.
637
+ #
638
+ # GDI+ no recorta nada cuando se dibuja en un punto —igual que Cairo— así que un
639
+ # nombre de perfil más largo que la tarjeta se dibujaba por encima del borde y
640
+ # se salía del panel, y un nombre de ventana largo se metía por debajo del
641
+ # porcentaje de la derecha y quedaban los dos ilegibles. Se ve con el fixture de
642
+ # nombres largos y no se ve mirando el código, que es por lo que el panel de
643
+ # GNOME tiene un gate que mide los píxeles del margen en vez de confiar en el ojo.
644
+ function Escribir($g, [string]$t, [float]$x, [float]$y, $fuente, $color,
645
+ [float]$derecha = -1, [float]$ancho = -1) {
391
646
  if (-not $t) { return }
392
647
  $br = New-Object System.Drawing.SolidBrush($color)
393
648
  if ($derecha -ge 0) {
394
649
  $an = $g.MeasureString($t, $fuente).Width
650
+ if ($ancho -gt 0 -and $an -gt $ancho) { $an = $ancho }
395
651
  $x = $derecha - $an
396
652
  }
397
- $g.DrawString($t, $fuente, $br, $x, $y)
653
+ if ($ancho -gt 0) {
654
+ $fmt = New-Object System.Drawing.StringFormat
655
+ $fmt.Trimming = [System.Drawing.StringTrimming]::EllipsisCharacter
656
+ $fmt.FormatFlags = [System.Drawing.StringFormatFlags]::NoWrap
657
+ # El alto de UNA línea, del tipo de letra y no del texto: MeasureString de
658
+ # una cadena larga devuelve el alto que ocuparía envuelta, y con eso la caja
659
+ # dejaba de ser de una línea justo en el caso que hay que recortar.
660
+ $caja = New-Object System.Drawing.RectangleF($x, $y, $ancho, $fuente.GetHeight($g))
661
+ $g.DrawString($t, $fuente, $br, $caja, $fmt)
662
+ $fmt.Dispose()
663
+ } else {
664
+ $g.DrawString($t, $fuente, $br, $x, $y)
665
+ }
398
666
  $br.Dispose()
399
667
  }
400
668
 
@@ -493,24 +761,46 @@ function DibujarCurva($g, $historia, [string]$nivel, $caja) {
493
761
  Escribir $g $cola 0 ($caja.Bottom + (Px 1)) $script:FMini $script:Tinta3 $caja.Right
494
762
  }
495
763
 
764
+ # «lecturas: cada ~5m · última hace 2m».
765
+ #
766
+ # La pregunta «¿este número de cuándo es?» no la contesta un porcentaje, y la
767
+ # edad del cache sola tampoco: «hace 40 minutos» es tranquilizador si se lee
768
+ # cada hora y alarmante si se lee cada cinco minutos. Las dos juntas sí. Es
769
+ # VistaCuenta.lecturas de bin/qm-indicator.
770
+ function FraseLecturas($cuota) {
771
+ if ($cuota.estado -ne 'ok') { return $null }
772
+ $partes = @()
773
+ $cada = CadaCuanto $cuota.historia
774
+ if ($null -ne $cada) { $partes += "cada ~$(Dur ([int]$cada))" }
775
+ if ($cuota.PSObject.Properties['edadSegundos'] -and $null -ne $cuota.edadSegundos) {
776
+ $e = [int]$cuota.edadSegundos
777
+ $partes += "última hace $(Dur $e)" + $(if ($e -ge $VIEJO_SEGUNDOS) { ' · viejo' } else { '' })
778
+ }
779
+ if (-not $partes.Count) { return $null }
780
+ return 'lecturas: ' + ($partes -join ' · ')
781
+ }
782
+
783
+ function Presupuesto($p) {
784
+ if (-not $p.PSObject.Properties['presupuesto']) { return $null }
785
+ return $p.presupuesto
786
+ }
787
+
496
788
  function AltoPerfil($p) {
497
789
  $alto = (Px $MARGEN) + (Px $ALTO_CABECERA)
498
790
  $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
- }
791
+ $alto += (Px $ALTO_BARRA) * (@($cuota.mostrar)).Count
792
+ # La curva es de la barra que frena, así que suma una vez y no por barra.
793
+ if ((@($cuota.historia)).Count -ge 3) { $alto += (Px $ALTO_CURVA) }
794
+ if (FraseRitmo $p.proyeccion) { $alto += (Px $ALTO_RITMO) }
795
+ if (FrasePresupuesto (Presupuesto $p)) { $alto += (Px $ALTO_PRESUPUESTO) }
796
+ if (FraseLecturas $cuota) { $alto += (Px $ALTO_LECTURAS) }
507
797
  return [int]($alto + (Px 10))
508
798
  }
509
799
 
510
800
  function DibujarPerfil($p, [int]$indice) {
511
801
  $ancho = [int](Px $ANCHO_VISTA)
512
802
  $alto = AltoPerfil $p
513
- $bmp = New-Object System.Drawing.Bitmap($ancho, $alto)
803
+ $bmp = Lienzo $ancho $alto
514
804
  $g = [System.Drawing.Graphics]::FromImage($bmp)
515
805
  $g.SmoothingMode = [System.Drawing.Drawing2D.SmoothingMode]::AntiAlias
516
806
  $g.TextRenderingHint = [System.Drawing.Text.TextRenderingHint]::ClearTypeGridFit
@@ -523,26 +813,21 @@ function DibujarPerfil($p, [int]$indice) {
523
813
  # El del MENÚ, que va sobre el fondo del menú.
524
814
  $colorCuenta = ColorCuenta $indice $script:MenuOscuro
525
815
  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
816
+ $anchoCabecera = $der - $m - (Px 19)
817
+ Escribir $g (Corto $p.perfil) ($m + (Px 19)) $y $script:FTitulo $script:Tinta -1 $anchoCabecera
527
818
  $y += Px 17
528
819
 
529
820
  $partes = @()
530
821
  if ($p.cuenta) { $partes += $p.cuenta }
531
822
  if ($p.plan) { $partes += $p.plan }
532
- Escribir $g ($partes -join ' · ') ($m + (Px 19)) $y $script:FSub $script:Tinta3
823
+ Escribir $g ($partes -join ' · ') ($m + (Px 19)) $y $script:FSub $script:Tinta3 -1 $anchoCabecera
533
824
  $y += Px 22
534
825
 
826
+ # Acá sólo llegan cuentas CON número: las mudas van a DibujarSinCuota, que
827
+ # las junta en una tarjeta sola. Esta función tenía una rama para dibujarles
828
+ # la frase y quedó muerta con ese cambio; se saca en vez de dejarla, porque
829
+ # una rama que no se ejecuta es una rama que nadie va a notar cuando se rompa.
535
830
  $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
831
  $peor = $cuota.frena
547
832
  $chocas = [bool]($p.proyeccion -and $p.proyeccion.estado -eq 'sube' -and $p.proyeccion.chocasAntesDelReinicio)
548
833
 
@@ -552,9 +837,14 @@ function DibujarPerfil($p, [int]$indice) {
552
837
  $activa = [bool]$v.activa
553
838
 
554
839
  $nombre = if ($activa) { (NombreVentana $v) + ' ▸' } else { NombreVentana $v }
840
+ # El porcentaje se dibuja PRIMERO —es lo que se viene a leer— y el nombre se
841
+ # recorta contra el hueco que dejó. Al revés, un nombre de ventana largo se
842
+ # metía por debajo del número y quedaban los dos ilegibles.
843
+ $cifra = '{0:d}%' -f [int][math]::Round($v.porcentaje)
844
+ Escribir $g $cifra 0 $y $script:FPct $script:Tinta $der
845
+ $anchoNombre = $der - $m - $g.MeasureString($cifra, $script:FPct).Width - (Px 8)
555
846
  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
847
+ $(if ($activa) { $script:Tinta } else { $script:Tinta2 }) -1 $anchoNombre
558
848
  $y += Px 18
559
849
 
560
850
  # El medidor: pista tenue y relleno con el color del estado.
@@ -569,16 +859,12 @@ function DibujarPerfil($p, [int]$indice) {
569
859
  $brLleno.Dispose()
570
860
  $y += Px 9
571
861
 
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
862
+ # La edad del cache ya NO va acá: se mudó al renglón de «lecturas», abajo,
863
+ # donde va acompañada de cada cuánto se lee. Sola decía la mitad —«hace
864
+ # 40 m» es tranquilizador si se lee cada hora y alarmante si se lee cada
865
+ # cinco minutos— y encima la repetía una vez por perfil en el renglón de
866
+ # una barra que no es la suya.
867
+ Escribir $g (Reinicio (Faltan $v.reinicia)) $m $y $script:FPie $script:Tinta3
582
868
  $y += Px 19
583
869
 
584
870
  # La curva va pegada a la barra que frena: es de ella, no del perfil.
@@ -591,7 +877,22 @@ function DibujarPerfil($p, [int]$indice) {
591
877
 
592
878
  $ritmo = FraseRitmo $p.proyeccion
593
879
  if ($ritmo) {
594
- Escribir $g $ritmo $m $y $script:FPie $(if ($chocas) { $PALETA['critico'] } else { $script:Tinta3 })
880
+ Escribir $g $ritmo $m $y $script:FPie `
881
+ $(if ($chocas) { $PALETA['critico'] } else { $script:Tinta3 }) -1 ($der - $m)
882
+ $y += Px $ALTO_RITMO
883
+ }
884
+
885
+ # El ritmo dice hacia dónde vas; el presupuesto, a cuánto tendrías que ir para
886
+ # que la cuota llegue al reinicio. Van pegados: son la misma pregunta.
887
+ $presupuesto = FrasePresupuesto (Presupuesto $p)
888
+ if ($presupuesto) {
889
+ Escribir $g $presupuesto $m $y $script:FPie $script:Tinta2 -1 ($der - $m)
890
+ $y += Px $ALTO_PRESUPUESTO
891
+ }
892
+
893
+ $lecturas = FraseLecturas $cuota
894
+ if ($lecturas) {
895
+ Escribir $g $lecturas $m $y $script:FPie $script:Tinta3 -1 ($der - $m)
595
896
  }
596
897
 
597
898
  $g.Dispose()
@@ -624,7 +925,7 @@ function DibujarResumen($perfiles) {
624
925
 
625
926
  $ancho = [int](Px $ANCHO_VISTA)
626
927
  $alto = [int](Px $ALTO_RESUMEN)
627
- $bmp = New-Object System.Drawing.Bitmap($ancho, $alto)
928
+ $bmp = Lienzo $ancho $alto
628
929
  $g = [System.Drawing.Graphics]::FromImage($bmp)
629
930
  $g.SmoothingMode = [System.Drawing.Drawing2D.SmoothingMode]::AntiAlias
630
931
  $g.TextRenderingHint = [System.Drawing.Text.TextRenderingHint]::ClearTypeGridFit
@@ -648,18 +949,22 @@ function DibujarResumen($perfiles) {
648
949
  $lap.Dispose()
649
950
 
650
951
  $x = $m + $lado + (Px 14)
651
- Escribir $g 'LO PRIMERO QUE TE FRENA' $x (Px 11) $script:FRotulo $script:Tinta3
952
+ $der = $ancho - $m
953
+ Escribir $g 'LO PRIMERO QUE TE FRENA' $x (Px 11) $script:FRotulo $script:Tinta3 -1 ($der - $x)
652
954
  $cifra = '{0:d}%' -f $pct
653
955
  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.
956
+ # El nombre va a la derecha de la cifra, apoyado en su misma línea de base, y
957
+ # recortado contra el margen: es el texto más largo del panel —perfil más
958
+ # ventana— y era el que primero se salía.
959
+ $xNombre = $x + $g.MeasureString($cifra, $script:FCifra).Width
655
960
  Escribir $g (' {0} · {1}' -f (Corto $mejorP.perfil), (NombreVentana $mejor)) `
656
- ($x + $g.MeasureString($cifra, $script:FCifra).Width) (Px 30) $script:FSub $script:Tinta2
961
+ $xNombre (Px 30) $script:FSub $script:Tinta2 -1 ($der - $xNombre)
657
962
 
658
963
  # Cuando ya te frenó, lo que importa no es cuándo «reinicia»: es cuándo
659
964
  # volvés a poder trabajar. Es la misma fecha y una pregunta distinta.
660
965
  $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)" }
966
+ $texto = if ($pct -ge 95 -and $null -ne $seg -and $seg -gt 0) { "libre en $(Dur $seg)" }
967
+ elseif ($null -ne $seg) { Reinicio $seg }
663
968
  else { 'sin reinicio informado' }
664
969
  Escribir $g $texto $x (Px 50) $script:FPie $(if ($pct -ge 95) { $c } else { $script:Tinta3 })
665
970
 
@@ -667,6 +972,79 @@ function DibujarResumen($perfiles) {
667
972
  return $bmp
668
973
  }
669
974
 
975
+ # Las cuentas que no dejaron número, JUNTAS en una tarjeta.
976
+ #
977
+ # Es VistaSinCuota de bin/qm-indicator. Antes cada perfil mudo se llevaba una
978
+ # tarjeta entera de 340 px para decir una línea, y con cuatro perfiles el panel
979
+ # se iba de pantalla mostrando sobre todo lo que NO se sabe. La respuesta a
980
+ # «¿por qué esta cuenta no tiene número?» es una frase corta, y cuatro frases
981
+ # cortas son una lista, no cuatro tarjetas.
982
+ #
983
+ # Ojo: esto agrupa el PANEL solamente. En la bandeja cada perfil mudo conserva
984
+ # su propio item, y eso es a propósito — está explicado en Refrescar.
985
+ function DibujarSinCuota($calladas) {
986
+ $cal = @($calladas)
987
+ if (-not $cal.Count) { return $null }
988
+
989
+ $ancho = [int](Px $ANCHO_VISTA)
990
+ $m = Px $MARGEN
991
+ $der = $ancho - $m
992
+
993
+ # Medir antes de dibujar: el alto depende de cuántas líneas ocupa cada frase.
994
+ $medidor = New-Object System.Drawing.Bitmap(1, 1)
995
+ $gm = [System.Drawing.Graphics]::FromImage($medidor)
996
+ $altos = @()
997
+ foreach ($c in $cal) {
998
+ $an = $der - $m - (Px 84)
999
+ $altos += [math]::Max((Px 15), $gm.MeasureString($c.frase, $script:FPie, [int]$an).Height)
1000
+ }
1001
+ $gm.Dispose(); $medidor.Dispose()
1002
+
1003
+ $alto = [int]((Px $MARGEN) + (Px 15) + ($altos | Measure-Object -Sum).Sum + (Px ($cal.Count * 5)) + (Px 10))
1004
+ $bmp = Lienzo $ancho $alto
1005
+ $g = [System.Drawing.Graphics]::FromImage($bmp)
1006
+ $g.SmoothingMode = [System.Drawing.Drawing2D.SmoothingMode]::AntiAlias
1007
+ $g.TextRenderingHint = [System.Drawing.Text.TextRenderingHint]::ClearTypeGridFit
1008
+ $g.Clear($script:Fondo)
1009
+
1010
+ $y = Px $MARGEN
1011
+ Escribir $g 'SIN NÚMERO' $m $y $script:FRotulo $script:Tinta3
1012
+ $y += Px 15
1013
+
1014
+ for ($i = 0; $i -lt $cal.Count; $i++) {
1015
+ $c = $cal[$i]
1016
+ Escribir $g $c.nombre $m $y $script:FNombre $script:Tinta2 -1 (Px 78)
1017
+ $caja = New-Object System.Drawing.RectangleF(
1018
+ ($m + (Px 84)), $y, ($der - $m - (Px 84)), $altos[$i])
1019
+ $br = New-Object System.Drawing.SolidBrush($script:Tinta3)
1020
+ $g.DrawString($c.frase, $script:FPie, $br, $caja)
1021
+ $br.Dispose()
1022
+ $y += $altos[$i] + (Px 5)
1023
+ }
1024
+
1025
+ $g.Dispose()
1026
+ return $bmp
1027
+ }
1028
+
1029
+ # El pie del panel: CUÁNDO DEJA DE SER CIERTO ESTE NÚMERO.
1030
+ #
1031
+ # Cada cuenta dice de cuándo es su número; esto dice cuándo deja de serlo. Es
1032
+ # la otra mitad de la misma pregunta, y es el renglón que baja solo mientras el
1033
+ # panel está abierto — por eso se dibuja aparte y no adentro de una tarjeta.
1034
+ function DibujarPieLectura([double]$falta) {
1035
+ $ancho = [int](Px $ANCHO_VISTA)
1036
+ $alto = [int](Px $ALTO_PIE)
1037
+ $bmp = Lienzo $ancho $alto
1038
+ $g = [System.Drawing.Graphics]::FromImage($bmp)
1039
+ $g.SmoothingMode = [System.Drawing.Drawing2D.SmoothingMode]::AntiAlias
1040
+ $g.TextRenderingHint = [System.Drawing.Text.TextRenderingHint]::ClearTypeGridFit
1041
+ $g.Clear($script:Fondo)
1042
+ Escribir $g "próxima lectura en $(CuentaRegresiva $falta)" (Px $MARGEN) (Px 4) `
1043
+ $script:FPie $script:Tinta3
1044
+ $g.Dispose()
1045
+ return $bmp
1046
+ }
1047
+
670
1048
  # ── los íconos de la bandeja ────────────────────────────────────────────
671
1049
  # Nunca un número, y uno por cuenta.
672
1050
  #
@@ -682,38 +1060,57 @@ function DibujarResumen($perfiles) {
682
1060
  # a mirar. En un item de bandeja no cabe, porque no tiene etiqueta de texto y
683
1061
  # es un cuadrado de 16x16. Así que la tira se reparte: un item por cuenta, con
684
1062
  # 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.
1063
+ # en el tooltip. Y arriba de todos, el general, que dice lo de la máquina entera
1064
+ # con la marca — incluso cuando qm no contesta y es el único que queda.
687
1065
  #
688
1066
  # La pista es gris al 41 % de alfa a propósito: la barra de tareas puede ser
689
1067
  # clara u oscura y el ícono no se entera, así que un gris translúcido es lo
690
1068
  # único que se ve en las dos.
691
1069
 
692
- function HacerIcono([double]$pct, [string]$nivel) {
1070
+ # El ícono general: la marca de quartermaster, que ya es un medidor.
1071
+ #
1072
+ # El logo (docs/logo-mono.svg) es un anillo INCOMPLETO con una cola en diagonal
1073
+ # —un manómetro—, así que la marca y el medidor son el mismo dibujo: el arco se
1074
+ # llena hasta el peor porcentaje de la máquina y se pinta con el color de ese
1075
+ # estado, y la cola va siempre porque es lo que hace que se lea como la marca y
1076
+ # no como un donut más. Un logo que nunca cambia de color sería una marca y no
1077
+ # un indicador, y en una bandeja el ícono tiene que decir algo de un vistazo.
1078
+ #
1079
+ # Las medidas salen del SVG, que está en un viewBox de 64: centro (32,32),
1080
+ # radio 20, trazo 9, cola de (41,41) a (51.5,51.5). Acá se dibuja a 32 px, o
1081
+ # sea la mitad de todo.
1082
+ function IconoGeneral([double]$pct, [string]$nivel) {
693
1083
  $lado = 32
694
- $grosor = 8.0
695
- $bmp = New-Object System.Drawing.Bitmap($lado, $lado)
1084
+ $k = $lado / 64.0
1085
+ $bmp = Lienzo $lado $lado
696
1086
  $g = [System.Drawing.Graphics]::FromImage($bmp)
697
1087
  $g.SmoothingMode = [System.Drawing.Drawing2D.SmoothingMode]::AntiAlias
698
1088
  $g.Clear([System.Drawing.Color]::Transparent)
699
1089
 
700
- $m = $grosor / 2 + 0.5
701
- $caja = New-Object System.Drawing.RectangleF($m, $m, ($lado - 2 * $m), ($lado - 2 * $m))
1090
+ $grosor = [float](9 * $k)
1091
+ $r = 20 * $k
1092
+ $c = 32 * $k
1093
+ $caja = New-Object System.Drawing.RectangleF(($c - $r), ($c - $r), (2 * $r), (2 * $r))
1094
+
1095
+ # La pista, igual que en el logo: el mismo trazo al 20 %. Gris y no del color
1096
+ # del estado, porque la barra de tareas puede ser clara u oscura.
702
1097
  $lapPista = New-Object System.Drawing.Pen([System.Drawing.Color]::FromArgb(105, 128, 128, 128), $grosor)
703
1098
  $g.DrawEllipse($lapPista, $caja)
704
1099
 
705
- $lap = New-Object System.Drawing.Pen($PALETA[$nivel], $grosor)
1100
+ $col = $PALETA[$nivel]
1101
+ $lap = New-Object System.Drawing.Pen($col, $grosor)
706
1102
  $lap.StartCap = [System.Drawing.Drawing2D.LineCap]::Round
707
1103
  $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)))
1104
+ # El logo abre el anillo a los 240°, así que el medidor llena ESE recorrido y
1105
+ # no los 360: el hueco de arriba a la izquierda es parte de la marca.
1106
+ $barrido = [float]([math]::Max(4, [math]::Min(240, $pct * 2.4)))
711
1107
  $g.DrawArc($lap, $caja, -90, $barrido)
712
1108
 
1109
+ # La cola, que es lo que distingue la marca de un anillo cualquiera.
1110
+ $g.DrawLine($lap, [float](41 * $k), [float](41 * $k), [float](51.5 * $k), [float](51.5 * $k))
1111
+
713
1112
  $h = $bmp.GetHicon()
714
1113
  $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
1114
  $clon = $ico.Clone()
718
1115
  [Qm.Nativo]::DestroyIcon($h) | Out-Null
719
1116
  $ico.Dispose(); $g.Dispose(); $bmp.Dispose(); $lapPista.Dispose(); $lap.Dispose()
@@ -732,7 +1129,7 @@ function HacerIcono([double]$pct, [string]$nivel) {
732
1129
  # a 16 cuando hace falta. Por eso el trazo del glifo va explícito y grueso.
733
1130
  function IconoCuenta([string]$producto, $colorCuenta, $semanal, [string]$nivelSemanal) {
734
1131
  $lado = 32
735
- $bmp = New-Object System.Drawing.Bitmap($lado, $lado)
1132
+ $bmp = Lienzo $lado $lado
736
1133
  $g = [System.Drawing.Graphics]::FromImage($bmp)
737
1134
  $g.SmoothingMode = [System.Drawing.Drawing2D.SmoothingMode]::AntiAlias
738
1135
  $g.Clear([System.Drawing.Color]::Transparent)
@@ -778,6 +1175,17 @@ function ArgsWsl([string]$cmd) {
778
1175
  function Leer {
779
1176
  # Devuelve el objeto del JSON, o un string con la frase del problema.
780
1177
  # Silencio es el bug (SOUL.md): si no hay número, hay una frase.
1178
+
1179
+ # El JSON de un archivo en vez del de qm. Acá se LEVANTA si no se puede leer,
1180
+ # al revés que todo lo demás en esta función: una frase se dibujaría como un
1181
+ # panel de una línea y el gate la mediría como si fuera un panel válido, que
1182
+ # es exactamente la falla que el gate tiene que encontrar. Mismo criterio que
1183
+ # leer_desde() en bin/qm-indicator.
1184
+ if ($Desde) {
1185
+ $texto = [System.IO.File]::ReadAllText($Desde, [System.Text.Encoding]::UTF8)
1186
+ return ($texto | ConvertFrom-Json)
1187
+ }
1188
+
781
1189
  $psi = New-Object System.Diagnostics.ProcessStartInfo
782
1190
  $psi.FileName = 'wsl.exe'
783
1191
  $psi.Arguments = ArgsWsl "$QmLinux --json --breve"
@@ -856,6 +1264,126 @@ function Calentar([switch]$Forzado) {
856
1264
  try { return [System.Diagnostics.Process]::Start($psi) } catch { return $null }
857
1265
  }
858
1266
 
1267
+ # ── «el número está, pero no se ve» ─────────────────────────────────────
1268
+ # Windows decide POR ÍCONO si va a la barra o al desplegable de escondidos, y a
1269
+ # los nuevos los manda al desplegable. Eso ya estaba dicho en el README como el
1270
+ # costo de la tira; lo que faltaba es que se enterara el usuario. Un ícono que
1271
+ # Windows escondió y un ícono que no arrancó se ven exactamente igual: nada. Es
1272
+ # la misma clase de silencio que motivó el repo, y macOS ya la cubre por el otro
1273
+ # lado con revisarSiSeVe() —la barra llena y la muesca— en bin/qm-barra.swift.
1274
+ #
1275
+ # Se puede MEDIR y no hay que suponerlo: cada item vive en
1276
+ # HKCU\Control Panel\NotifyIconSettings con su UID y un `IsPromoted` que vale 1
1277
+ # si está en la barra. El UID lo reparte WinForms y lo guarda en un campo
1278
+ # privado, así que se lee por reflexión — el mismo camino que ya se usa para
1279
+ # ShowContextMenu, y por la misma razón.
1280
+ $script:AvisoEscondido = $false
1281
+ $script:CampoUid = [System.Windows.Forms.NotifyIcon].GetField(
1282
+ 'id', [System.Reflection.BindingFlags]'Instance,NonPublic')
1283
+
1284
+ function RevisarSiSeVe {
1285
+ # Una sola vez por corrida: un ícono que el usuario esconde y muestra no tiene
1286
+ # que avisar en cada vuelta. Es la misma decisión que `avisoBarraLlena` en
1287
+ # Swift, y por el mismo motivo — ahí se tomó después de que avisara en bucle.
1288
+ if ($script:AvisoEscondido -or $null -eq $script:CampoUid) { return }
1289
+ if (-not $script:Bandeja.Count) { return }
1290
+
1291
+ $uids = @()
1292
+ foreach ($ni in @($script:Bandeja.Values)) {
1293
+ try { $uids += [int]$script:CampoUid.GetValue($ni) } catch { }
1294
+ }
1295
+ if (-not $uids.Count) { return }
1296
+
1297
+ # La clave guarda la ruta con un GUID de carpeta conocida adelante
1298
+ # ({1AC14E77-...}\WindowsPowerShell\v1.0\powershell.exe), así que se compara
1299
+ # por el nombre del ejecutable y se desempata por UID.
1300
+ try {
1301
+ $exe = [System.IO.Path]::GetFileName(
1302
+ [System.Diagnostics.Process]::GetCurrentProcess().MainModule.FileName)
1303
+ } catch { return }
1304
+
1305
+ $vistos = 0; $promovidos = 0
1306
+ try {
1307
+ foreach ($k in (Get-ChildItem 'HKCU:\Control Panel\NotifyIconSettings' -ErrorAction Stop)) {
1308
+ $p = Get-ItemProperty $k.PSPath -ErrorAction SilentlyContinue
1309
+ if ($null -eq $p) { continue }
1310
+ if (-not $p.PSObject.Properties['ExecutablePath']) { continue }
1311
+ if (-not $p.PSObject.Properties['UID']) { continue }
1312
+ if (([string]$p.ExecutablePath) -notlike "*\$exe") { continue }
1313
+ if ($uids -notcontains [int]$p.UID) { continue }
1314
+ $vistos++
1315
+ if ($p.PSObject.Properties['IsPromoted'] -and [int]$p.IsPromoted -eq 1) { $promovidos++ }
1316
+ }
1317
+ } catch { return }
1318
+
1319
+ # Cero vistos no es «está escondido», es «Windows todavía no los anotó»: se
1320
+ # vuelve a mirar en la vuelta siguiente en vez de avisar de algo que no se sabe.
1321
+ if ($vistos -eq 0 -or $promovidos -gt 0) { return }
1322
+ $script:AvisoEscondido = $true
1323
+ Globo 'quartermaster' `
1324
+ ('el número está, pero Windows dejó los íconos en el desplegable de ' +
1325
+ 'escondidos: arrastrá uno a la barra de tareas y se queda ahí. ' +
1326
+ 'Mientras tanto el panel se abre desde el desplegable.') $false
1327
+ }
1328
+
1329
+ # ── cuando el archivo cambia debajo ─────────────────────────────────────
1330
+ # `git pull`, `apt upgrade` y `npm update` reemplazan los archivos y se van; el
1331
+ # proceso que ya está corriendo tiene el guión LEÍDO y sigue igual hasta que
1332
+ # alguien lo reinicie a mano — que no lo hace nadie, porque la bandeja es
1333
+ # justamente lo que se deja andando y se olvida. Es vigilar_version() de
1334
+ # bin/qm-indicator.
1335
+ #
1336
+ # Va por sondeo y NO por FileSystemWatcher, al revés que la versión de GNOME.
1337
+ # Es la misma razón que explica el encabezado de este archivo: el guión puede
1338
+ # estar del otro lado del 9P de WSL —\\wsl.localhost\...— donde FileSystemWatcher
1339
+ # no es confiable. Y acá no cuesta nada: ya hay un tick cada 30 s.
1340
+ $script:Yo = $PSCommandPath
1341
+ $script:SelloYo = $null
1342
+ try { $script:SelloYo = (Get-Item $script:Yo).LastWriteTimeUtc } catch { }
1343
+
1344
+ function RevisarVersion {
1345
+ if ($SinAutoReinicio) { return }
1346
+ if (-not $script:Yo -or $null -eq $script:SelloYo) { return }
1347
+ try { $ahora = (Get-Item $script:Yo -ErrorAction Stop).LastWriteTimeUtc } catch { return }
1348
+ if ($ahora -eq $script:SelloYo) { return }
1349
+
1350
+ # Compila antes de saltar. Si la versión nueva está rota, reiniciar deja al
1351
+ # usuario SIN bandeja; quedarse con la vieja lo deja con una que anda. Entre
1352
+ # las dos, la que anda. Es la misma decisión que _reiniciar() en Python, y de
1353
+ # paso resuelve gratis el otro problema: un gestor de paquetes escribe en
1354
+ # varios pasos, y un archivo a medio escribir no parsea, así que esto es
1355
+ # también la espera a que la escritura termine.
1356
+ $errores = $null
1357
+ try {
1358
+ [System.Management.Automation.Language.Parser]::ParseFile(
1359
+ $script:Yo, [ref]$null, [ref]$errores) | Out-Null
1360
+ } catch { return }
1361
+ if ($errores -and $errores.Count) {
1362
+ # No se anota el sello: se vuelve a probar en la vuelta siguiente, que es
1363
+ # cuando el gestor de paquetes terminó de escribir.
1364
+ return
1365
+ }
1366
+
1367
+ $script:SelloYo = $ahora
1368
+ try {
1369
+ $exe = [System.Diagnostics.Process]::GetCurrentProcess().MainModule.FileName
1370
+ } catch { return }
1371
+ # `$args` no: es una variable automática de PowerShell y pisarla adentro de una
1372
+ # función es la clase de colisión silenciosa que este archivo ya tuvo dos veces.
1373
+ $lanzar = @('-NoProfile', '-ExecutionPolicy', 'Bypass', '-WindowStyle', 'Hidden',
1374
+ '-File', $script:Yo) + $script:MisArgs
1375
+ # El candado se suelta ANTES de lanzar: si no, la instancia nueva se encuentra
1376
+ # el nombre tomado por la vieja y se va enseguida, y el usuario se queda sin
1377
+ # bandeja — que es justo lo que las dos protecciones quieren evitar.
1378
+ SoltarCandado
1379
+ try {
1380
+ Start-Process -FilePath $exe -ArgumentList $lanzar -WindowStyle Hidden | Out-Null
1381
+ } catch {
1382
+ return # el candado ya se soltó, pero seguimos siendo la única viva
1383
+ }
1384
+ $script:Ctx.ExitThread()
1385
+ }
1386
+
859
1387
  # Abrir el panel a mano. `ShowContextMenu` es interno, así que va por reflexión;
860
1388
  # es lo mismo que hace el click izquierdo sobre un item.
861
1389
  function MostrarMenu($ni) {
@@ -890,11 +1418,15 @@ function ActualizarAhora {
890
1418
  if ($null -eq $proc) { Refrescar; return }
891
1419
  $script:EsperaProc = $proc
892
1420
  $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
1421
+ # La señal de que está pasando algo, en el item que se apretó. Se pone en
1422
+ # TODOS los menús y no sólo en el visible: el calentado es uno para toda la
1423
+ # máquina, así que abrir otro ícono mientras corre tiene que mostrar lo mismo.
1424
+ foreach ($mn in @($script:Menus.Values)) {
1425
+ foreach ($it in @($mn.Items)) {
1426
+ if ($it -is [System.Windows.Forms.ToolStripMenuItem] -and $it.Text -eq $ETIQUETA_ACTUALIZAR) {
1427
+ $it.Text = 'Actualizando…'
1428
+ $it.Enabled = $false
1429
+ }
898
1430
  }
899
1431
  }
900
1432
  $script:Espera = New-Object System.Windows.Forms.Timer
@@ -929,6 +1461,51 @@ function FilaImagen($bmp) {
929
1461
  return $fila
930
1462
  }
931
1463
 
1464
+ # ── el pie que baja solo ────────────────────────────────────────────────
1465
+ # Cada cuenta dice de cuándo es su número; el pie dice cuándo deja de serlo.
1466
+ #
1467
+ # El panel de Windows se rehace entero cada 30 s, así que un número acá se
1468
+ # quedaría quieto medio minuto y después daría un salto — y una cuenta regresiva
1469
+ # que no se mueve no parece una cuenta regresiva, parece un número roto. Se
1470
+ # redibuja SÓLO este renglón una vez por segundo, y sólo mientras el panel está
1471
+ # abierto: el resto del panel no cambió, así que no hay nada más que rehacer.
1472
+ # Es la misma decisión que _tic() en bin/qm-indicator.
1473
+ # El mapa de bits del pie es UNO y lo comparten todos los menús —el mismo Image
1474
+ # se puede mostrar en varios PictureBox— así que el latido lo redibuja una vez
1475
+ # por segundo y no una vez por menú abierto.
1476
+ $script:PbPies = @()
1477
+ $script:BmpPie = $null
1478
+ $script:Latido = $null
1479
+
1480
+ function FaltaParaLectura {
1481
+ # Segundos hasta el próximo calentado, o $null si no hay uno previsto.
1482
+ if ($SinCalentar) { return $null }
1483
+ if ($script:UltimoCalentar -eq [datetime]::MinValue) { return $null }
1484
+ $falta = (Cadencia) - ((Get-Date) - $script:UltimoCalentar).TotalSeconds
1485
+ return [math]::Max(0, $falta)
1486
+ }
1487
+
1488
+ # El pie se dibuja UNA vez por vuelta y lo comparten todos los menús.
1489
+ #
1490
+ # Antes lo creaba ArmarMenu, o sea una vez POR MENÚ, y cada llamada liberaba el
1491
+ # bitmap anterior — el que el menú de la vuelta anterior acababa de recibir. Con
1492
+ # cuatro íconos, tres de los cuatro pies quedaban apuntando a una imagen muerta:
1493
+ # el renglón salía en blanco y, al repintarse, GDI+ tiraba «Parameter is not
1494
+ # valid». Es el mismo error de razonamiento que el de las tarjetas —liberar algo
1495
+ # que todavía tiene dueños— cometido dos veces en el mismo archivo.
1496
+ #
1497
+ # Ahora el dueño es uno solo: Refrescar lo crea, ArmarMenu lo usa, y el viejo se
1498
+ # libera con las tarjetas viejas, al final, cuando ya no lo mira nadie.
1499
+ function LatirPie {
1500
+ if (-not $script:PbPies.Count) { return }
1501
+ $falta = FaltaParaLectura
1502
+ if ($null -eq $falta) { return }
1503
+ $antes = $script:BmpPie
1504
+ $script:BmpPie = DibujarPieLectura $falta
1505
+ foreach ($pb in @($script:PbPies)) { try { $pb.Image = $script:BmpPie } catch { } }
1506
+ if ($antes) { try { $antes.Dispose() } catch { } }
1507
+ }
1508
+
932
1509
  function ItemTexto([string]$t) {
933
1510
  $it = New-Object System.Windows.Forms.ToolStripMenuItem($t)
934
1511
  $it.Enabled = $false
@@ -938,17 +1515,33 @@ function ItemTexto([string]$t) {
938
1515
  return $it
939
1516
  }
940
1517
 
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)
1518
+ # Recorre TODAS las ventanas visibles, no sólo la que frena.
1519
+ #
1520
+ # Antes esto recibía una sola ventana —`frena`— y ahí se perdían avisos: `peor()`
1521
+ # en src/core/tipos.ts devuelve la más alta, así que con la sesión al 96 % y una
1522
+ # semanal al 85 % la bandeja avisaba de la sesión y de la semanal no decía nada.
1523
+ # Las otras dos siempre recorrieron la lista (revisarAvisos en qm-barra.swift,
1524
+ # revisar_avisos en qm-indicator); ésta era la que se había quedado corta, y es
1525
+ # justo lo contrario del principio de SOUL.md que dice leer todas las barras.
1526
+ function RevisarAvisos([string]$perfil, $ventanas, $frena, $proy, [bool]$chocas) {
1527
+ foreach ($v in @($ventanas)) {
1528
+ $nombre = NombreVentana $v
1529
+ $minuto = AlMinuto $v.reinicia
1530
+ $base = "$perfil|$nombre|$minuto"
1531
+ $pct = [double]$v.porcentaje
1532
+ foreach ($u in $UMBRALES) {
1533
+ if ($pct -ge $u) {
1534
+ $seg = Faltan $v.reinicia
1535
+ $cola = if ($null -ne $seg) { " Se reinicia en $(Dur $seg)." } else { '' }
1536
+ Avisar "$base|$u" ("{0}: {1:d}% de {2}" -f $perfil, [int][math]::Round($pct), $nombre) `
1537
+ "Pasaste el $u%.$cola" ($u -ge 95)
1538
+ }
949
1539
  }
1540
+ RevisarLiberada $perfil $v
950
1541
  }
951
- if ($chocas -and $proy) {
1542
+
1543
+ if ($chocas -and $proy -and $null -ne $frena) {
1544
+ $base = "$perfil|$(NombreVentana $frena)|$(AlMinuto $frena.reinicia)"
952
1545
  $seg = Faltan $proy.techo
953
1546
  if ($null -eq $seg) { $seg = 0 }
954
1547
  Avisar "$base|choque" "${perfil}: a este ritmo llegás al 100%" `
@@ -967,168 +1560,126 @@ function ActualizarTira($tira) {
967
1560
  $vivas = @()
968
1561
  foreach ($t in $tira) {
969
1562
  $vivas += $t.clave
970
- if ($script:Iconos.Contains($t.clave)) {
971
- $ni = $script:Iconos[$t.clave]
1563
+ if ($script:Bandeja.Contains($t.clave)) {
1564
+ $ni = $script:Bandeja[$t.clave]
972
1565
  } else {
973
1566
  $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
1567
  $ni.Add_MouseUp($script:AbrirMenu)
978
1568
  $ni.Visible = $true
979
- $script:Iconos[$t.clave] = $ni
1569
+ $script:Bandeja[$t.clave] = $ni
980
1570
  }
1571
+ # Cada ícono abre SU panel: el general muestra todas las cuentas y el de
1572
+ # una cuenta muestra esa sola. Antes todos compartían un único menú, así
1573
+ # que con cuatro íconos en la barra los cuatro abrían la misma pantalla y
1574
+ # el ícono que clickeabas no quería decir nada.
1575
+ $ni.ContextMenuStrip = $script:Menus[$t.clave]
981
1576
  $anterior = $ni.Icon
982
1577
  $ni.Icon = $t.icono
983
- if ($anterior) { $anterior.Dispose() }
1578
+ # El mismo objeto no se libera: con una tira reusada —que es lo que pasa si
1579
+ # alguien llama a esto dos veces con la misma lectura— `$anterior` ES el
1580
+ # ícono recién asignado, y soltarlo dejaría el item apuntando a un handle
1581
+ # muerto. Es el mismo error que ya costó dos bugs con los mapas de bits.
1582
+ if ($anterior -and -not [object]::ReferenceEquals($anterior, $t.icono)) { $anterior.Dispose() }
984
1583
  # NotifyIcon.Text no acepta más de 63 caracteres.
985
1584
  $texto = [string]$t.texto
986
1585
  if ($texto.Length -gt 63) { $texto = $texto.Substring(0, 60) + '...' }
987
1586
  $ni.Text = $texto
988
1587
  }
989
1588
 
990
- foreach ($clave in @($script:Iconos.Keys)) {
1589
+ foreach ($clave in @($script:Bandeja.Keys)) {
991
1590
  if ($vivas -contains $clave) { continue }
992
- $ni = $script:Iconos[$clave]
1591
+ $ni = $script:Bandeja[$clave]
993
1592
  $ni.Visible = $false
994
1593
  if ($ni.Icon) { $ni.Icon.Dispose() }
995
1594
  $ni.Dispose()
996
- $script:Iconos.Remove($clave)
1595
+ $script:Bandeja.Remove($clave)
997
1596
  }
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 }
1597
+ # El que emite los globos. Tiene que estar visible; se prefiere el general
1598
+ # porque es el que habla de la máquina entera, y si no está, el primero.
1599
+ $script:Ni = $null
1600
+ if ($script:Bandeja.Contains('general')) { $script:Ni = $script:Bandeja['general'] }
1601
+ elseif ($script:Bandeja.Count) { $script:Ni = @($script:Bandeja.Values)[0] }
1000
1602
  }
1001
1603
 
1002
- function Refrescar {
1604
+ # Un menú por clave, creado cuando hace falta.
1605
+ #
1606
+ # Todos comparten los handlers: se arman una sola vez y se enganchan acá, en vez
1607
+ # de repetir los bloques por menú — que es como se consiguen tres menús que se
1608
+ # comportan distinto sin que nadie lo haya decidido.
1609
+ function MenuDe([string]$clave) {
1610
+ if ($script:Menus.Contains($clave)) { return $script:Menus[$clave] }
1611
+ $mn = New-Object System.Windows.Forms.ContextMenuStrip
1612
+ # Sin esto el menú reserva una canaleta a la izquierda para tildes e íconos,
1613
+ # y el dibujo queda corrido y con un escalón que no es parte del diseño.
1614
+ $mn.ShowImageMargin = $false
1615
+ $mn.ShowCheckMargin = $false
1616
+ $mn.Add_ItemClicked($script:AlClickear)
1617
+ $mn.Add_Closing($script:AlCerrar)
1618
+ $mn.Add_Opened($script:AlAbrir)
1619
+ $mn.Add_Closed($script:AlCerrado)
1620
+ VestirMenu $mn ([bool]$script:MenuOscuro)
1621
+ $script:Menus[$clave] = $mn
1622
+ return $mn
1623
+ }
1624
+
1625
+ # Llena un menú: las tarjetas que le tocan, el pie y los tres botones.
1626
+ #
1627
+ # Es la MISMA función para el panel general y para el de una cuenta: lo único
1628
+ # que cambia es la lista de tarjetas que recibe. Con una función por caso, la
1629
+ # de la cuenta sola se hubiera quedado sin el pie y sin «Actualizar ahora» la
1630
+ # primera vez que alguien tocara una de las dos.
1631
+ function ArmarMenu($mn, $piezas, [string]$frase) {
1003
1632
  # Si el panel está abierto —«Actualizar ahora» lo deja así— hay que suspender
1004
1633
  # el layout mientras se cambian los items. Sin esto, cada Add() relayoutea y
1005
1634
  # reposiciona el menú visible: se ve saltar de tamaño una vez por sección.
1006
1635
  $abierto = $false
1007
- try { $abierto = $script:Menu.Visible } catch { $abierto = $false }
1008
- if ($abierto) { $script:Menu.SuspendLayout() }
1636
+ try { $abierto = $mn.Visible } catch { $abierto = $false }
1637
+ if ($abierto) { $mn.SuspendLayout() }
1009
1638
 
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
1639
  # Items.Clear() saca los items de la lista pero no los libera, y acá se
1018
1640
  # 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 = @()
1641
+ foreach ($viejo in @($mn.Items)) { $viejo.Dispose() }
1642
+ $mn.Items.Clear()
1026
1643
 
1027
- $pico = 0.0
1028
- $script:MinutosAlTecho = $null
1029
- $mueven = @()
1030
- $tira = @()
1031
-
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" })
1644
+ if ($frase) {
1645
+ # Silencio es el bug: si no hay número, hay una frase.
1646
+ $mn.Items.Add((ItemTexto $frase)) | Out-Null
1036
1647
  } 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
- }
1648
+ foreach ($b in @($piezas)) {
1649
+ $mn.Items.Add((FilaImagen $b)) | Out-Null
1650
+ $mn.Items.Add((New-Object System.Windows.Forms.ToolStripSeparator)) | Out-Null
1117
1651
  }
1652
+ }
1118
1653
 
1119
- $script:Alto = $pico
1120
- $script:CuentasQueMueven = $mueven
1654
+ # El pie va después de las tarjetas y antes de los botones, igual que en el
1655
+ # panel de GNOME. Su mapa de bits lo comparten todos los menús y lo reemplaza
1656
+ # el latido una vez por segundo, así que NO entra en $script:Bitmaps.
1657
+ if ($script:BmpPie) {
1658
+ $filaPie = FilaImagen $script:BmpPie
1659
+ $script:PbPies += $filaPie.Control
1660
+ $mn.Items.Add($filaPie) | Out-Null
1661
+ }
1121
1662
 
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' })
1663
+ # El elegí-tus-íconos, en TODOS los paneles: se llega desde cualquier ícono,
1664
+ # que es lo que hace falta cuando el que sobra es justo el que estás mirando.
1665
+ # Un tilde por cuenta, más el general; clickear uno lo esconde o lo trae, se
1666
+ # guarda y se aplica en el acto — sin reiniciar nada.
1667
+ if (@($script:ClavesConocidas).Count) {
1668
+ $sub = New-Object System.Windows.Forms.ToolStripMenuItem('Íconos en la bandeja')
1669
+ $sub.ForeColor = $script:Tinta
1670
+ foreach ($k in @($script:ClavesConocidas)) {
1671
+ $rotulo = if ($k -eq 'general') { 'general (todas las cuentas)' } else { $k }
1672
+ $it = New-Object System.Windows.Forms.ToolStripMenuItem($rotulo)
1673
+ $it.Checked = QuieroIcono $k
1674
+ $it.ForeColor = $script:Tinta
1675
+ $it.Tag = $k
1676
+ $it.Add_Click({ AlternarIcono ([string]$this.Tag) })
1677
+ $sub.DropDownItems.Add($it) | Out-Null
1126
1678
  }
1679
+ VestirMenu $sub.DropDown ([bool]$script:MenuOscuro)
1680
+ $mn.Items.Add($sub) | Out-Null
1127
1681
  }
1128
1682
 
1129
- ActualizarTira $tira
1130
- SoltarGlobos
1131
-
1132
1683
  # El item que se apretó volvió a nacer con su texto normal, así que no hay
1133
1684
  # que deshacer el «Actualizando…»: se fue con el item viejo.
1134
1685
  foreach ($par in @(
@@ -1139,15 +1690,312 @@ function Refrescar {
1139
1690
  $it = New-Object System.Windows.Forms.ToolStripMenuItem($par.t)
1140
1691
  $it.ForeColor = $script:Tinta
1141
1692
  $it.Add_Click($par.a)
1142
- $menu.Items.Add($it) | Out-Null
1693
+ $mn.Items.Add($it) | Out-Null
1143
1694
  }
1144
1695
 
1145
1696
  if ($abierto) {
1146
- $script:Menu.ResumeLayout($true)
1697
+ $mn.ResumeLayout($true)
1147
1698
  # El panel cambió de alto, así que hay que reacomodarlo: sin esto se queda
1148
1699
  # con el tamaño de antes y recorta la última sección.
1149
- $script:Menu.PerformLayout()
1700
+ $mn.PerformLayout()
1701
+ }
1702
+ }
1703
+
1704
+ # ── qué íconos quiere el usuario, y que lo pueda decidir él ─────────────
1705
+ # Se guarda la lista de los ESCONDIDOS y no la de los visibles, a propósito: así
1706
+ # una cuenta nueva aparece sola. Al revés —guardando los visibles— un perfil que
1707
+ # se agrega después nacería invisible, y una cuenta que no se ve es exactamente
1708
+ # igual a una cuenta que va bien. El silencio otra vez, y encima permanente.
1709
+ $script:RutaIconos = Join-Path $env:LOCALAPPDATA 'quartermaster\iconos.json'
1710
+ $script:Ocultos = @{}
1711
+ $script:ClavesConocidas = @()
1712
+ try {
1713
+ if (Test-Path $script:RutaIconos) {
1714
+ $m = Get-Content $script:RutaIconos -Raw -Encoding UTF8 | ConvertFrom-Json
1715
+ if ($m.PSObject.Properties['ocultos']) {
1716
+ foreach ($k in @($m.ocultos)) { $script:Ocultos[[string]$k] = $true }
1717
+ }
1718
+ }
1719
+ } catch { $script:Ocultos = @{} } # sin memoria se ven todos, que es lo seguro
1720
+
1721
+ function GuardarOcultos {
1722
+ try {
1723
+ $dir = Split-Path $script:RutaIconos -Parent
1724
+ if (-not (Test-Path $dir)) { New-Item -ItemType Directory -Path $dir -Force | Out-Null }
1725
+ @{ ocultos = @($script:Ocultos.Keys | Sort-Object) } | ConvertTo-Json -Compress |
1726
+ Set-Content $script:RutaIconos -Encoding UTF8
1727
+ } catch { }
1728
+ }
1729
+
1730
+ function QuieroIcono([string]$clave) { return -not $script:Ocultos.ContainsKey($clave) }
1731
+
1732
+ function AlternarIcono([string]$clave) {
1733
+ if ($script:Ocultos.ContainsKey($clave)) {
1734
+ $script:Ocultos.Remove($clave)
1735
+ } else {
1736
+ # El último no se puede esconder. Una bandeja vacía no es una preferencia,
1737
+ # es la herramienta apagada sin decirlo — y desde una bandeja vacía no hay
1738
+ # menú desde donde volver a prenderla.
1739
+ $quedan = @(@($script:ClavesConocidas) | Where-Object { QuieroIcono $_ })
1740
+ if ($quedan.Count -le 1) { return }
1741
+ $script:Ocultos[$clave] = $true
1742
+ }
1743
+ GuardarOcultos
1744
+
1745
+ # Que el panel NO se cierre al tildar. Es el mismo mecanismo que «Actualizar
1746
+ # ahora»: WinForms cierra el menú al clickear cualquier item, y acá eso es
1747
+ # peor que en ningún lado — elegir qué íconos querés es justamente la tarea en
1748
+ # la que uno toca varios seguidos, y cerrar el panel después de cada tilde
1749
+ # obliga a volver a abrirlo una vez por cuenta.
1750
+ #
1751
+ # La bandera se prende acá y no en un handler del submenú: los eventos de un
1752
+ # ToolStripDropDown no suben al ContextMenuStrip, así que el padre nunca se
1753
+ # entera de qué nieto se clickeó. Quien sabe es esta función. El que cancela
1754
+ # sigue siendo AlCerrar, en el padre.
1755
+ $script:MantenerAbierto = $true
1756
+
1757
+ # Refrescar destruye los items del menú, incluido ÉSTE, que es desde donde
1758
+ # estamos corriendo. Se difiere un turno del bucle de mensajes — y para
1759
+ # entonces el cierre ya se canceló, así que rehace un menú VISIBLE, que es el
1760
+ # camino que ArmarMenu ya sabe manejar (SuspendLayout / PerformLayout).
1761
+ $t = New-Object System.Windows.Forms.Timer
1762
+ $t.Interval = 1
1763
+ $t.Add_Tick({ $this.Stop(); $this.Dispose(); Refrescar })
1764
+ $t.Start()
1765
+ }
1766
+
1767
+ # El modelo del panel: qué tarjetas van en cada ícono.
1768
+ #
1769
+ # Es modelo_panel() de bin/qm-indicator y existe por la misma razón: dibujar y
1770
+ # decidir-qué-dibujar son dos cosas, y el gate necesita la segunda sin bandeja.
1771
+ # Devuelve las tarjetas por clave, las frases de las cuentas mudas y la tira.
1772
+ #
1773
+ # Con $avisar en $false no notifica ni toca la cadencia: el modo captura arma
1774
+ # exactamente el mismo panel sin mandarle un globo a nadie.
1775
+ function ModeloPaneles($datos, [bool]$avisar) {
1776
+ $paneles = [ordered]@{}
1777
+ $frases = @{}
1778
+ $tira = @()
1779
+ $bitmaps = @()
1780
+
1781
+ if ($datos -is [string]) {
1782
+ # Sin datos no hay cuentas: queda el general solo, con el arco vacío.
1783
+ $paneles['general'] = @()
1784
+ $frases['general'] = $datos
1785
+ $tira += @{ clave = 'general'; icono = (IconoGeneral 0 'atento'); texto = "qm · $datos" }
1786
+ return @{ paneles = $paneles; frases = $frases; tira = $tira; bitmaps = $bitmaps }
1787
+ }
1788
+
1789
+ $pico = 0.0
1790
+ $alTecho = $null
1791
+ $mueven = @()
1792
+ $general = @()
1793
+
1794
+ $resumen = DibujarResumen $datos.perfiles
1795
+ if ($resumen) { $bitmaps += $resumen; $general += $resumen }
1796
+
1797
+ # El índice del color de cuenta avanza sólo con las que dejaron número, igual
1798
+ # que iCuenta en qm-barra.swift: una cuenta muda no gasta un color, así que
1799
+ # las que se ven conservan el suyo de una lectura a la otra.
1800
+ $iCuenta = 0
1801
+ $calladas = @()
1802
+ foreach ($p in $datos.perfiles) {
1803
+ $cuota = $p.cuota
1804
+ $nombre = Corto $p.perfil
1805
+ # El del ÍCONO, que va sobre la barra de tareas y puede no ser el mismo.
1806
+ $colorCuenta = ColorCuenta $iCuenta $script:BarraOscura
1807
+
1808
+ # Un lugar en la tira POR PERFIL, tenga número o no.
1809
+ #
1810
+ # macOS puede dejar afuera a una cuenta muda porque su tira es un solo
1811
+ # dibujo que se rehace entero. Acá cada lugar es un item de bandeja, y
1812
+ # Windows lo identifica por el hash de (ejecutable + UID) donde el UID lo
1813
+ # reparte WinForms POR ORDEN DE CREACIÓN. Medido en el registro, en
1814
+ # Control Panel\NotifyIconSettings. O sea: sacar y volver a poner un item
1815
+ # corre los UID de los que vienen después, y con eso se le muda de cuenta
1816
+ # la decisión de "este ícono va fijo en la barra" que el usuario tomó
1817
+ # arrastrándolo. Un lugar fijo por perfil, con el medidor vacío cuando no
1818
+ # hay número, cuesta un cuadradito y salva esa decisión.
1819
+ if ($cuota.estado -ne 'ok') {
1820
+ $frase = if ($cuota.PSObject.Properties['frase']) { $cuota.frase } else { 'sin cuota' }
1821
+ # En el PANEL general las mudas van juntas al final, en una sola tarjeta:
1822
+ # una tarjeta de 340 px por frase corta llenaba la pantalla de lo que NO
1823
+ # se sabe. En su panel propio va la frase sola, que es la respuesta
1824
+ # completa a por qué no hay número.
1825
+ $calladas += @{ nombre = $nombre; frase = $frase }
1826
+ # Su panel propio es la MISMA tarjeta que le toca en el general, con ella
1827
+ # sola adentro: así el menú y la captura dibujan lo mismo, que es la única
1828
+ # forma de que el gate esté comprobando lo que el usuario ve. Va aparte y
1829
+ # no reusa la tarjeta agrupada porque esa lleva las demás cuentas.
1830
+ $suya = DibujarSinCuota @(@{ nombre = $nombre; frase = $frase })
1831
+ $bitmaps += $suya
1832
+ $paneles[$nombre] = @($suya)
1833
+ $tira += @{
1834
+ clave = $nombre
1835
+ icono = (IconoCuenta $p.producto $colorCuenta $null 'ok')
1836
+ texto = "$nombre · $frase"
1837
+ }
1838
+ continue
1839
+ }
1840
+
1841
+ $bmp = DibujarPerfil $p $iCuenta
1842
+ $bitmaps += $bmp
1843
+ $general += $bmp
1844
+ $paneles[$nombre] = @($bmp)
1845
+ $iCuenta++
1846
+
1847
+ $peor = $cuota.frena
1848
+ $proy = $p.proyeccion
1849
+ $chocas = [bool]($proy -and $proy.estado -eq 'sube' -and $proy.chocasAntesDelReinicio)
1850
+ $viejo = if ($cuota.edadSegundos -gt $VIEJO_SEGUNDOS) { '~' } else { '' }
1851
+
1852
+ # El medidor es SIEMPRE la semanal; el número de la sesión —que en macOS va
1853
+ # al lado del medidor— acá no tiene dónde ir y se va al tooltip.
1854
+ $ses = $cuota.sesion
1855
+ $sem = $cuota.semanal
1856
+ $nivelSem = if ($null -ne $sem) {
1857
+ NivelDe ([int]$sem.porcentaje) `
1858
+ ([bool]($sem.preocupa -or ($chocas -and $null -ne $peor -and $sem.clave -eq $peor.clave)))
1859
+ } else { 'ok' }
1860
+ $partes = @($nombre)
1861
+ if ($null -ne $ses) { $partes += ('sesión {0}{1:d}%' -f $viejo, [int][math]::Round($ses.porcentaje)) }
1862
+ if ($null -ne $sem) { $partes += ('{0} {1:d}%' -f (NombreVentana $sem), [int][math]::Round($sem.porcentaje)) }
1863
+ $tira += @{
1864
+ clave = $nombre
1865
+ icono = (IconoCuenta $p.producto $colorCuenta `
1866
+ $(if ($null -ne $sem) { [int]$sem.porcentaje } else { $null }) $nivelSem)
1867
+ texto = ($partes -join ' · ')
1868
+ }
1869
+
1870
+ if ($avisar) { RevisarAvisos $nombre $cuota.mostrar $peor $proy $chocas }
1871
+ if ($null -ne $peor) {
1872
+ $pct = [double]$peor.porcentaje
1873
+ if ($pct -ge 40) { $mueven += $nombre }
1874
+ if ($pct -gt $pico) { $pico = $pct }
1875
+ }
1876
+ if ($chocas) {
1877
+ $seg = Faltan $proy.techo
1878
+ if ($null -ne $seg) {
1879
+ $min = $seg / 60
1880
+ if ($null -eq $alTecho -or $min -lt $alTecho) { $alTecho = $min }
1881
+ }
1882
+ }
1883
+ }
1884
+
1885
+ # Las mudas, todas juntas y al final del panel general: lo que no se sabe va
1886
+ # después de lo que sí.
1887
+ $sin = DibujarSinCuota $calladas
1888
+ if ($sin) { $bitmaps += $sin; $general += $sin }
1889
+
1890
+ if ($avisar) {
1891
+ $script:Alto = $pico
1892
+ $script:CuentasQueMueven = $mueven
1893
+ $script:MinutosAlTecho = $alTecho
1150
1894
  }
1895
+
1896
+ # El general va PRIMERO en la tira: Windows ordena los íconos por orden de
1897
+ # registro, así que éste es el orden en que aparecen, y el de la máquina
1898
+ # entera es el que uno busca cuando no sabe qué cuenta mirar.
1899
+ $nivelPico = NivelDe ([int][math]::Round($pico)) ([bool]($null -ne $alTecho))
1900
+ $paneles.Insert(0, 'general', $general)
1901
+ $tira = @(@{
1902
+ clave = 'general'
1903
+ icono = (IconoGeneral $pico $nivelPico)
1904
+ texto = ('quartermaster · {0} cuenta(s) · lo peor {1:d}%' -f $iCuenta, [int][math]::Round($pico))
1905
+ }) + $tira
1906
+ if (-not $general.Count) { $frases['general'] = 'qm no encontró ningún perfil' }
1907
+
1908
+ return @{ paneles = $paneles; frases = $frases; tira = $tira; bitmaps = $bitmaps }
1909
+ }
1910
+
1911
+ function Refrescar {
1912
+ $datos = Leer
1913
+ # Los dos temas, que son dos claves distintas del registro y pueden no
1914
+ # coincidir. Si el de las apps cambió, AplicarTema rehace la paleta y vuelve a
1915
+ # vestir todos los menús; se redibujan igual acá abajo.
1916
+ $null = AplicarTema
1917
+ $script:BarraOscura = BarraOscura
1918
+
1919
+ # Los mapas de bits del tick anterior se APARTAN acá y se liberan al final,
1920
+ # cuando ya no los mira nadie.
1921
+ #
1922
+ # Un PictureBox no libera su Image al morir, así que hay que soltarlos a mano
1923
+ # — pero soltarlos ACÁ fue un crash: entre este renglón y el ArmarMenu de más
1924
+ # abajo, los PictureBox de los menús siguen apuntando a los Bitmap viejos, y
1925
+ # si en ese hueco entra un repintado, GDI+ tira «Parameter is not valid» y
1926
+ # WinForms le muestra al usuario el cartel de excepción no manejada. El
1927
+ # original no tenía el problema porque liberaba los items del menú PRIMERO y
1928
+ # los bitmaps después; el refactor a varios menús invirtió el orden, y con N
1929
+ # menús compartiendo la misma tarjeta el hueco es más ancho todavía.
1930
+ #
1931
+ # Es el mismo cuidado que hay que tener con el pie del panel, aplicado donde
1932
+ # hacía falta: primero se dibuja lo nuevo, después se suelta lo viejo.
1933
+ $bitmapsViejos = @($script:Bitmaps)
1934
+ if ($script:BmpPie) { $bitmapsViejos += $script:BmpPie }
1935
+ $script:BmpPie = $null
1936
+ $script:Bitmaps = @()
1937
+ $script:PbPies = @()
1938
+
1939
+ $m = ModeloPaneles $datos $true
1940
+ $script:Bitmaps = $m.bitmaps
1941
+ $paneles = $m.paneles
1942
+ $frases = $m.frases
1943
+
1944
+ # Todas las claves que existen en esta lectura, escondidas o no: es lo que
1945
+ # lista el submenú, y sin esto no habría cómo volver a traer una escondida.
1946
+ $script:ClavesConocidas = @($m.tira | ForEach-Object { $_.clave })
1947
+
1948
+ # -Iconos siembra la elección UNA vez y después manda el menú. Así el flag
1949
+ # sigue sirviendo para arrancar con una combinación, pero no pelea contra lo
1950
+ # que el usuario elija después: sería un ajuste que se deshace solo en cada
1951
+ # arranque, que es peor que no tenerlo.
1952
+ if (@($script:BandejaPedidos).Count -and -not $script:PedidosAplicados) {
1953
+ $script:PedidosAplicados = $true
1954
+ $script:Ocultos = @{}
1955
+ foreach ($k in $script:ClavesConocidas) {
1956
+ if ($script:BandejaPedidos -notcontains $k.ToLower()) { $script:Ocultos[$k] = $true }
1957
+ }
1958
+ GuardarOcultos
1959
+ }
1960
+
1961
+ # El filtro. Se aplica a la TIRA y no a los paneles: el panel general sigue
1962
+ # mostrando todas las cuentas aunque no tengan ícono propio.
1963
+ $tira = @($m.tira | Where-Object { QuieroIcono $_.clave })
1964
+ if (-not $tira.Count) {
1965
+ # Una bandeja vacía es el silencio otra vez, y acá sería un silencio que se
1966
+ # causó el usuario con un -Iconos que no coincide con nada. Queda el general
1967
+ # y se dice por qué.
1968
+ $tira = @(@{ clave = 'general'; icono = (IconoGeneral 0 'atento')
1969
+ texto = 'quartermaster · no quedó ningún ícono elegido' })
1970
+ if (-not $paneles.Contains('general')) { $paneles['general'] = @() }
1971
+ }
1972
+
1973
+ # El pie, uno solo para todos los menús. Va antes de armarlos porque
1974
+ # ArmarMenu lo consume.
1975
+ $falta = FaltaParaLectura
1976
+ if ($null -ne $falta) { $script:BmpPie = DibujarPieLectura $falta }
1977
+
1978
+ # Los menús: uno por ícono que quedó, y se tiran los de los que ya no están.
1979
+ foreach ($t in $tira) {
1980
+ ArmarMenu (MenuDe $t.clave) $paneles[$t.clave] ([string]$frases[$t.clave])
1981
+ }
1982
+ $claves = @($tira | ForEach-Object { $_.clave })
1983
+ foreach ($clave in @($script:Menus.Keys)) {
1984
+ if ($claves -contains $clave) { continue }
1985
+ $mn = $script:Menus[$clave]
1986
+ foreach ($viejo in @($mn.Items)) { $viejo.Dispose() }
1987
+ $mn.Dispose()
1988
+ $script:Menus.Remove($clave)
1989
+ }
1990
+
1991
+ ActualizarTira $tira
1992
+ RevisarSiSeVe
1993
+ SoltarGlobos
1994
+ GuardarPrevios
1995
+
1996
+ # Recién ahora: todos los menús se rearmaron, así que ningún PictureBox sigue
1997
+ # apuntando a estos.
1998
+ foreach ($b in $bitmapsViejos) { try { $b.Dispose() } catch { } }
1151
1999
  }
1152
2000
 
1153
2001
  function AbrirTablero {
@@ -1171,60 +2019,208 @@ function AbrirTablero {
1171
2019
 
1172
2020
  # ── arranque ────────────────────────────────────────────────────────────
1173
2021
 
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
2022
+ # Los argumentos con los que arrancamos, para poder relanzarnos iguales cuando
2023
+ # el archivo cambie debajo. Se reconstruyen de los parámetros ligados y no de
2024
+ # la línea original, que PowerShell no conserva de forma confiable.
2025
+ $script:MisArgs = @()
2026
+ foreach ($kv in $PSBoundParameters.GetEnumerator()) {
2027
+ if ($kv.Value -is [switch]) {
2028
+ if ($kv.Value.IsPresent) { $script:MisArgs += "-$($kv.Key)" }
2029
+ } else {
2030
+ $script:MisArgs += "-$($kv.Key)"
2031
+ $script:MisArgs += [string]$kv.Value
2032
+ }
2033
+ }
2034
+
2035
+ # ── una bandeja por sesión, y la segunda se va ──────────────────────────
2036
+ # Sin esto, arrancarla dos veces —el arranque automático más un `make tray` a
2037
+ # mano, que es lo más fácil del mundo— deja DOS tiras enteras en la bandeja: un
2038
+ # ícono por cuenta repetido, los globos por duplicado, y los dos procesos
2039
+ # pisándose el mismo avisados.json y el mismo previos.json. En GNOME el mismo
2040
+ # problema se resuelve con un nombre en el bus (soy_el_unico en bin/qm-indicator)
2041
+ # y acá con un mutex nombrado, que es lo equivalente: si el proceso muere de
2042
+ # cualquier forma, Windows suelta el mutex solo. Un archivo con el PID hay que
2043
+ # limpiarlo, y nunca se limpia en el caso que importa.
2044
+ #
2045
+ # Global\ y no Local\: el alcance es la máquina y no la sesión de terminal.
2046
+ $script:Mutex = $null
2047
+ $script:TengoCandado = $false
1182
2048
 
1183
- # Que «Actualizar ahora» no cierre el panel.
2049
+ function TomarCandado {
2050
+ $nuevo = $false
2051
+ try {
2052
+ $script:Mutex = New-Object System.Threading.Mutex($true, 'Global\ai.legios.quartermaster.tray', [ref]$nuevo)
2053
+ } catch {
2054
+ return $true # si el mutex no se puede crear, seguir es mejor que no arrancar
2055
+ }
2056
+ $script:TengoCandado = $nuevo
2057
+ return $nuevo
2058
+ }
2059
+
2060
+ function SoltarCandado {
2061
+ if (-not $script:TengoCandado -or $null -eq $script:Mutex) { return }
2062
+ $script:TengoCandado = $false
2063
+ try { $script:Mutex.ReleaseMutex() } catch { }
2064
+ try { $script:Mutex.Dispose() } catch { }
2065
+ $script:Mutex = $null
2066
+ }
2067
+
2068
+ # El modo captura no toca la bandeja ni el candado: dibuja, escribe y se va, así
2069
+ # que puede correr al lado de una bandeja viva (y en un runner de CI, donde no
2070
+ # hay ninguna).
2071
+ if (-not $Captura) {
2072
+ if (-not (TomarCandado)) {
2073
+ Write-Host 'ya hay una bandeja de quartermaster andando en esta máquina.'
2074
+ exit 0
2075
+ }
2076
+ }
2077
+
2078
+ # Qué íconos pidió el usuario. Vacío = todos, que es el caso normal.
2079
+ $script:BandejaPedidos = @(
2080
+ $Iconos -split ',' | ForEach-Object { $_.Trim().ToLower() } | Where-Object { $_ })
2081
+ $script:PedidosAplicados = $false
2082
+
2083
+ # Los handlers que comparten todos los menús. Se arman UNA vez y MenuDe los
2084
+ # engancha en cada menú nuevo.
1184
2085
  #
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.
2086
+ # Que «Actualizar ahora» no cierre el panel: WinForms cierra un menú al clickear
2087
+ # cualquier item, y ahí se pierde justo lo que se venía a mirar. El cierre se
2088
+ # puede cancelar, pero sólo se cancela para ESE item: «Abrir tablero» y «Salir»
2089
+ # tienen que seguir cerrándolo, y clickear afuera o apretar Escape también.
1189
2090
  #
1190
2091
  # Hacen falta los dos handlers y no uno: ItemClicked corre antes que Closing y
1191
2092
  # es el único que sabe QUÉ se clickeó; Closing es el único que puede cancelar.
1192
2093
  $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
- })
2094
+ # Sólo PRENDE la bandera, nunca la apaga: apagarla acá era un peligro de orden.
2095
+ # Un tilde del submenú la prende desde AlternarIcono, y si después llegara este
2096
+ # handler —por el item padre, o por la cascada de cierres— con un `=` la
2097
+ # apagaría justo antes de que AlCerrar la mire, y el panel se cerraría igual.
2098
+ # La apaga AlCerrar, que es el único que sabe que el cierre ya se resolvió.
2099
+ $script:AlClickear = {
2100
+ if ($_.ClickedItem.Text -eq $ETIQUETA_ACTUALIZAR) { $script:MantenerAbierto = $true }
2101
+ }
2102
+ $script:AlCerrar = {
2103
+ if ($script:MantenerAbierto -and
2104
+ $_.CloseReason -eq [System.Windows.Forms.ToolStripDropDownCloseReason]::ItemClicked) {
2105
+ $_.Cancel = $true
2106
+ }
2107
+ $script:MantenerAbierto = $false
2108
+ }
2109
+ # El latido del pie: sólo corre mientras hay un panel abierto, porque es lo
2110
+ # único que se mueve ahí y nadie lo mira cerrado.
2111
+ $script:AlAbrir = { if ($script:Latido) { $script:Latido.Start() } }
2112
+ $script:AlCerrado = { if ($script:Latido) { $script:Latido.Stop() } }
1203
2113
 
1204
- # La tira, indexada por perfil y en orden de aparición. Y el item que emite los
2114
+ # La tira, indexada por clave y en orden de aparición. Y el item que emite los
1205
2115
  # globos, que sale de ella.
1206
- $script:Iconos = [ordered]@{}
2116
+ #
2117
+ # Se llama $script:Bandeja y no $script:Iconos por la TERCERA colisión de
2118
+ # nombres de este archivo, y la peor de las tres: el parámetro -Iconos crea un
2119
+ # $script:Iconos tipado [string], así que asignarle un diccionario no fallaba —
2120
+ # lo CONVERTÍA a texto— y el error salía mucho después, al indexarlo, sin línea
2121
+ # ni nombre de variable. PowerShell no distingue mayúsculas y un parámetro vive
2122
+ # en el ámbito del script: cualquier $script:Algo que se llame como un parámetro
2123
+ # es el parámetro.
2124
+ $script:Bandeja = [ordered]@{}
1207
2125
  $script:Bitmaps = @()
1208
2126
  $script:Ni = $null
1209
2127
 
1210
2128
  # Click izquierdo también abre el menú: en la bandeja lo único que se ve es el
1211
2129
  # ícono, y esperar que el usuario adivine que va con botón derecho es la misma
1212
2130
  # 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.
2131
+ # varios en la tira ya no es siempre el mismo — y ahora cada uno abre SU panel.
1214
2132
  $script:AbrirMenu = {
1215
2133
  if ($_.Button -eq [System.Windows.Forms.MouseButtons]::Left) { MostrarMenu $this }
1216
2134
  }
1217
2135
 
1218
- $script:Escala = [math]::Max(1.0, $script:Menu.DeviceDpi / 96.0)
2136
+ # El DPI sale de un menú cualquiera, así que se crea el general —que existe
2137
+ # siempre— antes de medir. AplicarTema viene después para que lo vista.
2138
+ $null = MenuDe 'general'
2139
+ $null = AplicarTema
2140
+ $script:Escala = [math]::Max(1.0, $script:Menus['general'].DeviceDpi / 96.0)
2141
+ # En modo captura la escala se fija: el DPI del runner no es el de nadie, y un
2142
+ # gate que mide píxeles necesita que la misma entrada dé el mismo tamaño en
2143
+ # todas las máquinas.
2144
+ if ($Captura) { $script:Escala = 1.0 }
1219
2145
  CrearFuentes
1220
2146
 
2147
+ # Un panel en un PNG, sin bandeja y sin bucle de mensajes.
2148
+ #
2149
+ # Arma las MISMAS piezas que Refrescar, con la misma ModeloPaneles y las mismas
2150
+ # funciones de dibujo: si esto dibujara por su cuenta, el gate estaría
2151
+ # comprobando un dibujo que nadie ve. Es capturar() de bin/qm-indicator y de
2152
+ # bin/qm-barra.swift, y existe por la razón que explica el comentario de esta
2153
+ # última: diseñar a ciegas fue el error.
2154
+ #
2155
+ # -Panel elige cuál: 'general' (el de todas las cuentas) o el nombre corto de
2156
+ # una, que es exactamente lo que muestra el ícono de esa cuenta.
2157
+ function Capturar([string]$ruta, [string]$cual) {
2158
+ $datos = Leer
2159
+ $m = ModeloPaneles $datos $false
2160
+ if (-not $cual) { $cual = 'general' }
2161
+ if (-not $m.paneles.Contains($cual)) {
2162
+ throw ("no hay panel '$cual'; los que hay: " + (@($m.paneles.Keys) -join ', '))
2163
+ }
2164
+
2165
+ $piezas = @($m.paneles[$cual])
2166
+ $frase = [string]$m.frases[$cual]
2167
+ if ($frase) {
2168
+ # Sólo el general puede quedarse sin tarjetas: es cuando qm no contestó, y
2169
+ # entonces lo que hay que dibujar es la frase del problema.
2170
+ throw "el panel '$cual' no tiene nada que dibujar: $frase"
2171
+ }
2172
+ # Un valor fijo y no la cadencia real: el pie tiene que salir igual en cada
2173
+ # corrida para que el gate pueda compararlo.
2174
+ $piezas += (DibujarPieLectura $SEGUNDOS_SONDEO)
2175
+ if (-not $piezas.Count) { throw 'el fixture no produjo ni una tarjeta' }
2176
+
2177
+ $ancho = ($piezas | ForEach-Object { $_.Width } | Measure-Object -Maximum).Maximum
2178
+ # Un píxel de separador entre piezas, que es lo que pone el menú.
2179
+ $alto = ($piezas | ForEach-Object { $_.Height } | Measure-Object -Sum).Sum + $piezas.Count - 1
2180
+
2181
+ $lienzo = Lienzo $ancho $alto
2182
+ $g = [System.Drawing.Graphics]::FromImage($lienzo)
2183
+ $g.Clear($script:Fondo)
2184
+ $brSep = New-Object System.Drawing.SolidBrush((Mezclar $script:Fondo $script:Tinta 0.22))
2185
+ $y = 0
2186
+ for ($i = 0; $i -lt $piezas.Count; $i++) {
2187
+ $g.DrawImageUnscaled($piezas[$i], 0, $y)
2188
+ $y += $piezas[$i].Height
2189
+ if ($i -lt $piezas.Count - 1) {
2190
+ $g.FillRectangle($brSep, 0, $y, [int]$ancho, 1)
2191
+ $y += 1
2192
+ }
2193
+ }
2194
+ $brSep.Dispose()
2195
+ $g.Dispose()
2196
+
2197
+ $dir = Split-Path $ruta -Parent
2198
+ if ($dir -and -not (Test-Path $dir)) { New-Item -ItemType Directory -Path $dir -Force | Out-Null }
2199
+ $lienzo.Save($ruta, [System.Drawing.Imaging.ImageFormat]::Png)
2200
+ Write-Host ("panel {0}: {1}x{2} en {3}" -f $cual, $lienzo.Width, $lienzo.Height, $ruta)
2201
+ Write-Host ("iconos: " + (@($m.tira | ForEach-Object { $_.clave }) -join ', '))
2202
+ foreach ($b in $m.bitmaps) { try { $b.Dispose() } catch { } }
2203
+ $lienzo.Dispose()
2204
+ }
2205
+
2206
+ if ($Captura) {
2207
+ Capturar $Captura $Panel
2208
+ exit 0
2209
+ }
2210
+
1221
2211
  $script:Ctx = New-Object System.Windows.Forms.ApplicationContext
1222
2212
 
1223
2213
  $timer = New-Object System.Windows.Forms.Timer
1224
2214
  $timer.Interval = $Segundos * 1000
1225
- $timer.Add_Tick({ $null = Calentar; Refrescar })
2215
+ # RevisarVersion va PRIMERO: si el archivo cambió, no tiene sentido gastar un
2216
+ # calentado y un redibujo con el código viejo antes de saltar al nuevo.
2217
+ $timer.Add_Tick({ RevisarVersion; $null = Calentar; Refrescar })
1226
2218
  $timer.Start()
1227
2219
 
2220
+ $script:Latido = New-Object System.Windows.Forms.Timer
2221
+ $script:Latido.Interval = 1000
2222
+ $script:Latido.Add_Tick({ LatirPie })
2223
+
1228
2224
  $null = Calentar
1229
2225
  Refrescar
1230
2226
 
@@ -1232,10 +2228,14 @@ try {
1232
2228
  [System.Windows.Forms.Application]::Run($script:Ctx)
1233
2229
  } finally {
1234
2230
  $timer.Stop()
1235
- foreach ($ni in @($script:Iconos.Values)) {
2231
+ $script:Latido.Stop()
2232
+ GuardarPrevios
2233
+ foreach ($ni in @($script:Bandeja.Values)) {
1236
2234
  $ni.Visible = $false
1237
2235
  if ($ni.Icon) { $ni.Icon.Dispose() }
1238
2236
  $ni.Dispose()
1239
2237
  }
1240
2238
  foreach ($b in @($script:Bitmaps)) { try { $b.Dispose() } catch { } }
2239
+ if ($script:BmpPie) { try { $script:BmpPie.Dispose() } catch { } }
2240
+ SoltarCandado
1241
2241
  }