@legios/quartermaster 0.1.4 → 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/README.md +281 -8
- package/bin/qm-barra.swift +48 -1
- package/bin/qm-indicator +23 -1
- package/bin/qm-tray.ps1 +1252 -252
- package/dist/cli/qm.js +38 -0
- package/dist/cli/qm.js.map +1 -1
- package/dist/core/presupuesto.js +75 -0
- package/dist/core/presupuesto.js.map +1 -0
- package/dist/render/tablero.html +68 -6
- package/package.json +3 -2
- package/scripts/gate-bandeja.ps1 +172 -0
- package/scripts/gate-dibujo.sh +49 -0
- package/src/render/tablero.html +68 -6
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 ($
|
|
215
|
-
|
|
216
|
-
$script:
|
|
217
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
500
|
-
|
|
501
|
-
|
|
502
|
-
|
|
503
|
-
|
|
504
|
-
|
|
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 =
|
|
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
|
-
|
|
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
|
-
|
|
573
|
-
|
|
574
|
-
|
|
575
|
-
|
|
576
|
-
|
|
577
|
-
|
|
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
|
|
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 =
|
|
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
|
-
|
|
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
|
-
|
|
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) {
|
|
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.
|
|
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
|
-
|
|
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
|
-
$
|
|
695
|
-
$bmp =
|
|
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
|
-
$
|
|
701
|
-
$
|
|
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
|
-
$
|
|
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
|
-
#
|
|
709
|
-
#
|
|
710
|
-
$barrido = [float]([math]::Max(4, [math]::Min(
|
|
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 =
|
|
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
|
-
|
|
895
|
-
|
|
896
|
-
|
|
897
|
-
|
|
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
|
-
|
|
942
|
-
|
|
943
|
-
|
|
944
|
-
|
|
945
|
-
|
|
946
|
-
|
|
947
|
-
|
|
948
|
-
|
|
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
|
-
|
|
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:
|
|
971
|
-
$ni = $script:
|
|
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:
|
|
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
|
-
|
|
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:
|
|
1589
|
+
foreach ($clave in @($script:Bandeja.Keys)) {
|
|
991
1590
|
if ($vivas -contains $clave) { continue }
|
|
992
|
-
$ni = $script:
|
|
1591
|
+
$ni = $script:Bandeja[$clave]
|
|
993
1592
|
$ni.Visible = $false
|
|
994
1593
|
if ($ni.Icon) { $ni.Icon.Dispose() }
|
|
995
1594
|
$ni.Dispose()
|
|
996
|
-
$script:
|
|
1595
|
+
$script:Bandeja.Remove($clave)
|
|
997
1596
|
}
|
|
998
|
-
# El que emite los globos.
|
|
999
|
-
|
|
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
|
-
|
|
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 = $
|
|
1008
|
-
if ($abierto) { $
|
|
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 @($
|
|
1020
|
-
$
|
|
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
|
-
$
|
|
1028
|
-
|
|
1029
|
-
|
|
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
|
-
$
|
|
1038
|
-
|
|
1039
|
-
$
|
|
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
|
-
|
|
1120
|
-
|
|
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
|
-
|
|
1123
|
-
|
|
1124
|
-
|
|
1125
|
-
|
|
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
|
-
$
|
|
1693
|
+
$mn.Items.Add($it) | Out-Null
|
|
1143
1694
|
}
|
|
1144
1695
|
|
|
1145
1696
|
if ($abierto) {
|
|
1146
|
-
$
|
|
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
|
-
$
|
|
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
|
-
#
|
|
1175
|
-
#
|
|
1176
|
-
|
|
1177
|
-
|
|
1178
|
-
|
|
1179
|
-
$
|
|
1180
|
-
$script:
|
|
1181
|
-
|
|
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
|
-
|
|
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
|
-
#
|
|
1186
|
-
# que se venía a mirar. El cierre se
|
|
1187
|
-
#
|
|
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
|
-
|
|
1194
|
-
|
|
1195
|
-
|
|
1196
|
-
|
|
1197
|
-
|
|
1198
|
-
|
|
1199
|
-
|
|
1200
|
-
|
|
1201
|
-
|
|
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
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
}
|