@legios/quartermaster 0.1.3
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/LICENSE +21 -0
- package/README.md +1276 -0
- package/bin/qm +66 -0
- package/bin/qm-barra +63 -0
- package/bin/qm-barra.swift +1253 -0
- package/bin/qm-indicator +2063 -0
- package/bin/qm-tray +41 -0
- package/bin/qm-tray.ps1 +1241 -0
- package/bin/qm-web +137 -0
- package/dist/adapters/cache-cuota.js +45 -0
- package/dist/adapters/cache-cuota.js.map +1 -0
- package/dist/adapters/cache-endpoint.js +66 -0
- package/dist/adapters/cache-endpoint.js.map +1 -0
- package/dist/adapters/codex.js +462 -0
- package/dist/adapters/codex.js.map +1 -0
- package/dist/adapters/credenciales.js +88 -0
- package/dist/adapters/credenciales.js.map +1 -0
- package/dist/adapters/cuota.js +73 -0
- package/dist/adapters/cuota.js.map +1 -0
- package/dist/adapters/historial.js +103 -0
- package/dist/adapters/historial.js.map +1 -0
- package/dist/adapters/opencode.js +214 -0
- package/dist/adapters/opencode.js.map +1 -0
- package/dist/adapters/transcripciones.js +129 -0
- package/dist/adapters/transcripciones.js.map +1 -0
- package/dist/adapters/utilizacion.js +151 -0
- package/dist/adapters/utilizacion.js.map +1 -0
- package/dist/cli/demo-h1.js +60 -0
- package/dist/cli/demo-h1.js.map +1 -0
- package/dist/cli/preflight.js +39 -0
- package/dist/cli/preflight.js.map +1 -0
- package/dist/cli/qm.js +779 -0
- package/dist/cli/qm.js.map +1 -0
- package/dist/core/config.js +63 -0
- package/dist/core/config.js.map +1 -0
- package/dist/core/perfiles.js +139 -0
- package/dist/core/perfiles.js.map +1 -0
- package/dist/core/proyeccion.js +83 -0
- package/dist/core/proyeccion.js.map +1 -0
- package/dist/core/tipos.js +101 -0
- package/dist/core/tipos.js.map +1 -0
- package/dist/render/barras.js +62 -0
- package/dist/render/barras.js.map +1 -0
- package/dist/render/tablero.html +664 -0
- package/package.json +59 -0
- package/src/render/tablero.html +664 -0
package/bin/qm-tray.ps1
ADDED
|
@@ -0,0 +1,1241 @@
|
|
|
1
|
+
<#
|
|
2
|
+
qm en el área de notificación de Windows.
|
|
3
|
+
|
|
4
|
+
Es la contraparte de `bin/qm-barra` (macOS) y `bin/qm-indicator` (GNOME) para
|
|
5
|
+
Windows: misma regla que las otras dos, SÓLO DIBUJA. Le pide el JSON a `qm` y
|
|
6
|
+
no sabe qué es una credencial, un llavero ni un endpoint. La regla de cuál
|
|
7
|
+
barra manda —la que evita que un 75 % con aviso quede tapado por un 8 % que se
|
|
8
|
+
ve más lindo— vive una sola vez, en src/core/tipos.ts, y llega acá resuelta en
|
|
9
|
+
`mostrar`, `frena`, `sesion` y `semanal`. Acá no se reimplementa.
|
|
10
|
+
|
|
11
|
+
El menú es el mismo dibujo que `VistaCuenta` en bin/qm-barra.swift: cabecera con
|
|
12
|
+
el glifo del producto, medidores redondeados con la paleta de estado, pie con el
|
|
13
|
+
reinicio y la edad del cache. En WinForms no se puede pintar un item de menú sin
|
|
14
|
+
subclasear, así que cada perfil se dibuja a un Bitmap y el Bitmap se mete en el
|
|
15
|
+
menú dentro de un PictureBox. El efecto es el mismo; el camino, no.
|
|
16
|
+
|
|
17
|
+
Tres cosas que Windows hace distinto y conviene saber antes de leer el código:
|
|
18
|
+
|
|
19
|
+
· La bandeja no tiene etiqueta de texto. La barra de menú de macOS muestra
|
|
20
|
+
"codex ~16%" al lado del ícono; acá un item es un cuadradito de 16x16 y
|
|
21
|
+
nada más. Así que el número se DIBUJA ADENTRO del ícono (como los medidores
|
|
22
|
+
de batería), y el detalle va al tooltip y al menú.
|
|
23
|
+
|
|
24
|
+
· No hay FileMonitor. El indicador de GNOME se entera en el acto porque vigila
|
|
25
|
+
cada .claude.json con Gio.FileMonitor; desde Windows esos archivos están del
|
|
26
|
+
otro lado del 9P de WSL, donde FileSystemWatcher no es confiable. Acá el
|
|
27
|
+
sondeo es el mecanismo principal, no la red de seguridad.
|
|
28
|
+
|
|
29
|
+
· El calentado no puede bloquear. En macOS el refresco del endpoint va en una
|
|
30
|
+
cola aparte; acá el timer corre en el hilo de la interfaz, así que
|
|
31
|
+
`--calentar` se dispara y se suelta: el número que trae lo levanta el tick
|
|
32
|
+
siguiente. Un menú congelado veinte segundos es peor que un número que
|
|
33
|
+
llega medio minuto tarde.
|
|
34
|
+
#>
|
|
35
|
+
|
|
36
|
+
[CmdletBinding()]
|
|
37
|
+
param(
|
|
38
|
+
# Ruta de `qm` ADENTRO de WSL. Por defecto se resuelve por PATH en un shell
|
|
39
|
+
# de login, que es donde vive ~/.local/bin.
|
|
40
|
+
[string]$QmLinux = 'qm',
|
|
41
|
+
# Distro de WSL. Vacío = la default.
|
|
42
|
+
[string]$Distro = '',
|
|
43
|
+
# Cada cuánto se redibuja. El calentado tiene su propia cadencia, más abajo.
|
|
44
|
+
[int]$Segundos = 30,
|
|
45
|
+
[int]$Puerto = 7391,
|
|
46
|
+
# Con esto no se le pide nada al endpoint: sólo se lee lo que haya en disco.
|
|
47
|
+
[switch]$SinCalentar
|
|
48
|
+
)
|
|
49
|
+
|
|
50
|
+
Set-StrictMode -Version Latest
|
|
51
|
+
$ErrorActionPreference = 'Stop'
|
|
52
|
+
|
|
53
|
+
Add-Type -AssemblyName System.Windows.Forms
|
|
54
|
+
Add-Type -AssemblyName System.Drawing
|
|
55
|
+
|
|
56
|
+
# Pintar los dibujos en oscuro no alcanza: el marco del menú, el resaltado del
|
|
57
|
+
# item bajo el mouse y los separadores los pinta WinForms con su propia tabla,
|
|
58
|
+
# que es clara. Sin esto el panel quedaba oscuro adentro de un menú blanco, que
|
|
59
|
+
# se ve peor que el problema original. La tabla no se puede configurar sin
|
|
60
|
+
# heredarla, y heredar en PowerShell es esto.
|
|
61
|
+
Add-Type -ReferencedAssemblies System.Drawing, System.Windows.Forms -TypeDefinition @'
|
|
62
|
+
using System.Drawing;
|
|
63
|
+
using System.Windows.Forms;
|
|
64
|
+
public class QmTabla : ProfessionalColorTable {
|
|
65
|
+
public static Color Fondo = Color.FromArgb(43, 43, 43);
|
|
66
|
+
public static Color Resalte = Color.FromArgb(62, 62, 62);
|
|
67
|
+
public static Color Borde = Color.FromArgb(80, 80, 80);
|
|
68
|
+
public override Color ToolStripDropDownBackground { get { return Fondo; } }
|
|
69
|
+
public override Color MenuBorder { get { return Borde; } }
|
|
70
|
+
public override Color MenuItemBorder { get { return Resalte; } }
|
|
71
|
+
public override Color MenuItemSelected { get { return Resalte; } }
|
|
72
|
+
public override Color MenuItemSelectedGradientBegin { get { return Resalte; } }
|
|
73
|
+
public override Color MenuItemSelectedGradientEnd { get { return Resalte; } }
|
|
74
|
+
public override Color ImageMarginGradientBegin { get { return Fondo; } }
|
|
75
|
+
public override Color ImageMarginGradientMiddle { get { return Fondo; } }
|
|
76
|
+
public override Color ImageMarginGradientEnd { get { return Fondo; } }
|
|
77
|
+
public override Color SeparatorDark { get { return Borde; } }
|
|
78
|
+
public override Color SeparatorLight { get { return Fondo; } }
|
|
79
|
+
}
|
|
80
|
+
'@
|
|
81
|
+
|
|
82
|
+
Add-Type -MemberDefinition @'
|
|
83
|
+
[DllImport("user32.dll", SetLastError = true)]
|
|
84
|
+
public static extern bool DestroyIcon(IntPtr handle);
|
|
85
|
+
[DllImport("user32.dll")]
|
|
86
|
+
public static extern bool SetProcessDPIAware();
|
|
87
|
+
'@ -Name Nativo -Namespace Qm
|
|
88
|
+
|
|
89
|
+
# Sin esto Windows estira el mapa de bits del menú y todo sale borroso.
|
|
90
|
+
try { [Qm.Nativo]::SetProcessDPIAware() | Out-Null } catch { }
|
|
91
|
+
|
|
92
|
+
# El texto del item que refresca. Está en una constante porque lo comparan el
|
|
93
|
+
# handler que cancela el cierre y el que pone «Actualizando…», y un literal
|
|
94
|
+
# repetido en tres lados es un renombre que rompe dos de ellos en silencio.
|
|
95
|
+
$ETIQUETA_ACTUALIZAR = 'Actualizar ahora'
|
|
96
|
+
|
|
97
|
+
$UMBRALES = @(80, 95)
|
|
98
|
+
# Cada cuánto se le pide el número al endpoint. Son los mismos de qm-barra.swift.
|
|
99
|
+
$SEGUNDOS_SONDEO = 300
|
|
100
|
+
$MINIMO_RED = 60
|
|
101
|
+
$VIEJO_SEGUNDOS = 6 * 3600
|
|
102
|
+
|
|
103
|
+
# ── la paleta ───────────────────────────────────────────────────────────
|
|
104
|
+
# La misma del tablero y de la barra de macOS. El color va en la MARCA, nunca
|
|
105
|
+
# en el texto: el número se queda con el color de etiqueta del sistema, que se
|
|
106
|
+
# adapta solo al tema claro u oscuro.
|
|
107
|
+
|
|
108
|
+
$PALETA = @{
|
|
109
|
+
ok = [System.Drawing.Color]::FromArgb(12, 163, 12) # #0ca30c
|
|
110
|
+
atento = [System.Drawing.Color]::FromArgb(250, 178, 25) # #fab219
|
|
111
|
+
aviso = [System.Drawing.Color]::FromArgb(236, 131, 90) # #ec835a
|
|
112
|
+
critico = [System.Drawing.Color]::FromArgb(208, 59, 59) # #d03b3b
|
|
113
|
+
}
|
|
114
|
+
|
|
115
|
+
function NivelDe([int]$pct, [bool]$preocupa) {
|
|
116
|
+
if ($pct -ge 95) { return 'critico' }
|
|
117
|
+
if ($preocupa -or $pct -ge 80) { return 'aviso' }
|
|
118
|
+
if ($pct -ge 60) { return 'atento' }
|
|
119
|
+
return 'ok'
|
|
120
|
+
}
|
|
121
|
+
|
|
122
|
+
# El color con que se identifica cada cuenta, en sus dos versiones.
|
|
123
|
+
#
|
|
124
|
+
# Deliberadamente lejos de la paleta de estado: verde, ámbar y rojo están
|
|
125
|
+
# reservados y no pueden significar además «esta es la cuenta 2».
|
|
126
|
+
#
|
|
127
|
+
# Son DOS tablas por lo mismo que colorCuenta() en Swift devuelve un NSColor
|
|
128
|
+
# dinámico: el mismo azul no sirve sobre los dos fondos. La diferencia es que
|
|
129
|
+
# acá hay que elegir a mano, y hay que elegir DOS VECES, porque el menú y la
|
|
130
|
+
# barra de tareas son superficies distintas con temas distintos. Medido en esta
|
|
131
|
+
# máquina: AppsUseLightTheme=0 y aun así SystemColors.Menu da 240,240,240 —los
|
|
132
|
+
# colores de sistema de Win32 no siguen al tema oscuro— mientras la barra de
|
|
133
|
+
# tareas sí es oscura. Con una sola tabla, los chevrones de codex (#4a3aa7)
|
|
134
|
+
# quedaban casi invisibles sobre la barra negra, que es la de fábrica. Se vio
|
|
135
|
+
# mirando el ícono a 16x16; no se deduce del código.
|
|
136
|
+
$COLOR_CUENTA_CLARO = @(
|
|
137
|
+
[System.Drawing.Color]::FromArgb(42, 120, 214), # #2a78d6
|
|
138
|
+
[System.Drawing.Color]::FromArgb(74, 58, 167), # #4a3aa7
|
|
139
|
+
[System.Drawing.Color]::FromArgb(232, 123, 164) # #e87ba4
|
|
140
|
+
)
|
|
141
|
+
$COLOR_CUENTA_OSCURO = @(
|
|
142
|
+
[System.Drawing.Color]::FromArgb(57, 135, 229), # #3987e5
|
|
143
|
+
[System.Drawing.Color]::FromArgb(144, 133, 233), # #9085e9
|
|
144
|
+
[System.Drawing.Color]::FromArgb(213, 81, 129) # #d55181
|
|
145
|
+
)
|
|
146
|
+
|
|
147
|
+
function ColorCuenta([int]$i, [bool]$fondoOscuro) {
|
|
148
|
+
$tabla = if ($fondoOscuro) { $COLOR_CUENTA_OSCURO } else { $COLOR_CUENTA_CLARO }
|
|
149
|
+
return $tabla[$i % $tabla.Count]
|
|
150
|
+
}
|
|
151
|
+
|
|
152
|
+
# ¿Es oscura la barra de tareas? Es OTRA clave que la de las apps. Si no está,
|
|
153
|
+
# oscura: es la de fábrica. Se relee en cada tick, así que cambiar el tema se
|
|
154
|
+
# nota en la vuelta siguiente sin reiniciar nada.
|
|
155
|
+
function BarraOscura {
|
|
156
|
+
try {
|
|
157
|
+
$v = Get-ItemProperty -ErrorAction Stop -Name SystemUsesLightTheme `
|
|
158
|
+
-Path 'HKCU:\SOFTWARE\Microsoft\Windows\CurrentVersion\Themes\Personalize'
|
|
159
|
+
return ($v.SystemUsesLightTheme -eq 0)
|
|
160
|
+
} catch { return $true }
|
|
161
|
+
}
|
|
162
|
+
|
|
163
|
+
# El fondo del menú NO sale de SystemColors, y eso fue un bug reportado: el
|
|
164
|
+
# panel era el único de los cuatro renderizadores sin modo oscuro.
|
|
165
|
+
#
|
|
166
|
+
# Medido acá: con AppsUseLightTheme=0 —Windows en oscuro— SystemColors.Menu
|
|
167
|
+
# igual devuelve 240,240,240, porque los colores clásicos de Win32 no siguen al
|
|
168
|
+
# tema de las apps. Es la misma trampa que ya había aparecido eligiendo el color
|
|
169
|
+
# de cuenta, y ahí sólo se usó para eso; el fondo se había quedado atrás. macOS
|
|
170
|
+
# lo saca de un NSColor dinámico y GNOME del tema de GTK, así que Windows era el
|
|
171
|
+
# único que tenía que preguntarlo a mano y no lo hacía.
|
|
172
|
+
#
|
|
173
|
+
# Se relee en cada tick, igual que el de la barra de tareas.
|
|
174
|
+
function TemaAppsOscuro {
|
|
175
|
+
try {
|
|
176
|
+
$v = Get-ItemProperty -ErrorAction Stop -Name AppsUseLightTheme `
|
|
177
|
+
-Path 'HKCU:\SOFTWARE\Microsoft\Windows\CurrentVersion\Themes\Personalize'
|
|
178
|
+
return ($v.AppsUseLightTheme -eq 0)
|
|
179
|
+
} catch { return $false } # sin la clave, claro: es lo que hacía antes
|
|
180
|
+
}
|
|
181
|
+
|
|
182
|
+
# Los tonos del menú de Windows 11 en oscuro. En claro se siguen usando los del
|
|
183
|
+
# sistema, que ahí sí son los correctos.
|
|
184
|
+
$script:MenuOscuro = $null
|
|
185
|
+
$script:Fondo = [System.Drawing.SystemColors]::Menu
|
|
186
|
+
$script:Tinta = [System.Drawing.SystemColors]::MenuText
|
|
187
|
+
|
|
188
|
+
function Mezclar($a, $b, [double]$t) {
|
|
189
|
+
[System.Drawing.Color]::FromArgb(
|
|
190
|
+
[int]($a.R + ($b.R - $a.R) * $t),
|
|
191
|
+
[int]($a.G + ($b.G - $a.G) * $t),
|
|
192
|
+
[int]($a.B + ($b.B - $a.B) * $t))
|
|
193
|
+
}
|
|
194
|
+
$script:Tinta2 = Mezclar $script:Tinta $script:Fondo 0.38
|
|
195
|
+
$script:Tinta3 = Mezclar $script:Tinta $script:Fondo 0.58
|
|
196
|
+
$script:Pista = Mezclar $script:Fondo $script:Tinta 0.14
|
|
197
|
+
$script:BarraOscura = $true
|
|
198
|
+
|
|
199
|
+
# Todo el tema en un lugar, y aplicable de nuevo: cambiar Windows de claro a
|
|
200
|
+
# oscuro es algo que se hace, y reiniciar la bandeja para que se entere sería
|
|
201
|
+
# la clase de detalle que uno descubre justo cuando no quiere. Devuelve $true
|
|
202
|
+
# si cambió algo, para no rehacer el menú al vicio en cada tick.
|
|
203
|
+
function AplicarTema {
|
|
204
|
+
$oscuro = TemaAppsOscuro
|
|
205
|
+
if ($oscuro -eq $script:MenuOscuro) { return $false }
|
|
206
|
+
$script:MenuOscuro = $oscuro
|
|
207
|
+
$script:Fondo = if ($oscuro) { [System.Drawing.Color]::FromArgb(43, 43, 43) }
|
|
208
|
+
else { [System.Drawing.SystemColors]::Menu }
|
|
209
|
+
$script:Tinta = if ($oscuro) { [System.Drawing.Color]::FromArgb(255, 255, 255) }
|
|
210
|
+
else { [System.Drawing.SystemColors]::MenuText }
|
|
211
|
+
$script:Tinta2 = Mezclar $script:Tinta $script:Fondo 0.38
|
|
212
|
+
$script:Tinta3 = Mezclar $script:Tinta $script:Fondo 0.58
|
|
213
|
+
$script:Pista = Mezclar $script:Fondo $script:Tinta 0.14
|
|
214
|
+
if ($null -ne $script:Menu) {
|
|
215
|
+
$script:Menu.BackColor = $script:Fondo
|
|
216
|
+
$script:Menu.ForeColor = $script:Tinta
|
|
217
|
+
if ($oscuro) {
|
|
218
|
+
[QmTabla]::Fondo = $script:Fondo
|
|
219
|
+
[QmTabla]::Resalte = Mezclar $script:Fondo $script:Tinta 0.12
|
|
220
|
+
[QmTabla]::Borde = Mezclar $script:Fondo $script:Tinta 0.22
|
|
221
|
+
$script:Menu.Renderer = New-Object System.Windows.Forms.ToolStripProfessionalRenderer((New-Object QmTabla))
|
|
222
|
+
} else {
|
|
223
|
+
# De vuelta al de fábrica: la tabla oscura sobre un menú claro se ve
|
|
224
|
+
# igual de mal que al revés.
|
|
225
|
+
$script:Menu.RenderMode = [System.Windows.Forms.ToolStripRenderMode]::ManagerRenderMode
|
|
226
|
+
}
|
|
227
|
+
}
|
|
228
|
+
return $true
|
|
229
|
+
}
|
|
230
|
+
|
|
231
|
+
# ── formato ─────────────────────────────────────────────────────────────
|
|
232
|
+
|
|
233
|
+
function Corto([string]$nombre) {
|
|
234
|
+
$n = $nombre
|
|
235
|
+
if ($n.StartsWith('.claude')) { $n = $n.Substring(7) }
|
|
236
|
+
$n = $n.TrimStart('-')
|
|
237
|
+
if ($n -eq '') { return 'main' }
|
|
238
|
+
return $n
|
|
239
|
+
}
|
|
240
|
+
|
|
241
|
+
function Dur([int]$segundos) {
|
|
242
|
+
# La escalera de duración del proyecto. El canon es duracion() en
|
|
243
|
+
# src/render/barras.ts —por donde pasa todo lo que imprime el CLI— y está
|
|
244
|
+
# congelado en test/fixtures/duraciones.json; make gate-duraciones corre las
|
|
245
|
+
# cuatro implementaciones y las compara.
|
|
246
|
+
#
|
|
247
|
+
# Antes esta decía 'ya', '1h' y '1d0h' donde el CLI decía 'vencido', '1h00m' y
|
|
248
|
+
# '1d'. Eran dos convenciones conviviendo, y sobrevivieron porque nadie había
|
|
249
|
+
# comparado una GUI contra el CLI.
|
|
250
|
+
if ($segundos -lt 0) { return 'vencido' }
|
|
251
|
+
$h = [int][math]::Floor($segundos / 3600)
|
|
252
|
+
$m = [int][math]::Floor(($segundos % 3600) / 60)
|
|
253
|
+
if ($h -ge 24) {
|
|
254
|
+
$d = [int][math]::Floor($h / 24)
|
|
255
|
+
if (($h % 24) -eq 0) { return "${d}d" } else { return "${d}d$($h % 24)h" }
|
|
256
|
+
}
|
|
257
|
+
if ($h -gt 0) { return ('{0}h{1:d2}m' -f $h, $m) }
|
|
258
|
+
if ($m -gt 0) { return "${m}m" }
|
|
259
|
+
return "${segundos}s"
|
|
260
|
+
}
|
|
261
|
+
|
|
262
|
+
function Faltan($iso) {
|
|
263
|
+
if (-not $iso) { return $null }
|
|
264
|
+
try { $cuando = [datetimeoffset]::Parse($iso) } catch { return $null }
|
|
265
|
+
return [int]($cuando - [datetimeoffset]::UtcNow).TotalSeconds
|
|
266
|
+
}
|
|
267
|
+
|
|
268
|
+
function AlMinuto($iso) {
|
|
269
|
+
# Clave estable para no repetir avisos: el servidor manda microsegundos y no
|
|
270
|
+
# siempre los mismos entre lecturas, así que con el valor crudo cada jitter
|
|
271
|
+
# estrena clave y vuelve a notificar lo mismo.
|
|
272
|
+
if (-not $iso) { return 'sin-reinicio' }
|
|
273
|
+
try { return ([datetimeoffset]::Parse($iso)).ToString('yyyy-MM-ddTHH:mm') } catch { return $iso }
|
|
274
|
+
}
|
|
275
|
+
|
|
276
|
+
function NombreVentana($v) {
|
|
277
|
+
if ($v.nombre) { return $v.nombre }
|
|
278
|
+
if ($v.alcance) { return "$($v.clave) ($($v.alcance))" }
|
|
279
|
+
return $v.clave
|
|
280
|
+
}
|
|
281
|
+
|
|
282
|
+
function FraseRitmo($p) {
|
|
283
|
+
# La misma distinción que hace qm: "no sé" no es "no".
|
|
284
|
+
if (-not $p) { return $null }
|
|
285
|
+
if ($p.estado -eq 'sube') {
|
|
286
|
+
$seg = Faltan $p.techo
|
|
287
|
+
if ($null -eq $seg) { $seg = 0 }
|
|
288
|
+
# Invariante y no la cultura de la máquina: con `n1`, una Windows en
|
|
289
|
+
# español escribe «1,8 pts/h» y una en inglés «1.8», así que las pantallas
|
|
290
|
+
# dejaban de coincidir entre sí y con macOS, que usa %.1f. El separador de
|
|
291
|
+
# un número no es una decisión de localización acá: es parte del dibujo.
|
|
292
|
+
$ritmo = ([double]$p.ritmoPuntosPorHora).ToString('0.0', [cultureinfo]::InvariantCulture)
|
|
293
|
+
$cuando = "$ritmo pts/h · 100 % en $(Dur $seg)"
|
|
294
|
+
if ($p.chocasAntesDelReinicio) { return "$cuando — antes del reinicio" }
|
|
295
|
+
return "$cuando — después del reinicio"
|
|
296
|
+
}
|
|
297
|
+
if ($p.estado -eq 'plano') { return 'no sube' }
|
|
298
|
+
return "todavía no sé el ritmo: $($p.motivo)"
|
|
299
|
+
}
|
|
300
|
+
|
|
301
|
+
# ── avisos ──────────────────────────────────────────────────────────────
|
|
302
|
+
# La clave incluye el instante de reinicio: cuando la ventana se reinicia la
|
|
303
|
+
# clave cambia sola y el mismo umbral puede volver a avisar. Sin eso, o
|
|
304
|
+
# spameás cada minuto o avisás una sola vez en la vida.
|
|
305
|
+
|
|
306
|
+
$script:RutaAvisos = Join-Path $env:LOCALAPPDATA 'quartermaster\avisados.json'
|
|
307
|
+
$script:Vistos = @{}
|
|
308
|
+
try {
|
|
309
|
+
if (Test-Path $script:RutaAvisos) {
|
|
310
|
+
foreach ($k in (Get-Content $script:RutaAvisos -Raw -Encoding UTF8 | ConvertFrom-Json)) {
|
|
311
|
+
$script:Vistos[$k] = $true
|
|
312
|
+
}
|
|
313
|
+
}
|
|
314
|
+
} catch { $script:Vistos = @{} } # sin memoria se avisa de más, no de menos
|
|
315
|
+
|
|
316
|
+
function Avisar([string]$clave, [string]$titulo, [string]$cuerpo, [bool]$urgente) {
|
|
317
|
+
if ($script:Vistos.ContainsKey($clave)) { return }
|
|
318
|
+
$script:Vistos[$clave] = $true
|
|
319
|
+
try {
|
|
320
|
+
$dir = Split-Path $script:RutaAvisos -Parent
|
|
321
|
+
if (-not (Test-Path $dir)) { New-Item -ItemType Directory -Path $dir -Force | Out-Null }
|
|
322
|
+
($script:Vistos.Keys | Sort-Object) | ConvertTo-Json | Set-Content $script:RutaAvisos -Encoding UTF8
|
|
323
|
+
} catch { }
|
|
324
|
+
# No se muestra acá: se encola. Un globo necesita un item VISIBLE que lo
|
|
325
|
+
# emita, y los items se crean después de dibujar —recién ahí se sabe cuántas
|
|
326
|
+
# cuentas hay—. Mostrarlo en el momento perdía justo el aviso del primer
|
|
327
|
+
# tick, que es el que llega cuando arrancás la máquina ya frenado.
|
|
328
|
+
$script:Globos += @{ titulo = $titulo; cuerpo = $cuerpo; urgente = $urgente }
|
|
329
|
+
}
|
|
330
|
+
|
|
331
|
+
$script:Globos = @()
|
|
332
|
+
|
|
333
|
+
function SoltarGlobos {
|
|
334
|
+
if (-not $script:Ni) { $script:Globos = @(); return }
|
|
335
|
+
foreach ($gl in @($script:Globos)) {
|
|
336
|
+
$ico = if ($gl.urgente) { [System.Windows.Forms.ToolTipIcon]::Error } else { [System.Windows.Forms.ToolTipIcon]::Warning }
|
|
337
|
+
try { $script:Ni.ShowBalloonTip(($(if ($gl.urgente) { 30000 } else { 10000 })), $gl.titulo, $gl.cuerpo, $ico) } catch { }
|
|
338
|
+
}
|
|
339
|
+
$script:Globos = @()
|
|
340
|
+
}
|
|
341
|
+
|
|
342
|
+
# ── dibujo ──────────────────────────────────────────────────────────────
|
|
343
|
+
# Las medidas están en píxeles lógicos (los mismos números que la vista de
|
|
344
|
+
# macOS) y se escalan por DPI al crear las fuentes. Si una constante de acá no
|
|
345
|
+
# coincide con lo que dibuja DibujarPerfil, los renglones se pisan — que es
|
|
346
|
+
# exactamente lo que le pasó a la versión de macOS y por eso lo dice ahí.
|
|
347
|
+
|
|
348
|
+
$script:Escala = 1.0
|
|
349
|
+
$ANCHO_VISTA = 340
|
|
350
|
+
$MARGEN = 15
|
|
351
|
+
$ALTO_CABECERA = 17 + 14 + 8 # título + subtítulo + aire
|
|
352
|
+
$ALTO_BARRA = 15 + 3 + 5 + 4 + 12 + 7
|
|
353
|
+
$ALTO_RITMO = 16
|
|
354
|
+
$ALTO_FRASE = 30
|
|
355
|
+
# 6 de aire + 16 de curva + 12 para los rótulos de abajo, igual que
|
|
356
|
+
# VistaCuenta.ALTO_CURVA en Swift. Si esto no coincide con lo que dibuja
|
|
357
|
+
# DibujarPerfil, los rótulos se comen el renglón siguiente.
|
|
358
|
+
$ALTO_CURVA = 34
|
|
359
|
+
# El anillo (44) más el aire de arriba y abajo: el alto de VistaResumen.
|
|
360
|
+
$ALTO_RESUMEN = 74
|
|
361
|
+
|
|
362
|
+
function Px([double]$v) { return [float]($v * $script:Escala) }
|
|
363
|
+
|
|
364
|
+
function CrearFuentes {
|
|
365
|
+
$f = { param($px, $estilo) New-Object System.Drawing.Font('Segoe UI', (Px $px), $estilo, [System.Drawing.GraphicsUnit]::Pixel) }
|
|
366
|
+
$script:FTitulo = & $f 14 ([System.Drawing.FontStyle]::Bold)
|
|
367
|
+
$script:FSub = & $f 11 ([System.Drawing.FontStyle]::Regular)
|
|
368
|
+
$script:FNombre = & $f 12 ([System.Drawing.FontStyle]::Regular)
|
|
369
|
+
$script:FActiva = & $f 12 ([System.Drawing.FontStyle]::Bold)
|
|
370
|
+
$script:FPct = & $f 12 ([System.Drawing.FontStyle]::Bold)
|
|
371
|
+
$script:FPie = & $f 10 ([System.Drawing.FontStyle]::Regular)
|
|
372
|
+
$script:FFrase = & $f 11 ([System.Drawing.FontStyle]::Regular)
|
|
373
|
+
$script:FRotulo = & $f 9 ([System.Drawing.FontStyle]::Bold)
|
|
374
|
+
$script:FMini = & $f 9 ([System.Drawing.FontStyle]::Regular)
|
|
375
|
+
$script:FCifra = & $f 20 ([System.Drawing.FontStyle]::Bold)
|
|
376
|
+
}
|
|
377
|
+
|
|
378
|
+
function RectRedondeado($g, $rect, [float]$r, $brocha) {
|
|
379
|
+
$p = New-Object System.Drawing.Drawing2D.GraphicsPath
|
|
380
|
+
$d = $r * 2
|
|
381
|
+
$p.AddArc($rect.X, $rect.Y, $d, $d, 180, 90)
|
|
382
|
+
$p.AddArc($rect.Right - $d, $rect.Y, $d, $d, 270, 90)
|
|
383
|
+
$p.AddArc($rect.Right - $d, $rect.Bottom - $d, $d, $d, 0, 90)
|
|
384
|
+
$p.AddArc($rect.X, $rect.Bottom - $d, $d, $d, 90, 90)
|
|
385
|
+
$p.CloseFigure()
|
|
386
|
+
$g.FillPath($brocha, $p)
|
|
387
|
+
$p.Dispose()
|
|
388
|
+
}
|
|
389
|
+
|
|
390
|
+
function Escribir($g, [string]$t, [float]$x, [float]$y, $fuente, $color, [float]$derecha = -1) {
|
|
391
|
+
if (-not $t) { return }
|
|
392
|
+
$br = New-Object System.Drawing.SolidBrush($color)
|
|
393
|
+
if ($derecha -ge 0) {
|
|
394
|
+
$an = $g.MeasureString($t, $fuente).Width
|
|
395
|
+
$x = $derecha - $an
|
|
396
|
+
}
|
|
397
|
+
$g.DrawString($t, $fuente, $br, $x, $y)
|
|
398
|
+
$br.Dispose()
|
|
399
|
+
}
|
|
400
|
+
|
|
401
|
+
# La marca de cada producto, dibujada: no hay ícono de sistema ni para Claude ni
|
|
402
|
+
# para Codex. El asterisco es la forma de la de Claude; los chevrones, código.
|
|
403
|
+
function GlifoProducto($g, [string]$producto, $color, [float]$x, [float]$y, [float]$lado, [float]$grosor = -1) {
|
|
404
|
+
# El grosor por defecto sigue al DPI, como el resto del menú. El ícono de la
|
|
405
|
+
# bandeja lo pasa explícito: ese se dibuja a 32 px fijos y lo baja Windows,
|
|
406
|
+
# así que un trazo de 1,3 se le desaparece en el camino a 16.
|
|
407
|
+
if ($grosor -le 0) { $grosor = Px 1.3 }
|
|
408
|
+
$lapiz = New-Object System.Drawing.Pen($color, $grosor)
|
|
409
|
+
$lapiz.StartCap = [System.Drawing.Drawing2D.LineCap]::Round
|
|
410
|
+
$lapiz.EndCap = [System.Drawing.Drawing2D.LineCap]::Round
|
|
411
|
+
$cx = $x + $lado / 2; $cy = $y + $lado / 2
|
|
412
|
+
if ($producto -eq 'codex') {
|
|
413
|
+
# Los chevrones necesitan aire en el medio: pegados se fusionan y el glifo
|
|
414
|
+
# se lee como una «o».
|
|
415
|
+
$a = $lado * 0.30; $hueco = $lado * 0.20
|
|
416
|
+
$g.DrawLines($lapiz, [System.Drawing.PointF[]]@(
|
|
417
|
+
(New-Object System.Drawing.PointF(($cx - $hueco), ($cy - $a))),
|
|
418
|
+
(New-Object System.Drawing.PointF(($cx - $hueco - $a * 0.85), $cy)),
|
|
419
|
+
(New-Object System.Drawing.PointF(($cx - $hueco), ($cy + $a)))))
|
|
420
|
+
$g.DrawLines($lapiz, [System.Drawing.PointF[]]@(
|
|
421
|
+
(New-Object System.Drawing.PointF(($cx + $hueco), ($cy - $a))),
|
|
422
|
+
(New-Object System.Drawing.PointF(($cx + $hueco + $a * 0.85), $cy)),
|
|
423
|
+
(New-Object System.Drawing.PointF(($cx + $hueco), ($cy + $a)))))
|
|
424
|
+
} elseif ($producto -eq 'opencode' -or $producto -eq 'zai') {
|
|
425
|
+
$r0 = $lado * 0.34
|
|
426
|
+
$g.DrawPolygon($lapiz, [System.Drawing.PointF[]]@(
|
|
427
|
+
(New-Object System.Drawing.PointF($cx, ($cy - $r0))),
|
|
428
|
+
(New-Object System.Drawing.PointF(($cx + $r0), $cy)),
|
|
429
|
+
(New-Object System.Drawing.PointF($cx, ($cy + $r0))),
|
|
430
|
+
(New-Object System.Drawing.PointF(($cx - $r0), $cy))))
|
|
431
|
+
} else {
|
|
432
|
+
$r0 = $lado * 0.36
|
|
433
|
+
foreach ($k in 0..2) {
|
|
434
|
+
$ang = $k * [math]::PI / 3
|
|
435
|
+
$g.DrawLine($lapiz,
|
|
436
|
+
[float]($cx + $r0 * [math]::Cos($ang)), [float]($cy + $r0 * [math]::Sin($ang)),
|
|
437
|
+
[float]($cx - $r0 * [math]::Cos($ang)), [float]($cy - $r0 * [math]::Sin($ang)))
|
|
438
|
+
}
|
|
439
|
+
}
|
|
440
|
+
$lapiz.Dispose()
|
|
441
|
+
}
|
|
442
|
+
|
|
443
|
+
# Las muestras recientes de la barra que frena, dibujadas.
|
|
444
|
+
#
|
|
445
|
+
# El eje Y va del mínimo al máximo de la serie y NO de 0 a 100: lo que
|
|
446
|
+
# interesa acá es la PENDIENTE, y a escala completa una subida de tres puntos
|
|
447
|
+
# se ve plana. Es el mismo criterio —y el mismo dibujo— que dibujarCurva() en
|
|
448
|
+
# qm-barra.swift, con la diferencia obvia de que en GDI+ la Y crece para abajo.
|
|
449
|
+
function DibujarCurva($g, $historia, [string]$nivel, $caja) {
|
|
450
|
+
$h = @($historia)
|
|
451
|
+
if ($h.Count -lt 3) { return }
|
|
452
|
+
$ts = @($h | ForEach-Object { [double]$_.t })
|
|
453
|
+
$ps = @($h | ForEach-Object { [double]$_.porcentaje })
|
|
454
|
+
$t0 = ($ts | Measure-Object -Minimum).Minimum
|
|
455
|
+
$t1 = ($ts | Measure-Object -Maximum).Maximum
|
|
456
|
+
$p0 = ($ps | Measure-Object -Minimum).Minimum
|
|
457
|
+
$p1 = ($ps | Measure-Object -Maximum).Maximum
|
|
458
|
+
if ($t1 -le $t0) { return }
|
|
459
|
+
$rango = [math]::Max(1, $p1 - $p0)
|
|
460
|
+
|
|
461
|
+
$pts = @()
|
|
462
|
+
for ($i = 0; $i -lt $h.Count; $i++) {
|
|
463
|
+
$pts += New-Object System.Drawing.PointF(
|
|
464
|
+
[float]($caja.X + $caja.Width * ($ts[$i] - $t0) / ($t1 - $t0)),
|
|
465
|
+
[float]($caja.Bottom - $caja.Height * ($ps[$i] - $p0) / $rango))
|
|
466
|
+
}
|
|
467
|
+
|
|
468
|
+
$c = $PALETA[$nivel]
|
|
469
|
+
# Un piso tenue, para que se vea que es un área y no una raya suelta.
|
|
470
|
+
$area = @(New-Object System.Drawing.PointF($pts[0].X, $caja.Bottom)) + $pts +
|
|
471
|
+
@(New-Object System.Drawing.PointF($pts[$pts.Count - 1].X, $caja.Bottom))
|
|
472
|
+
$br = New-Object System.Drawing.SolidBrush([System.Drawing.Color]::FromArgb(36, $c.R, $c.G, $c.B))
|
|
473
|
+
$g.FillPolygon($br, [System.Drawing.PointF[]]$area)
|
|
474
|
+
$br.Dispose()
|
|
475
|
+
|
|
476
|
+
$lap = New-Object System.Drawing.Pen($c, (Px 1.5))
|
|
477
|
+
$lap.LineJoin = [System.Drawing.Drawing2D.LineJoin]::Round
|
|
478
|
+
$g.DrawLines($lap, [System.Drawing.PointF[]]$pts)
|
|
479
|
+
$lap.Dispose()
|
|
480
|
+
|
|
481
|
+
# El punto de ahora, que es el que se mira.
|
|
482
|
+
$fin = $pts[$pts.Count - 1]
|
|
483
|
+
$d = Px 5
|
|
484
|
+
$brF = New-Object System.Drawing.SolidBrush($c)
|
|
485
|
+
$g.FillEllipse($brF, ($fin.X - $d / 2), ($fin.Y - $d / 2), $d, $d)
|
|
486
|
+
$brF.Dispose()
|
|
487
|
+
|
|
488
|
+
$horas = ($t1 - $t0) / 3600000
|
|
489
|
+
Escribir $g ('{0:d}%' -f [int][math]::Round($p0)) $caja.X ($caja.Bottom + (Px 1)) $script:FMini $script:Tinta3
|
|
490
|
+
$cola = if ($horas -ge 1) {
|
|
491
|
+
'últimas ' + ([double]$horas).ToString('0.0', [cultureinfo]::InvariantCulture) + ' h'
|
|
492
|
+
} else { 'última hora' }
|
|
493
|
+
Escribir $g $cola 0 ($caja.Bottom + (Px 1)) $script:FMini $script:Tinta3 $caja.Right
|
|
494
|
+
}
|
|
495
|
+
|
|
496
|
+
function AltoPerfil($p) {
|
|
497
|
+
$alto = (Px $MARGEN) + (Px $ALTO_CABECERA)
|
|
498
|
+
$cuota = $p.cuota
|
|
499
|
+
if ($cuota.estado -ne 'ok') {
|
|
500
|
+
$alto += (Px $ALTO_FRASE)
|
|
501
|
+
} else {
|
|
502
|
+
$alto += (Px $ALTO_BARRA) * (@($cuota.mostrar)).Count
|
|
503
|
+
# La curva es de la barra que frena, así que suma una vez y no por barra.
|
|
504
|
+
if ((@($cuota.historia)).Count -ge 3) { $alto += (Px $ALTO_CURVA) }
|
|
505
|
+
if (FraseRitmo $p.proyeccion) { $alto += (Px $ALTO_RITMO) }
|
|
506
|
+
}
|
|
507
|
+
return [int]($alto + (Px 10))
|
|
508
|
+
}
|
|
509
|
+
|
|
510
|
+
function DibujarPerfil($p, [int]$indice) {
|
|
511
|
+
$ancho = [int](Px $ANCHO_VISTA)
|
|
512
|
+
$alto = AltoPerfil $p
|
|
513
|
+
$bmp = New-Object System.Drawing.Bitmap($ancho, $alto)
|
|
514
|
+
$g = [System.Drawing.Graphics]::FromImage($bmp)
|
|
515
|
+
$g.SmoothingMode = [System.Drawing.Drawing2D.SmoothingMode]::AntiAlias
|
|
516
|
+
$g.TextRenderingHint = [System.Drawing.Text.TextRenderingHint]::ClearTypeGridFit
|
|
517
|
+
$g.Clear($script:Fondo)
|
|
518
|
+
|
|
519
|
+
$m = Px $MARGEN
|
|
520
|
+
$der = $ancho - $m
|
|
521
|
+
$y = Px $MARGEN
|
|
522
|
+
|
|
523
|
+
# El del MENÚ, que va sobre el fondo del menú.
|
|
524
|
+
$colorCuenta = ColorCuenta $indice $script:MenuOscuro
|
|
525
|
+
GlifoProducto $g $p.producto $colorCuenta $m ($y + (Px 2)) (Px 13)
|
|
526
|
+
Escribir $g (Corto $p.perfil) ($m + (Px 19)) $y $script:FTitulo $script:Tinta
|
|
527
|
+
$y += Px 17
|
|
528
|
+
|
|
529
|
+
$partes = @()
|
|
530
|
+
if ($p.cuenta) { $partes += $p.cuenta }
|
|
531
|
+
if ($p.plan) { $partes += $p.plan }
|
|
532
|
+
Escribir $g ($partes -join ' · ') ($m + (Px 19)) $y $script:FSub $script:Tinta3
|
|
533
|
+
$y += Px 22
|
|
534
|
+
|
|
535
|
+
$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
|
+
$peor = $cuota.frena
|
|
547
|
+
$chocas = [bool]($p.proyeccion -and $p.proyeccion.estado -eq 'sube' -and $p.proyeccion.chocasAntesDelReinicio)
|
|
548
|
+
|
|
549
|
+
foreach ($v in @($cuota.mostrar)) {
|
|
550
|
+
$esPeor = ($null -ne $peor -and $v.clave -eq $peor.clave -and $v.alcance -eq $peor.alcance)
|
|
551
|
+
$nivel = NivelDe ([int]$v.porcentaje) ([bool]($v.preocupa -or ($chocas -and $esPeor)))
|
|
552
|
+
$activa = [bool]$v.activa
|
|
553
|
+
|
|
554
|
+
$nombre = if ($activa) { (NombreVentana $v) + ' ▸' } else { NombreVentana $v }
|
|
555
|
+
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
|
|
558
|
+
$y += Px 18
|
|
559
|
+
|
|
560
|
+
# El medidor: pista tenue y relleno con el color del estado.
|
|
561
|
+
$h = Px 5
|
|
562
|
+
$brPista = New-Object System.Drawing.SolidBrush($script:Pista)
|
|
563
|
+
RectRedondeado $g (New-Object System.Drawing.RectangleF($m, $y, ($der - $m), $h)) ($h / 2) $brPista
|
|
564
|
+
$brPista.Dispose()
|
|
565
|
+
$frac = [math]::Max(0, [math]::Min(100, $v.porcentaje)) / 100
|
|
566
|
+
$anchoLleno = [math]::Max((Px 5), ($der - $m) * $frac)
|
|
567
|
+
$brLleno = New-Object System.Drawing.SolidBrush($PALETA[$nivel])
|
|
568
|
+
RectRedondeado $g (New-Object System.Drawing.RectangleF($m, $y, $anchoLleno, $h)) ($h / 2) $brLleno
|
|
569
|
+
$brLleno.Dispose()
|
|
570
|
+
$y += Px 9
|
|
571
|
+
|
|
572
|
+
$pie = ''
|
|
573
|
+
$seg = Faltan $v.reinicia
|
|
574
|
+
if ($null -ne $seg) { $pie = "reinicia en $(Dur $seg)" }
|
|
575
|
+
if ($esPeor -and $cuota.PSObject.Properties['edadSegundos']) {
|
|
576
|
+
$e = [int]$cuota.edadSegundos
|
|
577
|
+
if ($pie) { $pie += ' · ' }
|
|
578
|
+
$pie += "cache de hace $(Dur $e)"
|
|
579
|
+
if ($e -ge $VIEJO_SEGUNDOS) { $pie += ' · viejo' }
|
|
580
|
+
}
|
|
581
|
+
Escribir $g $pie $m $y $script:FPie $script:Tinta3
|
|
582
|
+
$y += Px 19
|
|
583
|
+
|
|
584
|
+
# La curva va pegada a la barra que frena: es de ella, no del perfil.
|
|
585
|
+
if ($esPeor -and (@($cuota.historia)).Count -ge 3) {
|
|
586
|
+
DibujarCurva $g $cuota.historia $nivel `
|
|
587
|
+
(New-Object System.Drawing.RectangleF($m, ($y + (Px 2)), ($der - $m), (Px 16)))
|
|
588
|
+
$y += Px $ALTO_CURVA
|
|
589
|
+
}
|
|
590
|
+
}
|
|
591
|
+
|
|
592
|
+
$ritmo = FraseRitmo $p.proyeccion
|
|
593
|
+
if ($ritmo) {
|
|
594
|
+
Escribir $g $ritmo $m $y $script:FPie $(if ($chocas) { $PALETA['critico'] } else { $script:Tinta3 })
|
|
595
|
+
}
|
|
596
|
+
|
|
597
|
+
$g.Dispose()
|
|
598
|
+
return $bmp
|
|
599
|
+
}
|
|
600
|
+
|
|
601
|
+
# La cabecera del panel: LO PRIMERO QUE TE FRENA.
|
|
602
|
+
#
|
|
603
|
+
# Es VistaResumen de qm-barra.swift. Con varias cuentas la primera pregunta no
|
|
604
|
+
# es «cómo va cada una» sino «cuál me frena y cuándo me suelta», y eso es una
|
|
605
|
+
# sola línea: va arriba de todo y el detalle por cuenta viene después.
|
|
606
|
+
#
|
|
607
|
+
# Devuelve $null cuando ninguna cuenta dejó número: una cabecera vacía sería
|
|
608
|
+
# peor que no tenerla, y cada perfil ya dice su propia frase abajo.
|
|
609
|
+
function DibujarResumen($perfiles) {
|
|
610
|
+
$mejorP = $null; $mejor = $null
|
|
611
|
+
foreach ($p in $perfiles) {
|
|
612
|
+
if ($p.cuota.estado -ne 'ok') { continue }
|
|
613
|
+
$v = $p.cuota.frena
|
|
614
|
+
if ($null -eq $v) { continue }
|
|
615
|
+
if ($null -eq $mejor -or $v.porcentaje -gt $mejor.porcentaje) { $mejor = $v; $mejorP = $p }
|
|
616
|
+
}
|
|
617
|
+
if ($null -eq $mejor) { return $null }
|
|
618
|
+
|
|
619
|
+
$pct = [int][math]::Round($mejor.porcentaje)
|
|
620
|
+
$chocas = [bool]($mejorP.proyeccion -and $mejorP.proyeccion.estado -eq 'sube' `
|
|
621
|
+
-and $mejorP.proyeccion.chocasAntesDelReinicio)
|
|
622
|
+
$nivel = NivelDe $pct ([bool]($mejor.preocupa -or $chocas))
|
|
623
|
+
$c = $PALETA[$nivel]
|
|
624
|
+
|
|
625
|
+
$ancho = [int](Px $ANCHO_VISTA)
|
|
626
|
+
$alto = [int](Px $ALTO_RESUMEN)
|
|
627
|
+
$bmp = New-Object System.Drawing.Bitmap($ancho, $alto)
|
|
628
|
+
$g = [System.Drawing.Graphics]::FromImage($bmp)
|
|
629
|
+
$g.SmoothingMode = [System.Drawing.Drawing2D.SmoothingMode]::AntiAlias
|
|
630
|
+
$g.TextRenderingHint = [System.Drawing.Text.TextRenderingHint]::ClearTypeGridFit
|
|
631
|
+
$g.Clear($script:Fondo)
|
|
632
|
+
|
|
633
|
+
# El anillo, igual que el del tablero: pista tenue del mismo color y arco
|
|
634
|
+
# con punta redondeada.
|
|
635
|
+
$m = Px $MARGEN
|
|
636
|
+
$lado = Px 44
|
|
637
|
+
$grosor = Px 5
|
|
638
|
+
$caja = New-Object System.Drawing.RectangleF(
|
|
639
|
+
($m + $grosor / 2), (($alto - $lado) / 2 + $grosor / 2),
|
|
640
|
+
($lado - $grosor), ($lado - $grosor))
|
|
641
|
+
$lapPista = New-Object System.Drawing.Pen(([System.Drawing.Color]::FromArgb(46, $c.R, $c.G, $c.B)), $grosor)
|
|
642
|
+
$g.DrawEllipse($lapPista, $caja)
|
|
643
|
+
$lapPista.Dispose()
|
|
644
|
+
$lap = New-Object System.Drawing.Pen($c, $grosor)
|
|
645
|
+
$lap.StartCap = [System.Drawing.Drawing2D.LineCap]::Round
|
|
646
|
+
$lap.EndCap = [System.Drawing.Drawing2D.LineCap]::Round
|
|
647
|
+
$g.DrawArc($lap, $caja, -90, [float]([math]::Max(4, [math]::Min(360, $pct * 3.6))))
|
|
648
|
+
$lap.Dispose()
|
|
649
|
+
|
|
650
|
+
$x = $m + $lado + (Px 14)
|
|
651
|
+
Escribir $g 'LO PRIMERO QUE TE FRENA' $x (Px 11) $script:FRotulo $script:Tinta3
|
|
652
|
+
$cifra = '{0:d}%' -f $pct
|
|
653
|
+
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.
|
|
655
|
+
Escribir $g (' {0} · {1}' -f (Corto $mejorP.perfil), (NombreVentana $mejor)) `
|
|
656
|
+
($x + $g.MeasureString($cifra, $script:FCifra).Width) (Px 30) $script:FSub $script:Tinta2
|
|
657
|
+
|
|
658
|
+
# Cuando ya te frenó, lo que importa no es cuándo «reinicia»: es cuándo
|
|
659
|
+
# volvés a poder trabajar. Es la misma fecha y una pregunta distinta.
|
|
660
|
+
$seg = Faltan $mejor.reinicia
|
|
661
|
+
$texto = if ($pct -ge 95 -and $null -ne $seg) { "libre en $(Dur $seg)" }
|
|
662
|
+
elseif ($null -ne $seg) { "reinicia en $(Dur $seg)" }
|
|
663
|
+
else { 'sin reinicio informado' }
|
|
664
|
+
Escribir $g $texto $x (Px 50) $script:FPie $(if ($pct -ge 95) { $c } else { $script:Tinta3 })
|
|
665
|
+
|
|
666
|
+
$g.Dispose()
|
|
667
|
+
return $bmp
|
|
668
|
+
}
|
|
669
|
+
|
|
670
|
+
# ── los íconos de la bandeja ────────────────────────────────────────────
|
|
671
|
+
# Nunca un número, y uno por cuenta.
|
|
672
|
+
#
|
|
673
|
+
# Lo primero que se aprendió acá: la primera versión dibujaba el porcentaje
|
|
674
|
+
# adentro del ícono, como los medidores de batería. Se renderizó a 16x16 —el
|
|
675
|
+
# tamaño real de la bandeja a 96 dpi— y se miró: un dígito se lee, dos son una
|
|
676
|
+
# mancha. Así que el número se va al tooltip y al menú, y el ícono hace de
|
|
677
|
+
# MEDIDOR: la forma dice cuánto va y el color dice cuánto importa, y las dos
|
|
678
|
+
# cosas sobreviven a 16 píxeles.
|
|
679
|
+
#
|
|
680
|
+
# Lo segundo: la barra de menú de macOS no muestra UN medidor, muestra una
|
|
681
|
+
# TIRA —glifo, medidor y número, una vez por cuenta— y eso es lo que se viene
|
|
682
|
+
# a mirar. En un item de bandeja no cabe, porque no tiene etiqueta de texto y
|
|
683
|
+
# es un cuadrado de 16x16. Así que la tira se reparte: un item por cuenta, con
|
|
684
|
+
# el glifo de su producto y el medidor de su semanal, y el número de la sesión
|
|
685
|
+
# en el tooltip. HacerIcono quedó para el único caso sin cuenta que mostrar:
|
|
686
|
+
# cuando qm no contesta.
|
|
687
|
+
#
|
|
688
|
+
# La pista es gris al 41 % de alfa a propósito: la barra de tareas puede ser
|
|
689
|
+
# clara u oscura y el ícono no se entera, así que un gris translúcido es lo
|
|
690
|
+
# único que se ve en las dos.
|
|
691
|
+
|
|
692
|
+
function HacerIcono([double]$pct, [string]$nivel) {
|
|
693
|
+
$lado = 32
|
|
694
|
+
$grosor = 8.0
|
|
695
|
+
$bmp = New-Object System.Drawing.Bitmap($lado, $lado)
|
|
696
|
+
$g = [System.Drawing.Graphics]::FromImage($bmp)
|
|
697
|
+
$g.SmoothingMode = [System.Drawing.Drawing2D.SmoothingMode]::AntiAlias
|
|
698
|
+
$g.Clear([System.Drawing.Color]::Transparent)
|
|
699
|
+
|
|
700
|
+
$m = $grosor / 2 + 0.5
|
|
701
|
+
$caja = New-Object System.Drawing.RectangleF($m, $m, ($lado - 2 * $m), ($lado - 2 * $m))
|
|
702
|
+
$lapPista = New-Object System.Drawing.Pen([System.Drawing.Color]::FromArgb(105, 128, 128, 128), $grosor)
|
|
703
|
+
$g.DrawEllipse($lapPista, $caja)
|
|
704
|
+
|
|
705
|
+
$lap = New-Object System.Drawing.Pen($PALETA[$nivel], $grosor)
|
|
706
|
+
$lap.StartCap = [System.Drawing.Drawing2D.LineCap]::Round
|
|
707
|
+
$lap.EndCap = [System.Drawing.Drawing2D.LineCap]::Round
|
|
708
|
+
# Un mínimo de arco: a 1 % un barrido exacto no dibuja nada, y "no dibuja
|
|
709
|
+
# nada" se lee igual que "no hay datos", que es justo lo que no es.
|
|
710
|
+
$barrido = [float]([math]::Max(4, [math]::Min(360, $pct * 3.6)))
|
|
711
|
+
$g.DrawArc($lap, $caja, -90, $barrido)
|
|
712
|
+
|
|
713
|
+
$h = $bmp.GetHicon()
|
|
714
|
+
$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
|
+
$clon = $ico.Clone()
|
|
718
|
+
[Qm.Nativo]::DestroyIcon($h) | Out-Null
|
|
719
|
+
$ico.Dispose(); $g.Dispose(); $bmp.Dispose(); $lapPista.Dispose(); $lap.Dispose()
|
|
720
|
+
return $clon
|
|
721
|
+
}
|
|
722
|
+
|
|
723
|
+
# Un trozo de la tira de macOS, hecho ícono: el glifo del producto y, al lado,
|
|
724
|
+
# el medidor vertical de la semanal.
|
|
725
|
+
#
|
|
726
|
+
# El glifo dice QUÉ suscripción es —la forma, el producto; el color, cuál de
|
|
727
|
+
# ellas— y el medidor dice cómo va. La identidad va en el glifo y nunca en el
|
|
728
|
+
# medidor, que está reservado para el estado: verde, ámbar y rojo no pueden
|
|
729
|
+
# significar además «esta es la cuenta 2».
|
|
730
|
+
#
|
|
731
|
+
# Se dibuja a 32 px, que es lo que pide la bandeja al 200 %, y Windows lo baja
|
|
732
|
+
# a 16 cuando hace falta. Por eso el trazo del glifo va explícito y grueso.
|
|
733
|
+
function IconoCuenta([string]$producto, $colorCuenta, $semanal, [string]$nivelSemanal) {
|
|
734
|
+
$lado = 32
|
|
735
|
+
$bmp = New-Object System.Drawing.Bitmap($lado, $lado)
|
|
736
|
+
$g = [System.Drawing.Graphics]::FromImage($bmp)
|
|
737
|
+
$g.SmoothingMode = [System.Drawing.Drawing2D.SmoothingMode]::AntiAlias
|
|
738
|
+
$g.Clear([System.Drawing.Color]::Transparent)
|
|
739
|
+
|
|
740
|
+
GlifoProducto $g $producto $colorCuenta 0 6 20 2.4
|
|
741
|
+
|
|
742
|
+
# El medidor es SIEMPRE la semanal. Si la cuenta no informa ninguna queda la
|
|
743
|
+
# pista vacía: mejor un hueco honesto que dibujar ahí otra cosa.
|
|
744
|
+
# 22 de 32 es la misma proporción que altoBarra/alto en medidores() de Swift
|
|
745
|
+
# (15 de 22). A 26 el medidor le ganaba al glifo y el ícono dejaba de decir
|
|
746
|
+
# de qué cuenta era.
|
|
747
|
+
$ancho = 6.0; $x = 23.0; $y0 = 5.0; $altoBarra = 22.0
|
|
748
|
+
$r = $ancho / 2
|
|
749
|
+
$brPista = New-Object System.Drawing.SolidBrush([System.Drawing.Color]::FromArgb(105, 128, 128, 128))
|
|
750
|
+
RectRedondeado $g (New-Object System.Drawing.RectangleF($x, $y0, $ancho, $altoBarra)) $r $brPista
|
|
751
|
+
$brPista.Dispose()
|
|
752
|
+
if ($null -ne $semanal) {
|
|
753
|
+
$frac = [math]::Max(0, [math]::Min(100, $semanal)) / 100
|
|
754
|
+
$h = [math]::Max($ancho, $altoBarra * $frac)
|
|
755
|
+
$br = New-Object System.Drawing.SolidBrush($PALETA[$nivelSemanal])
|
|
756
|
+
# Se llena desde ABAJO, como el medidor vertical de la barra de macOS.
|
|
757
|
+
RectRedondeado $g (New-Object System.Drawing.RectangleF($x, ($y0 + $altoBarra - $h), $ancho, $h)) $r $br
|
|
758
|
+
$br.Dispose()
|
|
759
|
+
}
|
|
760
|
+
|
|
761
|
+
$handle = $bmp.GetHicon()
|
|
762
|
+
$ico = [System.Drawing.Icon]::FromHandle($handle)
|
|
763
|
+
# Se clona para poder destruir el handle ya mismo: GetHicon() entrega uno que
|
|
764
|
+
# el GC no libera, y esto se rehace cada tick por cada cuenta.
|
|
765
|
+
$clon = $ico.Clone()
|
|
766
|
+
[Qm.Nativo]::DestroyIcon($handle) | Out-Null
|
|
767
|
+
$ico.Dispose(); $g.Dispose(); $bmp.Dispose()
|
|
768
|
+
return $clon
|
|
769
|
+
}
|
|
770
|
+
|
|
771
|
+
# ── datos ───────────────────────────────────────────────────────────────
|
|
772
|
+
|
|
773
|
+
function ArgsWsl([string]$cmd) {
|
|
774
|
+
$prefijo = if ($Distro) { "-d $Distro " } else { '' }
|
|
775
|
+
return "$prefijo-e bash -lc `"$cmd`""
|
|
776
|
+
}
|
|
777
|
+
|
|
778
|
+
function Leer {
|
|
779
|
+
# Devuelve el objeto del JSON, o un string con la frase del problema.
|
|
780
|
+
# Silencio es el bug (SOUL.md): si no hay número, hay una frase.
|
|
781
|
+
$psi = New-Object System.Diagnostics.ProcessStartInfo
|
|
782
|
+
$psi.FileName = 'wsl.exe'
|
|
783
|
+
$psi.Arguments = ArgsWsl "$QmLinux --json --breve"
|
|
784
|
+
$psi.RedirectStandardOutput = $true
|
|
785
|
+
$psi.RedirectStandardError = $true
|
|
786
|
+
$psi.UseShellExecute = $false
|
|
787
|
+
$psi.CreateNoWindow = $true
|
|
788
|
+
$psi.StandardOutputEncoding = [System.Text.Encoding]::UTF8
|
|
789
|
+
$psi.StandardErrorEncoding = [System.Text.Encoding]::UTF8
|
|
790
|
+
try {
|
|
791
|
+
$p = [System.Diagnostics.Process]::Start($psi)
|
|
792
|
+
$salida = $p.StandardOutput.ReadToEnd()
|
|
793
|
+
$err = $p.StandardError.ReadToEnd()
|
|
794
|
+
if (-not $p.WaitForExit(20000)) { try { $p.Kill() } catch { }; return 'qm tardó más de 20 s' }
|
|
795
|
+
} catch {
|
|
796
|
+
return "no pude correr qm: $($_.Exception.Message)"
|
|
797
|
+
}
|
|
798
|
+
# 3 es "cruzaste el umbral", no un error.
|
|
799
|
+
if ($p.ExitCode -ne 0 -and $p.ExitCode -ne 3) {
|
|
800
|
+
$linea = (($err + $salida).Trim() -split "`n")[0]
|
|
801
|
+
if (-not $linea) { $linea = 'sin detalle' }
|
|
802
|
+
return "qm salió $($p.ExitCode): $linea"
|
|
803
|
+
}
|
|
804
|
+
try { return ($salida | ConvertFrom-Json) } catch { return 'qm no devolvió JSON' }
|
|
805
|
+
}
|
|
806
|
+
|
|
807
|
+
# Cada cuánto volver a preguntarle al endpoint.
|
|
808
|
+
#
|
|
809
|
+
# Un intervalo fijo de 5 minutos es inservible para una barra que sube rápido:
|
|
810
|
+
# se llega al 100 % adentro de una sola espera. La cadencia sale de lo que ya
|
|
811
|
+
# sabemos —cuán alto está y cuánto falta para el techo—, que es exactamente
|
|
812
|
+
# para lo que existe la proyección. Misma escalera que cadencia() en
|
|
813
|
+
# qm-barra.swift.
|
|
814
|
+
$script:Alto = 0.0
|
|
815
|
+
$script:MinutosAlTecho = $null
|
|
816
|
+
|
|
817
|
+
function Cadencia {
|
|
818
|
+
$seg = $SEGUNDOS_SONDEO
|
|
819
|
+
if ($script:Alto -ge 90) { $seg = $MINIMO_RED }
|
|
820
|
+
elseif ($script:Alto -ge 75) { $seg = 120 }
|
|
821
|
+
elseif ($script:Alto -ge 50) { $seg = 240 }
|
|
822
|
+
if ($null -ne $script:MinutosAlTecho) {
|
|
823
|
+
if ($script:MinutosAlTecho -le 30) { $seg = [math]::Min($seg, $MINIMO_RED) }
|
|
824
|
+
elseif ($script:MinutosAlTecho -le 90) { $seg = [math]::Min($seg, 120) }
|
|
825
|
+
}
|
|
826
|
+
return [math]::Max($MINIMO_RED, $seg)
|
|
827
|
+
}
|
|
828
|
+
|
|
829
|
+
$script:UltimoCalentar = [datetime]::MinValue
|
|
830
|
+
$script:CuentasQueMueven = @()
|
|
831
|
+
# La espera de «Actualizar ahora», si hay una en curso.
|
|
832
|
+
$script:Espera = $null
|
|
833
|
+
$script:EsperaProc = $null
|
|
834
|
+
$script:EsperaDesde = [datetime]::MinValue
|
|
835
|
+
|
|
836
|
+
function Calentar([switch]$Forzado) {
|
|
837
|
+
# Se dispara y se suelta: el resultado lo levanta el tick siguiente. Esperarlo
|
|
838
|
+
# acá congelaría el menú, porque esto corre en el hilo de la interfaz.
|
|
839
|
+
#
|
|
840
|
+
# Devuelve el proceso para que quien lo pidió a mano pueda esperarlo sin
|
|
841
|
+
# bloquear, y -Forzado saltea la cadencia: si el usuario apretó el botón, la
|
|
842
|
+
# respuesta no es "todavía no toca".
|
|
843
|
+
if ($SinCalentar) { return $null }
|
|
844
|
+
if (-not $Forzado -and ((Get-Date) - $script:UltimoCalentar).TotalSeconds -lt (Cadencia)) { return $null }
|
|
845
|
+
$script:UltimoCalentar = Get-Date
|
|
846
|
+
# Sólo las cuentas que se mueven. Refrescar una que va al 9 % es gastar un
|
|
847
|
+
# pedido para confirmar que no pasó nada.
|
|
848
|
+
$cmd = if ($script:CuentasQueMueven.Count) {
|
|
849
|
+
"$QmLinux --calentar --cuentas=" + ($script:CuentasQueMueven -join ',')
|
|
850
|
+
} else { "$QmLinux --calentar" }
|
|
851
|
+
$psi = New-Object System.Diagnostics.ProcessStartInfo
|
|
852
|
+
$psi.FileName = 'wsl.exe'
|
|
853
|
+
$psi.Arguments = ArgsWsl $cmd
|
|
854
|
+
$psi.UseShellExecute = $false
|
|
855
|
+
$psi.CreateNoWindow = $true
|
|
856
|
+
try { return [System.Diagnostics.Process]::Start($psi) } catch { return $null }
|
|
857
|
+
}
|
|
858
|
+
|
|
859
|
+
# Abrir el panel a mano. `ShowContextMenu` es interno, así que va por reflexión;
|
|
860
|
+
# es lo mismo que hace el click izquierdo sobre un item.
|
|
861
|
+
function MostrarMenu($ni) {
|
|
862
|
+
if ($null -eq $ni) { return }
|
|
863
|
+
try {
|
|
864
|
+
$m = $ni.GetType().GetMethod('ShowContextMenu', [System.Reflection.BindingFlags]'Instance,NonPublic')
|
|
865
|
+
if ($m) { $m.Invoke($ni, $null) }
|
|
866
|
+
} catch { }
|
|
867
|
+
}
|
|
868
|
+
|
|
869
|
+
# «Actualizar ahora», que antes no actualizaba nada y después parpadeaba.
|
|
870
|
+
#
|
|
871
|
+
# Dos problemas encadenados. El primero: era el mismo `Calentar; Refrescar` del
|
|
872
|
+
# tick, y el calentado tarda ~930 ms mientras el Refrescar que venía detrás
|
|
873
|
+
# tarda ~250, así que leía el cache de ANTES del calentado que él mismo acababa
|
|
874
|
+
# de disparar. El número era exactamente el que ya estabas mirando.
|
|
875
|
+
#
|
|
876
|
+
# El segundo, que apareció recién al arreglar el primero: Windows cierra un
|
|
877
|
+
# menú al clickear cualquier item, así que el panel desaparecía y volvía dos
|
|
878
|
+
# segundos después. Un parpadeo no es una actualización.
|
|
879
|
+
#
|
|
880
|
+
# Ahora el panel NO se cierra —el cierre se cancela cuando el item clickeado es
|
|
881
|
+
# éste, y sólo éste— y el número aparece adentro del panel abierto. Mientras
|
|
882
|
+
# llega, el item dice «Actualizando…» y no acepta otro click: dos segundos sin
|
|
883
|
+
# ninguna señal se leen como que no pasó nada, que es de donde vino todo esto.
|
|
884
|
+
#
|
|
885
|
+
# La espera va con un timer y no con el hilo: congelar la interfaz un segundo
|
|
886
|
+
# sería volver al problema que explica el comentario de Calentar.
|
|
887
|
+
function ActualizarAhora {
|
|
888
|
+
if ($null -ne $script:Espera) { return } # ya hay uno en curso
|
|
889
|
+
$proc = Calentar -Forzado
|
|
890
|
+
if ($null -eq $proc) { Refrescar; return }
|
|
891
|
+
$script:EsperaProc = $proc
|
|
892
|
+
$script:EsperaDesde = Get-Date
|
|
893
|
+
# La señal de que está pasando algo, en el item que se apretó.
|
|
894
|
+
foreach ($it in @($script:Menu.Items)) {
|
|
895
|
+
if ($it -is [System.Windows.Forms.ToolStripMenuItem] -and $it.Text -eq $ETIQUETA_ACTUALIZAR) {
|
|
896
|
+
$it.Text = 'Actualizando…'
|
|
897
|
+
$it.Enabled = $false
|
|
898
|
+
}
|
|
899
|
+
}
|
|
900
|
+
$script:Espera = New-Object System.Windows.Forms.Timer
|
|
901
|
+
$script:Espera.Interval = 250
|
|
902
|
+
$script:Espera.Add_Tick({
|
|
903
|
+
$listo = $false
|
|
904
|
+
try { $listo = $script:EsperaProc.HasExited } catch { $listo = $true }
|
|
905
|
+
# Un techo, para no quedarse esperando un calentado que no vuelve.
|
|
906
|
+
if (-not $listo -and ((Get-Date) - $script:EsperaDesde).TotalSeconds -lt 15) { return }
|
|
907
|
+
$script:Espera.Stop()
|
|
908
|
+
$script:Espera.Dispose()
|
|
909
|
+
$script:Espera = $null
|
|
910
|
+
try { $script:EsperaProc.Dispose() } catch { }
|
|
911
|
+
$script:EsperaProc = $null
|
|
912
|
+
Refrescar
|
|
913
|
+
})
|
|
914
|
+
$script:Espera.Start()
|
|
915
|
+
}
|
|
916
|
+
|
|
917
|
+
# ── el menú ─────────────────────────────────────────────────────────────
|
|
918
|
+
|
|
919
|
+
function FilaImagen($bmp) {
|
|
920
|
+
$pb = New-Object System.Windows.Forms.PictureBox
|
|
921
|
+
$pb.Image = $bmp
|
|
922
|
+
$pb.Size = $bmp.Size
|
|
923
|
+
$pb.Margin = New-Object System.Windows.Forms.Padding(0)
|
|
924
|
+
$fila = New-Object System.Windows.Forms.ToolStripControlHost($pb)
|
|
925
|
+
$fila.AutoSize = $false
|
|
926
|
+
$fila.Size = $bmp.Size
|
|
927
|
+
$fila.Margin = New-Object System.Windows.Forms.Padding(0)
|
|
928
|
+
$fila.Padding = New-Object System.Windows.Forms.Padding(0)
|
|
929
|
+
return $fila
|
|
930
|
+
}
|
|
931
|
+
|
|
932
|
+
function ItemTexto([string]$t) {
|
|
933
|
+
$it = New-Object System.Windows.Forms.ToolStripMenuItem($t)
|
|
934
|
+
$it.Enabled = $false
|
|
935
|
+
# Un item deshabilitado se pinta con el gris del sistema, que sobre fondo
|
|
936
|
+
# oscuro no se lee. Y es justo el item que lleva la frase del problema.
|
|
937
|
+
$it.ForeColor = $script:Tinta2
|
|
938
|
+
return $it
|
|
939
|
+
}
|
|
940
|
+
|
|
941
|
+
function RevisarAvisos([string]$perfil, $v, $proy, [bool]$chocas) {
|
|
942
|
+
$base = "$perfil|$(NombreVentana $v)|$(AlMinuto $v.reinicia)"
|
|
943
|
+
$pct = $v.porcentaje
|
|
944
|
+
foreach ($u in $UMBRALES) {
|
|
945
|
+
if ($pct -ge $u) {
|
|
946
|
+
$seg = Faltan $v.reinicia
|
|
947
|
+
$cola = if ($null -ne $seg) { " Se reinicia en $(Dur $seg)." } else { '' }
|
|
948
|
+
Avisar "$base|$u" ("{0}: {1:d}% de {2}" -f $perfil, [int]$pct, (NombreVentana $v)) "Pasaste el $u%.$cola" ($u -ge 95)
|
|
949
|
+
}
|
|
950
|
+
}
|
|
951
|
+
if ($chocas -and $proy) {
|
|
952
|
+
$seg = Faltan $proy.techo
|
|
953
|
+
if ($null -eq $seg) { $seg = 0 }
|
|
954
|
+
Avisar "$base|choque" "${perfil}: a este ritmo llegás al 100%" `
|
|
955
|
+
("$(([double]$proy.ritmoPuntosPorHora).ToString('0.0', [cultureinfo]::InvariantCulture)) pts/h — " +
|
|
956
|
+
"tocás el techo en $(Dur $seg), antes de que la ventana se reinicie.") $true
|
|
957
|
+
}
|
|
958
|
+
}
|
|
959
|
+
|
|
960
|
+
# La tira: crea, actualiza y saca items de bandeja según las cuentas que haya.
|
|
961
|
+
#
|
|
962
|
+
# Reusar el mismo NotifyIcon mientras la cuenta siga existiendo es lo que evita
|
|
963
|
+
# que los íconos salten de lugar —o al desplegable de overflow— en cada tick.
|
|
964
|
+
# Windows los ordena por orden de registro, así que el orden de la tira es el
|
|
965
|
+
# orden en que aparecieron, que es el del menú.
|
|
966
|
+
function ActualizarTira($tira) {
|
|
967
|
+
$vivas = @()
|
|
968
|
+
foreach ($t in $tira) {
|
|
969
|
+
$vivas += $t.clave
|
|
970
|
+
if ($script:Iconos.Contains($t.clave)) {
|
|
971
|
+
$ni = $script:Iconos[$t.clave]
|
|
972
|
+
} else {
|
|
973
|
+
$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
|
+
$ni.Add_MouseUp($script:AbrirMenu)
|
|
978
|
+
$ni.Visible = $true
|
|
979
|
+
$script:Iconos[$t.clave] = $ni
|
|
980
|
+
}
|
|
981
|
+
$anterior = $ni.Icon
|
|
982
|
+
$ni.Icon = $t.icono
|
|
983
|
+
if ($anterior) { $anterior.Dispose() }
|
|
984
|
+
# NotifyIcon.Text no acepta más de 63 caracteres.
|
|
985
|
+
$texto = [string]$t.texto
|
|
986
|
+
if ($texto.Length -gt 63) { $texto = $texto.Substring(0, 60) + '...' }
|
|
987
|
+
$ni.Text = $texto
|
|
988
|
+
}
|
|
989
|
+
|
|
990
|
+
foreach ($clave in @($script:Iconos.Keys)) {
|
|
991
|
+
if ($vivas -contains $clave) { continue }
|
|
992
|
+
$ni = $script:Iconos[$clave]
|
|
993
|
+
$ni.Visible = $false
|
|
994
|
+
if ($ni.Icon) { $ni.Icon.Dispose() }
|
|
995
|
+
$ni.Dispose()
|
|
996
|
+
$script:Iconos.Remove($clave)
|
|
997
|
+
}
|
|
998
|
+
# El que emite los globos. Cualquiera sirve; tiene que estar visible.
|
|
999
|
+
$script:Ni = if ($script:Iconos.Count) { @($script:Iconos.Values)[0] } else { $null }
|
|
1000
|
+
}
|
|
1001
|
+
|
|
1002
|
+
function Refrescar {
|
|
1003
|
+
# Si el panel está abierto —«Actualizar ahora» lo deja así— hay que suspender
|
|
1004
|
+
# el layout mientras se cambian los items. Sin esto, cada Add() relayoutea y
|
|
1005
|
+
# reposiciona el menú visible: se ve saltar de tamaño una vez por sección.
|
|
1006
|
+
$abierto = $false
|
|
1007
|
+
try { $abierto = $script:Menu.Visible } catch { $abierto = $false }
|
|
1008
|
+
if ($abierto) { $script:Menu.SuspendLayout() }
|
|
1009
|
+
|
|
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
|
+
# Items.Clear() saca los items de la lista pero no los libera, y acá se
|
|
1018
|
+
# reconstruye el menú entero cada tick.
|
|
1019
|
+
foreach ($viejo in @($menu.Items)) { $viejo.Dispose() }
|
|
1020
|
+
$menu.Items.Clear()
|
|
1021
|
+
# Un PictureBox no libera su Image al morir, así que los mapas de bits del
|
|
1022
|
+
# tick anterior se sueltan a mano. Con la cabecera son uno más por vuelta, y
|
|
1023
|
+
# cada uno mide 340 px de ancho.
|
|
1024
|
+
foreach ($b in @($script:Bitmaps)) { try { $b.Dispose() } catch { } }
|
|
1025
|
+
$script:Bitmaps = @()
|
|
1026
|
+
|
|
1027
|
+
$pico = 0.0
|
|
1028
|
+
$script:MinutosAlTecho = $null
|
|
1029
|
+
$mueven = @()
|
|
1030
|
+
$tira = @()
|
|
1031
|
+
|
|
1032
|
+
if ($datos -is [string]) {
|
|
1033
|
+
$menu.Items.Add((ItemTexto $datos)) | Out-Null
|
|
1034
|
+
# Sin datos no hay cuentas: queda un solo item, con el arco vacío.
|
|
1035
|
+
$tira = @(@{ clave = '?'; icono = (HacerIcono 0 'atento'); texto = "qm · $datos" })
|
|
1036
|
+
} else {
|
|
1037
|
+
$resumen = DibujarResumen $datos.perfiles
|
|
1038
|
+
if ($resumen) {
|
|
1039
|
+
$script:Bitmaps += $resumen
|
|
1040
|
+
$menu.Items.Add((FilaImagen $resumen)) | Out-Null
|
|
1041
|
+
$menu.Items.Add((New-Object System.Windows.Forms.ToolStripSeparator)) | Out-Null
|
|
1042
|
+
}
|
|
1043
|
+
|
|
1044
|
+
# El índice del color de cuenta avanza sólo con las que dejaron número,
|
|
1045
|
+
# igual que iCuenta en qm-barra.swift: una cuenta muda no gasta un color,
|
|
1046
|
+
# así que las que se ven conservan el suyo de una lectura a la otra.
|
|
1047
|
+
$iCuenta = 0
|
|
1048
|
+
foreach ($p in $datos.perfiles) {
|
|
1049
|
+
$bmp = DibujarPerfil $p $iCuenta
|
|
1050
|
+
$script:Bitmaps += $bmp
|
|
1051
|
+
$menu.Items.Add((FilaImagen $bmp)) | Out-Null
|
|
1052
|
+
$menu.Items.Add((New-Object System.Windows.Forms.ToolStripSeparator)) | Out-Null
|
|
1053
|
+
|
|
1054
|
+
$cuota = $p.cuota
|
|
1055
|
+
$nombre = Corto $p.perfil
|
|
1056
|
+
# El del ÍCONO, que va sobre la barra de tareas y puede no ser el mismo.
|
|
1057
|
+
$colorCuenta = ColorCuenta $iCuenta $script:BarraOscura
|
|
1058
|
+
|
|
1059
|
+
# Un lugar en la tira POR PERFIL, tenga número o no.
|
|
1060
|
+
#
|
|
1061
|
+
# macOS puede dejar afuera a una cuenta muda porque su tira es un solo
|
|
1062
|
+
# dibujo que se rehace entero. Acá cada lugar es un item de bandeja, y
|
|
1063
|
+
# Windows lo identifica por el hash de (ejecutable + UID) donde el UID lo
|
|
1064
|
+
# reparte WinForms POR ORDEN DE CREACIÓN. Medido en el registro, en
|
|
1065
|
+
# Control Panel\NotifyIconSettings. O sea: sacar y volver a poner un item
|
|
1066
|
+
# corre los UID de los que vienen después, y con eso se le muda de cuenta
|
|
1067
|
+
# la decisión de "este ícono va fijo en la barra" que el usuario tomó
|
|
1068
|
+
# arrastrándolo. Un lugar fijo por perfil, con el medidor vacío cuando no
|
|
1069
|
+
# hay número, cuesta un cuadradito y salva esa decisión.
|
|
1070
|
+
if ($cuota.estado -ne 'ok') {
|
|
1071
|
+
$frase = if ($cuota.PSObject.Properties['frase']) { $cuota.frase } else { 'sin cuota' }
|
|
1072
|
+
$tira += @{
|
|
1073
|
+
clave = [string]$p.perfil
|
|
1074
|
+
icono = (IconoCuenta $p.producto $colorCuenta $null 'ok')
|
|
1075
|
+
texto = "$nombre · $frase"
|
|
1076
|
+
}
|
|
1077
|
+
continue
|
|
1078
|
+
}
|
|
1079
|
+
$iCuenta++
|
|
1080
|
+
|
|
1081
|
+
$peor = $cuota.frena
|
|
1082
|
+
$proy = $p.proyeccion
|
|
1083
|
+
$chocas = [bool]($proy -and $proy.estado -eq 'sube' -and $proy.chocasAntesDelReinicio)
|
|
1084
|
+
$viejo = if ($cuota.edadSegundos -gt $VIEJO_SEGUNDOS) { '~' } else { '' }
|
|
1085
|
+
|
|
1086
|
+
# El medidor es SIEMPRE la semanal; el número de la sesión —que en macOS
|
|
1087
|
+
# va al lado del medidor— acá no tiene dónde ir y se va al tooltip.
|
|
1088
|
+
$ses = $cuota.sesion
|
|
1089
|
+
$sem = $cuota.semanal
|
|
1090
|
+
$nivelSem = if ($null -ne $sem) {
|
|
1091
|
+
NivelDe ([int]$sem.porcentaje) `
|
|
1092
|
+
([bool]($sem.preocupa -or ($chocas -and $null -ne $peor -and $sem.clave -eq $peor.clave)))
|
|
1093
|
+
} else { 'ok' }
|
|
1094
|
+
$partes = @($nombre)
|
|
1095
|
+
if ($null -ne $ses) { $partes += ('sesión {0}{1:d}%' -f $viejo, [int][math]::Round($ses.porcentaje)) }
|
|
1096
|
+
if ($null -ne $sem) { $partes += ('{0} {1:d}%' -f (NombreVentana $sem), [int][math]::Round($sem.porcentaje)) }
|
|
1097
|
+
$tira += @{
|
|
1098
|
+
clave = [string]$p.perfil
|
|
1099
|
+
icono = (IconoCuenta $p.producto $colorCuenta `
|
|
1100
|
+
$(if ($null -ne $sem) { [int]$sem.porcentaje } else { $null }) $nivelSem)
|
|
1101
|
+
texto = ($partes -join ' · ')
|
|
1102
|
+
}
|
|
1103
|
+
|
|
1104
|
+
if ($null -ne $peor) {
|
|
1105
|
+
$pct = [double]$peor.porcentaje
|
|
1106
|
+
if ($pct -ge 40) { $mueven += $nombre }
|
|
1107
|
+
if ($pct -gt $pico) { $pico = $pct }
|
|
1108
|
+
RevisarAvisos $nombre $peor $proy $chocas
|
|
1109
|
+
}
|
|
1110
|
+
if ($chocas) {
|
|
1111
|
+
$seg = Faltan $proy.techo
|
|
1112
|
+
if ($null -ne $seg) {
|
|
1113
|
+
$min = $seg / 60
|
|
1114
|
+
if ($null -eq $script:MinutosAlTecho -or $min -lt $script:MinutosAlTecho) { $script:MinutosAlTecho = $min }
|
|
1115
|
+
}
|
|
1116
|
+
}
|
|
1117
|
+
}
|
|
1118
|
+
|
|
1119
|
+
$script:Alto = $pico
|
|
1120
|
+
$script:CuentasQueMueven = $mueven
|
|
1121
|
+
|
|
1122
|
+
# Ahora cada perfil tiene su lugar, así que esto sólo salta si qm no
|
|
1123
|
+
# encontró ni un perfil. La bandeja vacía es el silencio otra vez.
|
|
1124
|
+
if (-not $tira.Count) {
|
|
1125
|
+
$tira = @(@{ clave = '?'; icono = (HacerIcono 0 'atento'); texto = 'qm · sin cuota' })
|
|
1126
|
+
}
|
|
1127
|
+
}
|
|
1128
|
+
|
|
1129
|
+
ActualizarTira $tira
|
|
1130
|
+
SoltarGlobos
|
|
1131
|
+
|
|
1132
|
+
# El item que se apretó volvió a nacer con su texto normal, así que no hay
|
|
1133
|
+
# que deshacer el «Actualizando…»: se fue con el item viejo.
|
|
1134
|
+
foreach ($par in @(
|
|
1135
|
+
@{ t = $ETIQUETA_ACTUALIZAR; a = { ActualizarAhora } },
|
|
1136
|
+
@{ t = 'Abrir tablero'; a = { AbrirTablero } },
|
|
1137
|
+
@{ t = 'Salir'; a = { $script:Ctx.ExitThread() } }
|
|
1138
|
+
)) {
|
|
1139
|
+
$it = New-Object System.Windows.Forms.ToolStripMenuItem($par.t)
|
|
1140
|
+
$it.ForeColor = $script:Tinta
|
|
1141
|
+
$it.Add_Click($par.a)
|
|
1142
|
+
$menu.Items.Add($it) | Out-Null
|
|
1143
|
+
}
|
|
1144
|
+
|
|
1145
|
+
if ($abierto) {
|
|
1146
|
+
$script:Menu.ResumeLayout($true)
|
|
1147
|
+
# El panel cambió de alto, así que hay que reacomodarlo: sin esto se queda
|
|
1148
|
+
# con el tamaño de antes y recorta la última sección.
|
|
1149
|
+
$script:Menu.PerformLayout()
|
|
1150
|
+
}
|
|
1151
|
+
}
|
|
1152
|
+
|
|
1153
|
+
function AbrirTablero {
|
|
1154
|
+
# Si ya hay alguien escuchando, no se levanta un segundo servidor.
|
|
1155
|
+
$vivo = $false
|
|
1156
|
+
try {
|
|
1157
|
+
$c = New-Object System.Net.Sockets.TcpClient
|
|
1158
|
+
$vivo = $c.ConnectAsync('127.0.0.1', $Puerto).Wait(400)
|
|
1159
|
+
$c.Close()
|
|
1160
|
+
} catch { $vivo = $false }
|
|
1161
|
+
if (-not $vivo) {
|
|
1162
|
+
$psi = New-Object System.Diagnostics.ProcessStartInfo
|
|
1163
|
+
$psi.FileName = 'wsl.exe'
|
|
1164
|
+
$psi.Arguments = ArgsWsl "qm-web --sin-abrir --puerto=$Puerto"
|
|
1165
|
+
$psi.UseShellExecute = $false
|
|
1166
|
+
$psi.CreateNoWindow = $true
|
|
1167
|
+
try { [System.Diagnostics.Process]::Start($psi) | Out-Null; Start-Sleep -Milliseconds 1200 } catch { }
|
|
1168
|
+
}
|
|
1169
|
+
Start-Process "http://127.0.0.1:$Puerto"
|
|
1170
|
+
}
|
|
1171
|
+
|
|
1172
|
+
# ── arranque ────────────────────────────────────────────────────────────
|
|
1173
|
+
|
|
1174
|
+
# El menú es uno solo y lo comparten todos los items de la tira, así que se
|
|
1175
|
+
# arma antes que ellos.
|
|
1176
|
+
$script:Menu = New-Object System.Windows.Forms.ContextMenuStrip
|
|
1177
|
+
# Sin esto el menú reserva una canaleta a la izquierda para tildes e íconos, y
|
|
1178
|
+
# el dibujo queda corrido y con un escalón que no es parte del diseño.
|
|
1179
|
+
$script:Menu.ShowImageMargin = $false
|
|
1180
|
+
$script:Menu.ShowCheckMargin = $false
|
|
1181
|
+
$null = AplicarTema
|
|
1182
|
+
|
|
1183
|
+
# Que «Actualizar ahora» no cierre el panel.
|
|
1184
|
+
#
|
|
1185
|
+
# WinForms cierra un menú al clickear cualquier item, y ahí se pierde justo lo
|
|
1186
|
+
# que se venía a mirar. El cierre se puede cancelar, pero sólo se cancela para
|
|
1187
|
+
# ESTE item: «Abrir tablero» y «Salir» tienen que seguir cerrándolo, y clickear
|
|
1188
|
+
# afuera o apretar Escape también.
|
|
1189
|
+
#
|
|
1190
|
+
# Hacen falta los dos handlers y no uno: ItemClicked corre antes que Closing y
|
|
1191
|
+
# es el único que sabe QUÉ se clickeó; Closing es el único que puede cancelar.
|
|
1192
|
+
$script:MantenerAbierto = $false
|
|
1193
|
+
$script:Menu.Add_ItemClicked({
|
|
1194
|
+
$script:MantenerAbierto = ($_.ClickedItem.Text -eq $ETIQUETA_ACTUALIZAR)
|
|
1195
|
+
})
|
|
1196
|
+
$script:Menu.Add_Closing({
|
|
1197
|
+
if ($script:MantenerAbierto -and
|
|
1198
|
+
$_.CloseReason -eq [System.Windows.Forms.ToolStripDropDownCloseReason]::ItemClicked) {
|
|
1199
|
+
$_.Cancel = $true
|
|
1200
|
+
}
|
|
1201
|
+
$script:MantenerAbierto = $false
|
|
1202
|
+
})
|
|
1203
|
+
|
|
1204
|
+
# La tira, indexada por perfil y en orden de aparición. Y el item que emite los
|
|
1205
|
+
# globos, que sale de ella.
|
|
1206
|
+
$script:Iconos = [ordered]@{}
|
|
1207
|
+
$script:Bitmaps = @()
|
|
1208
|
+
$script:Ni = $null
|
|
1209
|
+
|
|
1210
|
+
# Click izquierdo también abre el menú: en la bandeja lo único que se ve es el
|
|
1211
|
+
# ícono, y esperar que el usuario adivine que va con botón derecho es la misma
|
|
1212
|
+
# 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.
|
|
1214
|
+
$script:AbrirMenu = {
|
|
1215
|
+
if ($_.Button -eq [System.Windows.Forms.MouseButtons]::Left) { MostrarMenu $this }
|
|
1216
|
+
}
|
|
1217
|
+
|
|
1218
|
+
$script:Escala = [math]::Max(1.0, $script:Menu.DeviceDpi / 96.0)
|
|
1219
|
+
CrearFuentes
|
|
1220
|
+
|
|
1221
|
+
$script:Ctx = New-Object System.Windows.Forms.ApplicationContext
|
|
1222
|
+
|
|
1223
|
+
$timer = New-Object System.Windows.Forms.Timer
|
|
1224
|
+
$timer.Interval = $Segundos * 1000
|
|
1225
|
+
$timer.Add_Tick({ $null = Calentar; Refrescar })
|
|
1226
|
+
$timer.Start()
|
|
1227
|
+
|
|
1228
|
+
$null = Calentar
|
|
1229
|
+
Refrescar
|
|
1230
|
+
|
|
1231
|
+
try {
|
|
1232
|
+
[System.Windows.Forms.Application]::Run($script:Ctx)
|
|
1233
|
+
} finally {
|
|
1234
|
+
$timer.Stop()
|
|
1235
|
+
foreach ($ni in @($script:Iconos.Values)) {
|
|
1236
|
+
$ni.Visible = $false
|
|
1237
|
+
if ($ni.Icon) { $ni.Icon.Dispose() }
|
|
1238
|
+
$ni.Dispose()
|
|
1239
|
+
}
|
|
1240
|
+
foreach ($b in @($script:Bitmaps)) { try { $b.Dispose() } catch { } }
|
|
1241
|
+
}
|