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