juegos

modes_gfx.c (17072B)

---

 /* modes_gfx.c - pantallas de los modos en pixeles (Ecuaciones, Tabla, Grafico, Estadistica). */
 #include <string.h>
 #include "calc_gfx.h"
 #include "dmath.h"
 #include "str.h"
 
 #define BG      RGB(18, 22, 30)
 #define PANEL   RGB(30, 36, 50)
 #define FG      RGB(236, 236, 236)
 #define DIM     RGB(130, 138, 156)
 #define ACC     RGB(255, 200, 60)
 #define RESC    RGB(140, 220, 255)
 #define SEL     RGB(48, 58, 80)
 #define CURS    RGB(255, 226, 0)
 #define ERRC    RGB(255, 100, 90)
 #define FCOL    RGB(120, 200, 255)
 #define GCOL    RGB(255, 140, 90)
 
 int eq_cells(int type);
 const char *stat_type_name(int t);
 void graph_trace(Calc *c);
 
 extern Layout g_lay[];                 /* render.c */
 #define L_in g_lay[0]
 #define L_v  (g_lay + 1)
 static Expr tmp;
 
 /* z = re + im i como expresion */
 static void cplx_expr(const Calc *c, const Cplx *z, Expr *out)
 {
     static Expr a;
     bool im0 = !z->im.v.m;
     calc_result_expr(c, &z->re, false, out);
     if (im0) return;
     Num im = z->im;
     bool neg = im.v.neg;
     if (neg) im = num_neg(im);
     calc_result_expr(c, &im, false, &a);
     out->cur = out->n;
     if (!z->re.v.m) { ex_clear(out); if (neg) ex_insert_raw(out, '-'); }
     else ex_insert_raw(out, neg ? '-' : '+');
     bool one = im.exact && ex_is_int(&im.x) && im.x.a == 1;
     if (!one) ex_insert_expr(out, &a);
     ex_insert_raw(out, 'i');
 }
 
 static void val_text(const Calc *c, const Num *v, bool err, char *b, int n)
 {
     if (err || num_bad(v)) { str_put(b, n, 0, "Error"); return; }
     fmt_plain(v, &c->fmt, false, b, n);
 }
 
 static void header(Surface *s, const Calc *c, const char *title)
 {
     gfx_rect(s, 0, 0, 320, 320, BG);
     gfx_rect(s, 0, 0, 320, 14, PANEL);
     cf_text(s, &cf_small, 3, 1, calc_ang_name(c->ang), FG);
     if (c->shift) { gfx_rect(s, 14, 1, 9, 12, ACC); cf_text(s, &cf_small, 16, 1, "S", BG); }
     const char *t = c->msg[0] ? c->msg : title;
     cf_text(s, &cf_small, 160 - cf_text_w(&cf_small, t) / 2, 1, t, c->msg[0] ? ACC : DIM);
 }
 
 static void help(Surface *s, const char *t)
 {
     gfx_rect(s, 0, 306, 320, 14, PANEL);
     cf_text(s, &cf_small, 4, 307, t, DIM);
 }
 
 /* caja de edicion abajo (con la entrada c->in) */
 static int input_box(Surface *s, const Calc *c, const char *label, int y)
 {
     int h = L_in.asc + L_in.desc;
     if (h < 15) h = 15;
     gfx_rect(s, 0, y, 320, h + 8, PANEL);
     gfx_rect(s, 0, y, 320, 1, ACC);
     int x = 6;
     if (label) x += cf_text(s, &cf_big, 6, y + 4 + L_in.asc - 11, label, ACC) + 4;
     int sc = 0, cx = L_in.gx[c->in.cur];
     if (x + cx > 310) sc = x + cx - 310;
     gfx_clip(s, x, y + 1, 316 - x, h + 6);
     layout_draw(s, &L_in, x - sc, y + 4, FG, c->in.cur, CURS);
     gfx_noclip(s);
     return h + 8;
 }
 
 /* ------------------------------------------------------------ ecuaciones */
 
 static const char *const EQ_TITLE[] = { "Sistema 2×2", "Sistema 3×3", "Polinomio de grado 2", "Polinomio de grado 3", "SOLVE" };
 
 static void eqn_paint(Surface *s, Calc *c)
 {
     EqnState *q = &c->eq;
     header(s, c, EQ_TITLE[q->type]);
     char b[80];
     if (q->type == EQ_SOLVE && q->phase == 0) {
         cf_text(s, &cf_bold, 8, 24, "Ecuación con X (sin = es = 0):", ACC);
         int p = str_put(b, sizeof b, 0, "Empieza a buscar en X = ");
         fmt_plain(&c->vars[VAR_X], &c->fmt, true, b + p, (int)sizeof b - p);
         cf_text(s, &cf_small, 8, 44, b, DIM);
         input_box(s, c, 0, 200);
         help(s, "Enter resuelve   Esc borra / cambia el tipo");
         return;
     }
     if (q->phase == 0) {
         static const char *const HDR[][4] = {
             { "a", "b", "c" }, { "a", "b", "c", "d" }, { "a", "b", "c" }, { "a", "b", "c", "d" } };
         static const char *const FORM_TXT[] = { "a·x + b·y = c", "a·x + b·y + c·z = d", "a·x² + b·x + c = 0", "a·x³ + b·x² + c·x + d = 0" };
         cf_text(s, &cf_big, 8, 22, FORM_TXT[q->type], DIM);
         int cols = q->type == EQ_SYS2 || q->type == EQ_POLY2 ? 3 : 4;
         int rows = eq_cells(q->type) / cols, cw = 300 / cols;
         for (int j = 0; j < cols; j++) cf_text(s, &cf_bold, 12 + j * cw + cw / 2 - 4, 46, HDR[q->type][j], ACC);
         for (int i = 0; i < rows; i++)
             for (int j = 0; j < cols; j++) {
                 int k = i * cols + j, x = 10 + j * cw, y = 64 + i * 26;
                 bool sel = k == q->sel;
                 gfx_box(s, x, y, cw - 4, 22, sel ? SEL : PANEL, sel ? ACC : RGB(50, 58, 76));
                 val_text(c, &q->coef[k], false, b, sizeof b);
                 gfx_clip(s, x + 2, y, cw - 8, 22);
                 cf_text(s, &cf_big, x + cw - 8 - cf_text_w(&cf_big, b), y + 5, b, FG);
                 gfx_noclip(s);
             }
         if (q->editing) input_box(s, c, "=", 250);
         help(s, q->editing ? "Enter guarda   Esc cancela" : "Tipeá un valor   Enter resuelve   Esc tipo");
         return;
     }
     /* soluciones */
     int y = 26;
     if (q->note[0]) { cf_text(s, &cf_bold, 10, 40, q->note, ERRC); help(s, "Esc vuelve"); return; }
     static const char *const VN[] = { "x", "y", "z" };
     static const char *const XN[] = { "x1", "x2", "x3" };
     int n = q->nsol;
     if (q->type == EQ_SOLVE) {
         calc_result_expr(c, &q->solve_x, false, &tmp);
         layout_expr(&tmp, &METRIC_PX, &L_v[0]);
         cf_text(s, &cf_bold, 10, y + L_v[0].asc - 11, "X =", ACC);
         layout_draw(s, &L_v[0], 50, y, RESC, -1, 0);
         y += L_v[0].asc + L_v[0].desc + 12;
         int p = str_put(b, sizeof b, 0, "L-R = ");
         fmt_plain(&q->solve_lr, &c->fmt, true, b + p, (int)sizeof b - p);
         cf_text(s, &cf_big, 10, y, b, DIM);
         help(s, "Esc vuelve a la ecuación (X quedó guardado)");
         return;
     }
     for (int i = 0; i < n; i++) {
         cplx_expr(c, &q->sol[i], &tmp);
         layout_expr(&tmp, &METRIC_PX, &L_v[i]);
         const char *nm = q->type <= EQ_SYS3 ? VN[i] : XN[i];
         bool sel = i == q->shown;
         int h = L_v[i].asc + L_v[i].desc;
         if (sel) gfx_rect(s, 4, y - 3, 312, h + 6, SEL);
         cf_text(s, &cf_bold, 10, y + L_v[i].asc - 11, nm, ACC);
         cf_text(s, &cf_big, 34, y + L_v[i].asc - 11, "=", DIM);
         layout_draw(s, &L_v[i], 50, y, RESC, -1, 0);
         y += h + 12;
     }
     if (q->type == EQ_POLY2 && q->nsol) {
         bool mx = q->coef[0].v.neg;
         cf_text(s, &cf_small, 10, y, mx ? "Máximo:" : "Mínimo:", DIM);
         y += 14;
         calc_result_expr(c, &q->sol[2].re, false, &tmp);
         layout_expr(&tmp, &METRIC_PX, &L_v[4]);
         calc_result_expr(c, &q->sol[2].im, false, &tmp);
         layout_expr(&tmp, &METRIC_PX, &L_v[5]);
         cf_text(s, &cf_big, 10, y + L_v[4].asc - 11, "x =", DIM);
         layout_draw(s, &L_v[4], 50, y, FG, -1, 0);
         y += L_v[4].asc + L_v[4].desc + 8;
         cf_text(s, &cf_big, 10, y + L_v[5].asc - 11, "y =", DIM);
         layout_draw(s, &L_v[5], 50, y, FG, -1, 0);
     }
     help(s, "↑↓ elige   Tab decimal   Esc vuelve");
 }
 
 /* ------------------------------------------------------------ tabla */
 
 static void table_paint(Surface *s, Calc *c)
 {
     TableState *t = &c->tb;
     header(s, c, "Tabla");
     char b[64];
     if (t->phase < 2) {
         cf_text(s, &cf_bold, 8, 24, t->phase == 0 ? "f(x) =" : "g(x) =", ACC);
         cf_text(s, &cf_small, 8, 44, "Escribí la función con x (o X). Enter sigue.", DIM);
         if (t->phase == 1) {
             cf_text(s, &cf_small, 8, 60, "f(x) ya está. ↑ vuelve a f(x).", DIM);
         }
         input_box(s, c, t->phase == 0 ? "f(x)=" : "g(x)=", 200);
         help(s, "Enter: rango de la tabla   Esc borra");
         return;
     }
     int cols = t->use_g ? 3 : 2, cw = 310 / cols;
     static const char *const H[] = { "x", "f(x)", "g(x)" };
     for (int j = 0; j < cols; j++) cf_text(s, &cf_bold, 8 + j * cw + cw - 10 - cf_text_w(&cf_bold, H[j]), 18, H[j], ACC);
     gfx_rect(s, 4, 33, 312, 1, DIM);
     int rows = 15;
     if (t->sel < t->top) t->top = t->sel;
     if (t->sel >= t->top + rows) t->top = t->sel - rows + 1;
     for (int r = t->top; r < t->rows && r < t->top + rows; r++) {
         int y = 36 + (r - t->top) * 16;
         if (r == t->sel) gfx_rect(s, 4, y - 1, 312, 16, SEL);
         for (int j = 0; j < cols; j++) {
             const Num *v = j == 0 ? &t->x[r] : j == 1 ? &t->fx[r] : &t->gx[r];
             bool err = j == 1 ? t->ferr[r] : j == 2 ? t->gerr[r] : false;
             val_text(c, v, err, b, sizeof b);
             gfx_clip(s, 8 + j * cw, y, cw - 4, 16);
             int w = cf_text_w(&cf_big, b);
             cf_text(s, &cf_big, 8 + j * cw + cw - 10 - w, y + 1, b, err ? ERRC : j ? RESC : FG);
             gfx_noclip(s);
         }
     }
     if (!t->rows) cf_text(s, &cf_big, 10, 60, "No hay filas (revisá el rango)", ERRC);
     /* valor completo de la fila elegida */
     if (t->rows) {
         calc_result_expr(c, &t->fx[t->sel], false, &tmp);
         layout_expr(&tmp, &METRIC_PX, &L_v[0]);
         gfx_rect(s, 0, 280 - L_v[0].asc - L_v[0].desc, 320, L_v[0].asc + L_v[0].desc + 26, PANEL);
         if (!t->ferr[t->sel]) layout_draw(s, &L_v[0], 312 - L_v[0].w, 296 - L_v[0].asc - L_v[0].desc, RESC, -1, 0);
     }
     help(s, "↑↓ recorre   Enter/Esc edita f(x)");
 }
 
 /* ------------------------------------------------------------ grafico */
 
 #define GY0 15
 #define GH  262
 
 static int gy_of(Dec y, const GraphState *g)
 {
     Dec r = dec_div(dec_mul_int(dec_sub(g->ymax, y), GH - 1), dec_sub(g->ymax, g->ymin));
     int64_t v;
     if (!dec_to_int(dec_round_int(r), &v) || v < -10000 || v > 10000) return r.neg ? -10000 : 10000;
     return (int)v;
 }
 
 static int gx_of(Dec x, const GraphState *g)
 {
     Dec r = dec_div(dec_mul_int(dec_sub(x, g->xmin), 319), dec_sub(g->xmax, g->xmin));
     int64_t v;
     if (!dec_to_int(dec_round_int(r), &v) || v < -10000 || v > 10000) return r.neg ? -10000 : 10000;
     return (int)v;
 }
 
 /* paso "lindo" de la grilla: 1, 2 o 5 por 10^k, unas 8 divisiones */
 static Dec nice_step(Dec span)
 {
     Dec s = dec_div_int(span, 8);
     if (!s.m) return DEC_ONE;
     Dec p = dec_scale10(DEC_ONE, s.e);
     Dec m = dec_div(s, p);
     int64_t k;
     dec_to_int(dec_round_int(m), &k);
     k = k <= 1 ? 1 : k <= 3 ? 2 : k <= 7 ? 5 : 10;
     return dec_mul_int(p, k);
 }
 
 static void curve(Surface *s, const int16_t *ys, Color col)
 {
     for (int i = 0; i < 320; i++) {
         if (ys[i] == INT16_MIN) continue;
         int y = ys[i];
         if (i > 0 && ys[i - 1] != INT16_MIN) {
             int py = ys[i - 1];
             if ((py < -GH || py > 2 * GH) && (y < -GH || y > 2 * GH)) continue;
             if (py - y < GH && y - py < GH) {
                 int a = py < y ? py : y, b = py < y ? y : py;
                 if (a < 0) a = 0;
                 if (b > GH - 1) b = GH - 1;
                 if (a <= b && b - a > 0) gfx_rect(s, i, GY0 + a, 1, b - a + 1, col);
                 continue;
             }
         }
         if (y >= 0 && y < GH) gfx_rect(s, i, GY0 + y, 1, 1, col);
     }
 }
 
 static void graph_paint(Surface *s, Calc *c)
 {
     GraphState *g = &c->gr;
     header(s, c, "Gráfico");
     char b[96];
     if (g->phase < 2) {
         cf_text(s, &cf_bold, 8, 24, g->phase == 0 ? "f(x) =" : "g(x) =", g->phase == 0 ? FCOL : GCOL);
         cf_text(s, &cf_small, 8, 44, "Escribí la función con x. Enter grafica.", DIM);
         cf_text(s, &cf_small, 8, 58, g->phase == 0 ? "↓ agrega una segunda función g(x)." : "↑ vuelve a f(x). Esc la saca.", DIM);
         input_box(s, c, g->phase == 0 ? "f(x)=" : "g(x)=", 200);
         help(s, "Enter grafica   w ventana (en el gráfico)");
         return;
     }
     gfx_clip(s, 0, GY0, 320, GH);
     /* grilla */
     Dec stx = nice_step(dec_sub(g->xmax, g->xmin)), sty = nice_step(dec_sub(g->ymax, g->ymin));
     Dec x0 = dec_mul(dec_floor(dec_div(g->xmin, stx)), stx);
     for (int i = 0; i < 40; i++) {
         Dec x = dec_add(x0, dec_mul_int(stx, i));
         if (dec_cmp(x, g->xmax) > 0) break;
         int px = gx_of(x, g);
         if (px >= 0 && px < 320) gfx_rect(s, px, GY0, 1, GH, RGB(30, 36, 48));
     }
     Dec y0 = dec_mul(dec_floor(dec_div(g->ymin, sty)), sty);
     for (int i = 0; i < 40; i++) {
         Dec y = dec_add(y0, dec_mul_int(sty, i));
         if (dec_cmp(y, g->ymax) > 0) break;
         int py = gy_of(y, g);
         if (py >= 0 && py < GH) gfx_rect(s, 0, GY0 + py, 320, 1, RGB(30, 36, 48));
     }
     /* ejes */
     int ax = gx_of(DEC_ZERO, g), ay = gy_of(DEC_ZERO, g);
     if (ax >= 0 && ax < 320) gfx_rect(s, ax, GY0, 1, GH, DIM);
     if (ay >= 0 && ay < GH) gfx_rect(s, 0, GY0 + ay, 320, 1, DIM);
     if (g->use_g) curve(s, g->gy, GCOL);
     curve(s, g->fy, FCOL);
     /* trazo */
     gfx_rect(s, g->tx, GY0, 1, GH, RGB(70, 70, 40));
     const int16_t *ys = g->curve ? g->gy : g->fy;
     if (ys[g->tx] != INT16_MIN && ys[g->tx] >= 0 && ys[g->tx] < GH) gfx_disc(s, g->tx, GY0 + ys[g->tx], 3, CURS);
     gfx_noclip(s);
     /* datos abajo */
     gfx_rect(s, 0, GY0 + GH, 320, 306 - GY0 - GH, PANEL);
     Dec x = dec_add(g->xmin, dec_div_int(dec_mul_int(dec_sub(g->xmax, g->xmin), g->tx), 319));
     Num xn = num_dec(dec_round_sig(x, 10));
     int p = str_put(b, sizeof b, 0, "x=");
     p = fmt_plain(&xn, &c->fmt, true, b + p, 40) + p;
     p = str_put(b, sizeof b, p, g->curve ? "  g=" : "  f=");
     if (num_bad(&g->tval)) str_put(b, sizeof b, p, "-");
     else fmt_plain(&g->tval, &c->fmt, true, b + p, (int)sizeof b - p);
     cf_text(s, &cf_small, 4, GY0 + GH + 1, b, g->curve ? GCOL : FCOL);
     help(s, "← → traza  ↑↓ curva  + - zoom  w ventana  Esc edita");
 }
 
 /* ------------------------------------------------------------ estadistica */
 
 static void stat_paint(Surface *s, Calc *c)
 {
     StatState *t = &c->st;
     header(s, c, stat_type_name(t->type));
     char b[64];
     if (t->phase == 1) {
         int rows = 18;
         if (t->rtop > t->nres - rows) t->rtop = t->nres > rows ? t->nres - rows : 0;
         for (int i = t->rtop; i < t->nres && i < t->rtop + rows; i++) {
             int y = 20 + (i - t->rtop) * 16;
             cf_text(s, &cf_bold, 10, y, t->rlabel[i], ACC);
             val_text(c, &t->rval[i], t->rerr[i], b, sizeof b);
             cf_text(s, &cf_big, 310 - cf_text_w(&cf_big, b), y, b, RESC);
         }
         help(s, "↑↓ recorre   Esc vuelve a los datos");
         return;
     }
     int cols = t->type == ST_1VAR ? 1 : 2;
     cf_text(s, &cf_bold, 40, 18, "x", ACC);
     if (cols == 2) cf_text(s, &cf_bold, 190, 18, "y", ACC);
     gfx_rect(s, 4, 33, 312, 1, DIM);
     int rows = t->editing ? 12 : 15;
     if (t->row < t->top) t->top = t->row;
     if (t->row >= t->top + rows) t->top = t->row - rows + 1;
     for (int r = t->top; r <= t->n && r < t->top + rows; r++) {
         int y = 36 + (r - t->top) * 16;
         str_int(b, sizeof b, 0, r + 1);
         cf_text(s, &cf_small, 6, y + 2, b, DIM);
         for (int j = 0; j < cols; j++) {
             int x = 30 + j * 150;
             bool sel = r == t->row && j == t->col;
             if (sel) gfx_rect(s, x, y - 1, 146, 16, SEL);
             if (r < t->n) {
                 val_text(c, j ? &t->y[r] : &t->x[r], false, b, sizeof b);
                 cf_text(s, &cf_big, x + 140 - cf_text_w(&cf_big, b), y, b, FG);
             }
         }
     }
     if (t->editing) input_box(s, c, "=", 250);
     help(s, t->editing ? "Enter guarda   Esc cancela" : "Tipeá valores  Supr borra fila  Enter resultados");
 }
 
 /* ------------------------------------------------------------ matrices */
 
 static void matrix_paint(Surface *s, Calc *c)
 {
     MatState *t = &c->mt;
     const MVal *m = t->target < 4 ? &t->m[t->target] : &t->v[t->target - 4];
     char title[24], b[64];
     int p = str_put(title, sizeof title, 0, t->target < 4 ? "Mat" : "Vct");
     char l[2] = { (char)('A' + t->target % 4), 0 };
     str_put(title, sizeof title, p, l);
     header(s, c, title);
     cf_text(s, &cf_bold, 10, 20, title, ACC);
     int cw = 300 / m->c;
     if (cw > 90) cw = 90;
     for (int i = 0; i < m->r; i++)
         for (int j = 0; j < m->c; j++) {
             int k = i * m->c + j, x = 10 + j * cw, y = 44 + i * 26;
             bool sel = k == t->sel;
             gfx_box(s, x, y, cw - 4, 22, sel ? SEL : PANEL, sel ? ACC : RGB(50, 58, 76));
             val_text(c, mv_get(m, i, j), false, b, sizeof b);
             gfx_clip(s, x + 2, y, cw - 8, 22);
             cf_text(s, &cf_big, x + cw - 8 - cf_text_w(&cf_big, b), y + 5, b, FG);
             gfx_noclip(s);
         }
     if (t->editing) input_box(s, c, "=", 250);
     help(s, t->editing ? "Enter guarda   Esc cancela" : "Tipeá un valor   = otra   Enter/Esc a las cuentas");
 }
 
 /* ------------------------------------------------------------ despacho */
 
 void modes_prepare(Calc *c)
 {
     layout_expr(&c->in, &METRIC_PX, &L_in);
     if (c->mode == MODE_GRAPH && c->gr.phase == 2) {
         c->gr.w = 320;
         c->gr.h = GH;
         if (!c->gr.ready) { graph_compute(c); graph_trace(c); }
     }
 }
 
 void modes_paint(Surface *s, Calc *c)
 {
     switch (c->mode) {
     case MODE_EQN: eqn_paint(s, c); break;
     case MODE_TABLE: table_paint(s, c); break;
     case MODE_GRAPH: graph_paint(s, c); break;
     case MODE_STAT: stat_paint(s, c); break;
     case MODE_MATRIX: matrix_paint(s, c); break;
     }
 }