mujoco

// Copyright 2021 DeepMind Technologies Limited
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "ui/ui_main.h"

#include <math.h>
#include <stdio.h>
#include <string.h>

#include <mujoco/mjmacro.h>
#include <mujoco/mujoco.h>
#include "engine/engine_array_safety.h"
#include "render/glad/glad.h"

//------------------------------------ Default themes ----------------------------------------------

// theme spacing 0 : tight
static const mjuiThemeSpacing themeSpacing0 = {
  270,   // total
  15,    // scroll
  120,   // label
  8,     // section
  6,     // cornersect
  6,     // cornersep
  4,     // itemside
  4,     // itemmid
  4,     // itemver
  8,     // texthor
  4,     // textver
  30,    // linescroll
  4      // samples
};


// theme spacing 1 : wide
static const mjuiThemeSpacing themeSpacing1 = {
  310,   // total
  15,    // scroll
  120,   // label
  10,    // section
  10,    // cornersect
  10,    // cornersep
  7,     // itemside
  7,     // itemmid
  7,     // itemver
  10,    // texthor
  5,     // textver
  30,    // linescroll
  4      // samples
};


// theme color 0 : default
static const mjuiThemeColor themeColor0 = {
  {0.25, 0.25, 0.25},   // master
  {0.12, 0.12, 0.12},   // thumb
  {0.6,  0.2,  0.2},    // secttitle
  {0.1,  0.1,  0.1},    // secttitle2
  {0.45, 0.17, 0.17},   // secttitleuncheck
  {0.45, 0.17, 0.17},   // secttitleuncheck2
  {0.45, 0.17, 0.17},   // secttitlecheck
  {0.45, 0.17, 0.17},   // secttitlecheck2
  {1.0,  1.0,  1.0},    // sectfont
  {0.7,  0.7,  0.7},    // sectsymbol
  {0.1,  0.1,  0.1},    // sectpane
  {0.25, 0.25, 0.25},   // separator
  {0.1,  0.1,  0.1},    // separator2
  {0.0,  0.0,  1.0},    // shortcut
  {1.0,  1.0,  1.0},    // fontactive
  {0.5,  0.5,  0.5},    // fontinactive
  {0.3,  0.3,  0.3},    // decorinactive
  {0.4,  0.4,  0.4},    // decorinactive2
  {0.6,  0.4,  0.4},    // button
  {0.4,  0.4,  0.7},    // check
  {0.4,  0.6,  0.4},    // radio
  {0.4,  0.6,  0.6},    // select
  {0.2,  0.3,  0.3},    // select2
  {0.3,  0.2,  0.3},    // slider
  {0.6,  0.4,  0.6},    // slider2
  {0.6,  0.6,  0.4},    // edit
  {0.7,  0.0,  0.0},    // edit2
  {0.9,  0.9,  0.9}     // cursor
};


// theme color 1 : orange
static const mjuiThemeColor themeColor1 = {
  {0.2,  0.2,  0.2},    // master
  {0.12, 0.12, 0.12},   // thumb
  {0.3,  0.3,  0.3},    // secttitle
  {0.15, 0.15, 0.15},   // secttitle2
  {0.25, 0.25, 0.25},   // secttitleuncheck
  {0.25, 0.25, 0.25},   // secttitleuncheck2
  {0.25, 0.25, 0.25},   // secttitlecheck
  {0.25, 0.25, 0.25},   // secttitlecheck2
  {0.8,  0.8,  0.8},    // sectfont
  {0.7,  0.7,  0.7},    // sectsymbol
  {0.15, 0.15, 0.15},   // sectpane
  {0.2,  0.2,  0.2},    // separator
  {0.15, 0.15, 0.15},   // separator2
  {0.0,  0.0,  1.0},    // shortcut
  {0.9,  0.9,  0.9},    // fontactive
  {0.5,  0.5,  0.5},    // fontinactive
  {0.2,  0.2,  0.2},    // decorinactive
  {0.25, 0.25, 0.25},   // decorinactive2
  {0.6,  0.4,  0.2},    // button
  {0.6,  0.4,  0.2},    // check
  {0.6,  0.4,  0.2},    // radio
  {0.6,  0.4,  0.2},    // select
  {0.3,  0.2,  0.1},    // select2
  {0.2,  0.2,  0.2},    // slider
  {0.6,  0.4,  0.2},    // slider2
  {0.6,  0.4,  0.2},    // edit
  {0.7,  0.0,  0.0},    // edit2
  {0.9,  0.9,  0.9}     // cursor
};


// theme color 2 : white
static const mjuiThemeColor themeColor2 = {
  {0.9,  0.9,  0.9},    // master
  {0.7,  0.7,  0.7},    // thumb
  {0.8,  0.8,  0.8},    // secttitle
  {1.0,  1.0,  1.0},    // secttitle2
  {0.95, 0.95, 0.95},   // secttitleuncheck
  {0.95, 0.95, 0.95},   // secttitleuncheck2
  {0.95, 0.95, 0.95},   // secttitlecheck
  {0.95, 0.95, 0.95},   // secttitlecheck2
  {0.0,  0.0,  0.8},    // sectfont
  {0.0,  0.0,  0.8},    // sectsymbol
  {1.0,  1.0,  1.0},    // sectpane
  {0.9,  0.9,  0.9},    // separator
  {1.0,  1.0,  1.0},    // separator2
  {0.0,  1.0,  1.0},    // shortcut
  {0.0,  0.0,  0.0},    // fontactive
  {0.7,  0.7,  0.7},    // fontinactive
  {0.95, 0.95, 0.95},   // decorinactive
  {0.9,  0.9,  0.9},    // decorinactive2
  {0.8,  0.8,  0.8},    // button
  {0.8,  0.8,  0.8},    // check
  {0.8,  0.8,  0.8},    // radio
  {0.8,  0.8,  0.8},    // select
  {0.9,  0.9,  0.9},    // select2
  {0.95, 0.95, 0.95},   // slider
  {0.8,  0.8,  0.8},    // slider2
  {0.8,  0.8,  0.8},    // edit
  {1.0,  0.3,  0.3},    // edit2
  {0.2,  0.2,  0.2}     // cursor
};


// theme color 3 : black
static const mjuiThemeColor themeColor3 = {
  {0.15, 0.15, 0.15},   // master
  {0.3,  0.3,  0.3},    // thumb
  {0.25, 0.25, 0.25},   // secttitle
  {0.0,  0.0,  0.0},    // secttitle2
  {0.2,  0.2,  0.2},    // secttitleuncheck
  {0.2,  0.2,  0.2},    // secttitleuncheck2
  {0.2,  0.2,  0.2},    // secttitlecheck
  {0.2,  0.2,  0.2},    // secttitlecheck2
  {1.0,  0.3,  0.3},    // sectfont
  {1.0,  0.3,  0.3},    // sectsymbol
  {0.0,  0.0,  0.0},    // sectpane
  {0.15, 0.15, 0.15},   // separator
  {0.0,  0.0,  0.0},    // separator2
  {0.0,  0.0,  1.0},    // shortcut
  {1.0,  1.0,  1.0},    // fontactive
  {0.4,  0.4,  0.4},    // fontinactive
  {0.1,  0.1,  0.1},    // decorinactive
  {0.15, 0.15, 0.15},   // decorinactive2
  {0.3,  0.3,  0.3},    // button
  {0.3,  0.3,  0.3},    // check
  {0.3,  0.3,  0.3},    // radio
  {0.3,  0.3,  0.3},    // select
  {0.15, 0.15, 0.15},   // select2
  {0.15, 0.15, 0.15},   // slider
  {0.3,  0.3,  0.3},    // slider2
  {0.3,  0.3,  0.3},    // edit
  {0.8,  0.2,  0.2},    // edit2
  {0.8,  0.8,  0.8}     // cursor
};



//------------------------------------ Utility functions -------------------------------------------

// scale from abstract pixels to framebuffer units
static int SCL(int sz, const mjrContext* con) {
  return mjMAX(0, mju_round(sz * 0.01 * con->fontScale));
}



// init OpenGL
static void initOpenGL(const mjrRect* r, const mjrContext* con) {
  // set OpenGL options
  glDisable(GL_NORMALIZE);
  glDisable(GL_DEPTH_TEST);
  glDisable(GL_CULL_FACE);
  glDisable(GL_LIGHTING);
  glDisable(GL_COLOR_MATERIAL);
  glDisable(GL_BLEND);
  glShadeModel(GL_SMOOTH);
  glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

  // standard 2D projection, in framebuffer units
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  glOrtho(0, r->width, 0, r->height, -1, 1);
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();

  // set viewport
  glViewport(r->left, r->bottom, r->width, r->height);
}



// get text width up to specified limit (0: 0, -1: entire string)
static int textwidth(const char* text, const mjrContext* con, int limit) {
  int i = 0, width = 0;

  // zero limit
  if (limit == 0) {
    return 0;
  }

  // add character widths
  while (text[i] && (limit < 1 || i < limit)) {
    width += con->charWidth[(unsigned char)text[i++]];
  }

  return width;
}



// draw text, limit to maxwidth
static void drawtext(const char* txt, int x, int y, int maxwidth,
                     const float* rgb, const mjrContext* con) {
  // determine string length that fits in maxwidth
  int len = 0, width = 0;
  while (txt[len]) {
    width += con->charWidth[(unsigned char)txt[len]];
    if (width >= maxwidth) {
      break;
    } else {
      len++;
    }
  }

  // draw normal text
  glListBase(con->baseFontNormal);
  glColor3fv(rgb);
  glRasterPos3i(x, y, 0);
  glCallLists(len, GL_UNSIGNED_BYTE, txt);
}



// draw text centered in rectangle
static void drawtextrect(mjrRect rect, const char* txt,
                         const float* rgb, const mjrContext* con) {
  int dy = (rect.height - con->charHeight)/2;
  int dx = (rect.width - textwidth(txt, con, -1))/2;
  dx = mjMAX(0, dx);

  drawtext(txt, rect.left+dx, rect.bottom+dy, rect.width-dx, rgb, con);
}



// draw rectangle
static void drawrectangle(mjrRect rect, const float* rgb, const float* rgbback,
                          const mjrContext* con) {
  // outside
  glColor3fv(rgb);
  glBegin(GL_QUADS);
  glVertex2i(rect.left, rect.bottom);
  glVertex2i(rect.left+rect.width, rect.bottom);
  glVertex2i(rect.left+rect.width, rect.bottom+rect.height);
  glVertex2i(rect.left, rect.bottom+rect.height);
  glEnd();

  // inside
  if (rgbback) {
    int margin = SCL(2, con);
    glColor3fv(rgbback);
    glBegin(GL_QUADS);
    glVertex2i(rect.left+margin, rect.bottom+margin);
    glVertex2i(rect.left+rect.width-margin, rect.bottom+margin);
    glVertex2i(rect.left+rect.width-margin, rect.bottom+rect.height-margin);
    glVertex2i(rect.left+margin, rect.bottom+rect.height-margin);
    glEnd();
  }
}



// round corners of rectangle
static void roundcorner(mjrRect rect, int flg_skipbottom, int flg_separator,
                        const mjUI* ui, const mjrContext* con) {
  // get rounding from theme, exit if disabled
  int cornerspec = flg_separator ? ui->spacing.cornersep : ui->spacing.cornersect;
  if (cornerspec == 0) {
    return;
  }

  // quarter-circle divisions and radius
  int ndivide = 10;
  double radius = cornerspec * 0.01 * con->fontScale;

  // draw fans in the four corners, optionally skip bottom corners
  for (int ic = (flg_skipbottom ? 2 : 0); ic < 4; ++ic) {
    // set corner
    double corner[2];
    switch (ic) {
    case 0:   // bottom-left
      corner[0] = rect.left;
      corner[1] = rect.bottom;
      break;

    case 1:   // bottom-right
      corner[0] = rect.left + rect.width;
      corner[1] = rect.bottom;
      break;

    case 2:   // top-right
      corner[0] = rect.left + rect.width;
      corner[1] = rect.bottom + rect.height;
      break;

    default:  // top-left
      corner[0] = rect.left;
      corner[1] = rect.bottom + rect.height;
    }

    // orient fan to point inside
    double angle = ic * 0.5 * mjPI;

    // compute circle center: opposite to corner
    double center[2];
    center[0] = corner[0] + mju_sqrt(2.0) * radius * cos(angle + 0.25 * mjPI);
    center[1] = corner[1] + mju_sqrt(2.0) * radius * sin(angle + 0.25 * mjPI);

    // fill with erase color, start trinagle_fan from corner
    glColor3fv(flg_separator ? ui->color.sectpane : ui->color.master);
    glBegin(GL_TRIANGLE_FAN);
    glVertex2d(corner[0], corner[1]);

    // compute vertices of quarter-circle
    for (int i = 0; i <= ndivide; i++) {
      double a = angle + mjPI + 0.5 * mjPI * (double)i / (double)ndivide;
      glVertex2d(center[0] + radius * cos(a), center[1] + radius * sin(a));
    }
    glEnd();
  }
}



// draw oval
static void drawoval(mjrRect rect, const float* rgb, const float* rgbback,
                     const mjrContext* con) {
  const int ndivide = 15;

  // require horizontal
  if (rect.height > rect.width) {
    return;
  }

  // circle info
  double radius = 0.5*rect.height;
  double lcenter[2] = {rect.left + radius, rect.bottom + radius};
  double rcenter[2] = {rect.left + rect.width - radius, rect.bottom + radius};

  // filled
  glColor3fv(rgb);
  glBegin(GL_POLYGON);

  // draw left half-circle
  for (int i=0; i <= ndivide; i++) {
    double angle = mjPI * (0.5 + (double)i / (double)ndivide);
    glVertex2d(lcenter[0] + radius*cos(angle), lcenter[1] + radius*sin(angle));
  }

  // draw right half-circle
  for (int i=0; i <= ndivide; i++) {
    double angle = mjPI * (1.5 + (double)i / (double)ndivide);
    glVertex2d(rcenter[0] + radius*cos(angle), rcenter[1] + radius*sin(angle));
  }
  glEnd();

  // inside
  if (rgbback) {
    int margin = SCL(2, con);
    radius -= margin;

    glColor3fv(rgbback);
    glBegin(GL_POLYGON);

    // draw left half-circle
    for (int i=0; i <= ndivide; i++) {
      double angle = mjPI * (0.5 + (double)i / (double)ndivide);
      glVertex2d(lcenter[0] + radius*cos(angle), lcenter[1] + radius*sin(angle));
    }

    // draw right half-circle
    for (int i=0; i <= ndivide; i++) {
      double angle = mjPI * (1.5 + (double)i / (double)ndivide);
      glVertex2d(rcenter[0] + radius*cos(angle), rcenter[1] + radius*sin(angle));
    }
    glEnd();
  }
}



// draw open/closed symbol in title
//  type: 0- section, 1- section with unchecked box,
//        2- section with checked box, 3- separator
static void drawsymbol(mjrRect rect, int flg_open, int type,
                       const mjUI* ui, const mjrContext* con) {
  // size and center
  int texthor =  SCL(ui->spacing.texthor, con);
  int cx = rect.left + rect.width - texthor;
  int cy = rect.bottom + rect.height/2;
  int d = mju_round(con->charHeight*0.33);

  // separator size
  if (type == 3) {
    d = mju_round(con->charHeight*0.28);
  }

  // open
  if (flg_open) {
    glColor3fv(ui->color.sectsymbol);
    glBegin(GL_TRIANGLES);
    glVertex2i(cx, cy+d);
    glVertex2i(cx-2*d, cy+d);
    glVertex2i(cx-d, cy-d);
    glEnd();
  }

  // closed
  else {
    // solid outside
    glColor3fv(ui->color.sectsymbol);
    glBegin(GL_TRIANGLES);
    glVertex2i(cx, cy-d);
    glVertex2i(cx, cy+d);
    glVertex2i(cx-2*d, cy);
    glEnd();

    // set color for inside
    switch (type) {
    case 0:   // section
      glColor3f(
        (ui->color.secttitle[0] + ui->color.secttitle2[0]) * 0.5,
        (ui->color.secttitle[1] + ui->color.secttitle2[1]) * 0.5,
        (ui->color.secttitle[2] + ui->color.secttitle2[2]) * 0.5
      );
      break;

    case 1:   // section with unchecked box
      glColor3f(
        (ui->color.secttitleuncheck[0] + ui->color.secttitleuncheck2[0]) * 0.5,
        (ui->color.secttitleuncheck[1] + ui->color.secttitleuncheck2[1]) * 0.5,
        (ui->color.secttitleuncheck[2] + ui->color.secttitleuncheck2[2]) * 0.5
      );
      break;

    case 2:   // section with checked box
      glColor3f(
        (ui->color.secttitlecheck[0] + ui->color.secttitlecheck2[0]) * 0.5,
        (ui->color.secttitlecheck[1] + ui->color.secttitlecheck2[1]) * 0.5,
        (ui->color.secttitlecheck[2] + ui->color.secttitlecheck2[2]) * 0.5
      );
      break;

    case 3:   // separator
      glColor3f(
        (ui->color.separator[0] + ui->color.separator2[0]) * 0.5,
        (ui->color.separator[1] + ui->color.separator2[1]) * 0.5,
        (ui->color.separator[2] + ui->color.separator2[2]) * 0.5
      );
    }

    // draw inside
    double margin = con->fontScale * 0.015;
    double u = 0.5 * sqrt(5.0) * margin;
    double y = d - u - 0.5 * margin;
    glBegin(GL_TRIANGLES);
    glVertex2d(cx-margin, cy-y);
    glVertex2d(cx-margin, cy+y);
    glVertex2d(cx-2*d+2*u, cy);
    glEnd();
  }
}



// radio element rectangle
static mjrRect radioelement(const mjuiItem* it, int n,
                            const mjUI* ui, const mjrContext* con) {
  // scale sizes from theme
  int g_itemmid =  SCL(ui->spacing.itemmid, con);
  int g_textver =  SCL(ui->spacing.textver, con);
  int ncol = ui->radiocol ? ui->radiocol : 2;
  int nrow = (it->multi.nelem-1)/ncol + 1;

  // compute elements
  int cellwidth = (it->rect.width-(ncol-1)*g_itemmid)/ncol;
  int cellheight = con->charHeight+2*g_textver;
  int row = n/ncol;
  int col = n%ncol;

  // construct rectangle
  mjrRect r = {
    it->rect.left + col*(cellwidth+g_itemmid),
    it->rect.bottom+(nrow-1-row)*cellheight,
    cellwidth,
    cellheight
  };

  // adjust width of last column
  if (col == ncol-1) {
    r.width = it->rect.width - r.left + it->rect.left;
  }

  return r;
}



// compute mouse position relative to ui
static void mouseinui(const mjUI* ui, const mjuiState* ins, int* x, int* y) {
  // extract data
  *x = (int)ins->x;
  *y = (int)ins->y;
  mjrRect rect = ins->rect[ui->rectid];

  // correct for scrollbar
  if (ui->height > rect.height) {
    *y -= ui->scroll;
  }

  // correct for offset
  *x -= rect.left;
  *y -= (rect.height - ui->height) + rect.bottom;
}



// compute mouse position relative to rectangle
static void mouseinrect(mjrRect rect, const mjUI* ui, const mjuiState* ins,
                        double* rx, double* ry) {
  // mouse relative to ui
  int x, y;
  mouseinui(ui, ins, &x, &y);

  // mouse relative to rectangle
  *rx = (x-rect.left) / (double)rect.width;
  *ry = (y-rect.bottom) / (double)rect.height;
}



// find radio element under mouse
static int findradio(const mjuiItem* it, const mjUI* ui,
                     const mjuiState* ins, const mjrContext* con) {
  // number of rows and columns
  int ncol = ui->radiocol ? ui->radiocol : 2;
  int nrow = (it->multi.nelem-1)/ncol + 1;

  // get mouse relative to rect
  double rx, ry;
  mouseinrect(it->rect, ui, ins, &rx, &ry);

  // count rows from top
  ry = 1-ry;

  // round and clamp
  int row = (int)floor(ry*nrow);
  int col = (int)floor(rx*ncol);
  row = mjMAX(0, mjMIN(row, nrow-1));
  col = mjMAX(0, mjMIN(col, ncol-1));

  // result
  int ind = row*ncol + col;
  if (ind < it->multi.nelem) {
    return ind;
  } else {
    return -1;
  }
}



// make list of separators for radioline elements
static void makeradioline(const mjuiItem* it, const mjrContext* con, int* sep) {
  int nelem = it->multi.nelem, totwid = 0;
  int elwid[mjMAXUIMULTI];

  // no elements
  if (!nelem) {
    return;
  }

  // compute element widths
  for (int i=0; i < nelem; i++) {
    elwid[i] = textwidth(it->multi.name[i], con, -1);
    totwid += elwid[i];
  }

  // compute per-element extra space
  double extra = ((double)(it->rect.width - totwid)) / ((double)nelem);

  // compute separators
  sep[0] = 0;
  for (int i=0; i < nelem; i++) {
    sep[i+1] = sep[i] + elwid[i] + mju_round((i+1)*extra) -mju_round(i*extra);
  }
  sep[nelem] = it->rect.width;
}



// find radioline element under mouse
static int findradioline(const mjuiItem* it, const mjUI* ui,
                         const mjuiState* ins, const mjrContext* con) {
  // make separators
  int sep[mjMAXUIMULTI+1];
  makeradioline(it, con, sep);

  // get mouse relative to rect
  double rx, ry;
  mouseinrect(it->rect, ui, ins, &rx, &ry);

  // find interval
  int x = mju_round(rx*it->rect.width);
  for (int i=0; i < it->multi.nelem; i++) {
    if (x >= sep[i] && x < sep[i+1]) {
      return i;
    }
  }

  // not found
  return -1;
}



// find select element under mouse
static int findselect(const mjuiItem* it, const mjUI* ui,
                      const mjuiState* ins, const mjrContext* con) {
  // not tracking: nothing to do
  if (!(ui->mousesect > 0 && ui->mouseitem >= 0 && it && it->type == mjITEM_SELECT)) {
    return -1;
  }

  // make box
  int g_textver = SCL(ui->spacing.textver, con);
  int cellheight = con->charHeight + 2*g_textver;
  mjrRect r = it->rect;
  r.height = it->multi.nelem * cellheight;
  r.bottom -= r.height;

  // find in box
  double rx, ry;
  mouseinrect(r, ui, ins, &rx, &ry);
  if (ry > 0 && ry < 1 && rx > 0 && rx < 1) {
    int k = (int)floor(ry*it->multi.nelem);
    k = mjMAX(0, mjMIN(it->multi.nelem-1, k));
    return it->multi.nelem-1-k;
  } else {
    return -1;
  }
}



// make scrollbar rectangles
void scrollrect(mjrRect rect, const mjUI* ui, const mjrContext* con,
                mjrRect* bar, mjrRect* thumb) {
  int w_scroll = SCL(ui->spacing.scroll, con);

  // bar
  *bar = rect;
  bar->left = rect.left+rect.width-w_scroll;
  bar->width = w_scroll;

  // thumb
  double tstart = (double)ui->scroll / (double)ui->height;
  double tend = (double)(ui->scroll+rect.height) / (double)ui->height;
  *thumb = *bar;
  thumb->bottom = rect.bottom + mju_round(rect.height*(1-tend));
  thumb->height = mju_round(rect.height*(tend-tstart));
}



// is point in rectangle
static int inside(int x, int y, mjrRect r) {
  return (x >= r.left && x <= r.left+r.width && y >= r.bottom && y <= r.bottom+r.height);
}



// is point in oval
static int insideoval(int x, int y, mjrRect r) {
  // exclude if not in rectangle
  if (!inside(x, y, r)) {
    return 0;
  }

  // check center
  int radius = r.height/2;
  if (x >= r.left+radius && x <= r.left+r.width-radius) {
    return 1;
  }

  // left circle
  int dx = x - (r.left+radius);
  int dy = y - (r.bottom+radius);
  if (dx < 0 && (dx*dx + dy*dy < radius*radius)) {
    return 1;
  }

  // right circle
  dx = x - (r.left+r.width-radius);
  if (dx > 0 && (dx*dx + dy*dy < radius*radius)) {
    return 1;
  }

  return 0;
}



// find mouse location in UI; y already inverted
// sect: -1: thumb, -2: slider down, -3: slider up, positive: 1+section
// item: -1: section title or scroll, non-negative: item number
// item: -2: in checkbox on section title
static void findmouse(const mjUI* ui, const mjuiState* ins, const mjrContext* con,
                      int* sect, int* item) {
  // clear
  *sect = 0;
  *item = 0;

  // extract data
  int x = (int)ins->x;
  int y = (int)ins->y;
  mjrRect rect = ins->rect[ui->rectid];

  // scrollbar
  if (ui->height > rect.height) {
    // construct rectangles
    mjrRect bar;
    mjrRect thumb;
    scrollrect(rect, ui, con, &bar, &thumb);

    // inside bar
    if (inside(x, y, bar)) {
      // inside thumb
      if (inside(x, y, thumb)) {
        *sect = -1;
      }

      // below thumb
      else if (y < thumb.bottom) {
        *sect = -2;
      }

      // above thumb
      else {
        *sect = -3;
      }

      // done
      *item = -1;
      return;
    }
  }

  // adjust x,y
  mouseinui(ui, ins, &x, &y);

  // check sections and items
  for (int n=0; n < ui->nsect; n++) {
    // get section pointer
    const mjuiSection* s = ui->sect + n;

    // in title
    if (s->state < 2 && inside(x, y, s->rtitle)) {
      *sect = n+1;
      *item = -1;

      // in checkbox
      if (s->checkbox > 0) {
        mjrRect rcheck = s->rtitle;
        rcheck.width = mjMIN(rcheck.height, rcheck.width);
        if (inside(x, y, rcheck)) {
          *item = -2;
        }
      }

      return;
    }

    // in content and open: check items
    if (s->state && inside(x, y, s->rcontent)) {
      for (int i=0; i < s->nitem; i++) {
        if (s->item[i].type == mjITEM_BUTTON ?
            insideoval(x, y, s->item[i].rect) :
            inside(x, y, s->item[i].rect)) {
          *sect = n+1;
          *item = i;
          return;
        }
      }
    }
  }
}



// set slider position given mouse
static void setslider(mjuiItem* it, mjUI* ui,
                      const mjuiState* ins, const mjrContext* con) {
  // get mouse relative position
  double rx, ry;
  mouseinrect(it->rect, ui, ins, &rx, &ry);

  // clamp rx, enforce divisions
  rx = mjMAX(0, mjMIN(1, rx));
  rx = mju_round(rx * it->slider.divisions) / mjMAX(1, it->slider.divisions);
  rx = mjMAX(0, mjMIN(1, rx));

  // compute value
  mjtNum val = (mjtNum)(it->slider.range[0]*(1-rx) + it->slider.range[1]*rx);

  // set slider position
  if (it->type == mjITEM_SLIDERINT) {
    *(int*)it->pdata = mju_round(val);
  } else {
    *(mjtNum*)it->pdata = val;
  }
}



// check edit text before conversion to array
// return 0 if ok, error code otherwise
static int checkedit(const char* text, const mjuiItem* it) {
  // text always passes
  if (it->type == mjITEM_EDITTXT) {
    return 0;
  }

  // check type
  if (it->type != mjITEM_EDITINT &&
      it->type != mjITEM_EDITNUM &&
      it->type != mjITEM_EDITFLOAT) {
    mju_error("Internal error: expected edit control");
  }

  // convert
  double val[mjMAXUIEDIT];
  int n = sscanf(text, "%lf %lf %lf %lf %lf %lf %lf",
                 val, val+1, val+2, val+3, val+4, val+5, val+6);

  // check length
  if (n != it->edit.nelem) {
    return 1;
  }

  // check range when defined
  for (int i=0; i < n; i++)
    if (it->edit.range[i][0] < it->edit.range[i][1] &&
        (val[i] < it->edit.range[i][0] || val[i] > it->edit.range[i][1])) {
      return 2;
    }

  // require int values for int type
  if (it->type == mjITEM_EDITINT) {
    for (int i=0; i < n; i++) {
      if (val[i] != (double)((int)val[i])) {
        return 3;
      }
    }
  }

  return 0;
}



// convert edit text to numeric array
// return 0 if ok, error code otherwise
static int text2array(const char* text, const mjuiItem* it) {
  // text: copy
  if (it->type == mjITEM_EDITTXT) {
    // copy string, assume mjMAXUINAME allocation
    char* pdata = (char*)it->pdata;
    strncpy(pdata, text, mjMAXUINAME);
    pdata[mjMAXUINAME-1] = 0;
    return 0;
  }

  // check type
  if (it->type != mjITEM_EDITINT && it->type != mjITEM_EDITNUM && it->type != mjITEM_EDITFLOAT) {
    mju_error("Internal error: expected edit control");
  }

  // convert
  double val[mjMAXUIEDIT];
  int n = sscanf(text, "%lf %lf %lf %lf %lf %lf %lf",
                 val, val+1, val+2, val+3, val+4, val+5, val+6);

  // check length
  if (n != it->edit.nelem) {
    return 1;
  }

  // check range when defined
  for (int i=0; i < n; i++) {
    if (it->edit.range[i][0] < it->edit.range[i][1] &&
        (val[i] < it->edit.range[i][0] || val[i] > it->edit.range[i][1])) {
      return 2;
    }
  }

  // require int values for int type
  if (it->type == mjITEM_EDITINT) {
    for (int i=0; i < n; i++) {
      if (val[i] != (double)((int)val[i])) {
        return 3;
      }
    }
  }

  // copy values
  if (it->type == mjITEM_EDITINT) {
    int* pdata = (int*)it->pdata;
    for (int i=0; i < n; i++) {
      pdata[i] = (int)val[i];
    }
  } else {
    if (it->type == mjITEM_EDITNUM) {
      mjtNum* pdata = (mjtNum*)it->pdata;
      for (int i=0; i < n; i++) {
        pdata[i] = (mjtNum)val[i];
      }
    } else {
      float* pdata = (float*)it->pdata;
      for (int i=0; i < n; i++) {
        pdata[i] = (float)val[i];
      }
    }
  }

  return 0;
}



// convert numeric array to edit text
static void array2text(char* text, const mjuiItem* it) {
  // text: copy
  if (it->type == mjITEM_EDITTXT) {
    // copy string, assume mjMAXUINAME allocation
    strncpy(text, (const char*)it->pdata, mjMAXUINAME);
    text[mjMAXUINAME-1] = 0;
    return;
  }

  // check type
  if (it->type != mjITEM_EDITINT && it->type != mjITEM_EDITNUM && it->type != mjITEM_EDITFLOAT) {
    mju_error("Internal error: expected edit control");
  }

  // print
  int n = it->edit.nelem;
  char buf[50];
  text[0] = 0;
  for (int i=0; i < n; i++) {
    if (it->type == mjITEM_EDITINT) {
      mjSNPRINTF(buf, "%d", ((int*)it->pdata)[i]);
    } else if (it->type == mjITEM_EDITNUM) {
      mjSNPRINTF(buf, "%.4g", ((mjtNum*)it->pdata)[i]);
    } else {
      mjSNPRINTF(buf, "%.4g", ((float*)it->pdata)[i]);
    }
    strncat(text, buf, mjMAXUITEXT - strlen(text) - 1);
    if (i < n-1) {
      strncat(text, "  ", mjMAXUITEXT - strlen(text) - 1);
    }
  }
}


// return (remapped) key if valid, 0 if not valid
static int validkey(int key, int sz, int type, const mjuiState* state) {
  // text
  if (type == mjITEM_EDITTXT) {
    if (sz < mjMAXUINAME-1 && key >= 32 && key <= 127) {
      // lower case if Shift (Caps Lock cannot be detected in GLWF)
      if (key >= 'A' && key <= 'Z' && !state->shift) {
        key = key + 'a' - 'A';
      }

      // Shift: remap remaining keys
      else if (state->shift) {
        if (key == '`') {
          key = '~';
        } else if (key == '-') {
          key = '_';
        } else if (key == '=') {
          key = '+';
        } else if (key == '[') {
          key = '{';
        } else if (key == ']') {
          key = '}';
        } else if (key == '\\') {
          key = '|';
        } else if (key == ';') {
          key = ':';
        } else if (key == '\'') {
          key = '"';
        } else if (key == ',') {
          key = '<';
        } else if (key == '.') {
          key = '>';
        } else if (key == '/') {
          key = '?';
        }
      }

      return key;
    } else {
      return 0;
    }
  }

  // numeric
  else if (type == mjITEM_EDITINT || type == mjITEM_EDITNUM || type == mjITEM_EDITFLOAT) {
    if (sz < (mjMAXUITEXT-1) &&
        (key == ' ' || key == '+' || key == '=' || key == '-' || (key >= '0' && key <= '9') ||
         (key >= mjKEY_NUMPAD_0 && key <= mjKEY_NUMPAD_9) ||
         ((key == 'e' || key == 'E' || key == '.') &&
          (type == mjITEM_EDITNUM || type == mjITEM_EDITFLOAT)))) {

      // remap '=' to '+'
      if (key == '=') {
        key = '+';
      }

      // remap 'E' to 'e'
      if (key == 'E') {
        key = 'e';
      }

      // remap numberpad to top row
      if (key >= mjKEY_NUMPAD_0 && key <= mjKEY_NUMPAD_9) {
        key = key - mjKEY_NUMPAD_0 + '0';
      }

      return key;

    } else {
      return 0;
    }
  }

  // other
  else {
    return 0;
  }
}



// adjust editscroll so cursor is visible
static void revealcursor(mjrRect r, mjUI* ui, const mjrContext* con) {
  // scroll left
  if (ui->editcursor <= ui->editscroll) {
    ui->editscroll = ui->editcursor;
    return;
  }

  // width of available text area
  int width = r.width - 2*SCL(ui->spacing.texthor, con);

  // scan backwards
  int i = ui->editcursor;
  while (width >= 0 && i >= ui->editscroll && i > 0) {
    i--;
    width -= con->charWidth[(unsigned char)ui->edittext[i]];
  }

  // adjust scroll if out of width
  if (width < 0) {
    ui->editscroll = i+1;
  }
}



// use mouse position to set editcursor, adjust editscroll
static void setcursor(mjrRect r, mjUI* ui, const mjuiState* ins, const mjrContext* con) {
  // correct rectangle for texthor
  int g_texthor = SCL(ui->spacing.texthor, con);
  mjrRect r1 = r;
  r1.left += g_texthor;
  r1.width -= 2*g_texthor;

  // get mouse relative position
  double rx, ry;
  mouseinrect(r1, ui, ins, &rx, &ry);

  // outside rectangle
  if (rx < 0) {
    ui->editcursor = 0;
    ui->editscroll = 0;
  } else if (rx > 1) {
    ui->editcursor = strlen(ui->edittext);
    revealcursor(r, ui, con);
  }

  // inside rectangle
  else {
    int besti = ui->editscroll, cumsum = 0;
    int R = mju_round(r1.width*rx), bestdif = R;

    // find closest between-char position
    for (int i=ui->editscroll; i < strlen(ui->edittext); i++) {
      // add next width
      cumsum += con->charWidth[(unsigned char)ui->edittext[i]];

      // update best
      if (bestdif > abs(cumsum-R)) {
        bestdif = abs(cumsum-R);
        besti = i+1;
      }
    }

    // set
    ui->editcursor = besti;
  }
}



// parse modifier and shortcut
static void parseshortcut(const char* text, int* mod, int* key) {
  // clear
  *mod = 0;
  *key = 0;

  // empty: return
  if (!text[0]) {
    return;
  }

  // require between 2 and 5 characters
  if (strlen(text) < 2 || strlen(text) > 5) {
    mju_error("mjui_add: invalid shortcut specification");
  }

  // modifier
  switch (text[0]) {
  case ' ':
    *mod = 0;
    break;

  case 'C':
    *mod = 1;
    break;

  case 'S':
    *mod = 2;
    break;

  case 'A':
    *mod = 4;
    break;

  default:
    mju_error("mjui_add: invalid shortcut modifier");
  }

  // key
  if (text[1] == '#') {
    if (sscanf(text+2, "%d", key) != 1) {
      mju_error("mjui_add: invalid shortcut numeric code");
    }
  } else {
    if (text[2] != 0) {
      mju_error("mjui_add: invalid shortcut");
    }
    *key = (int)text[1];
  }
}



// check fpr matching modifier and shortcut
static int matchshortcut(const mjuiState* ins, int mod, int key) {
  // match key
  if (!key || ins->key != key) {
    return 0;
  }

  // match modifier
  if ((ins->control != 0) + 2*(ins->shift != 0) + 4*(ins->alt != 0) != mod) {
    return 0;
  }

  return 1;
}



//---------------------------------- Public API ----------------------------------------------------

// Get builtin UI theme spacing (0-1).
mjuiThemeSpacing mjui_themeSpacing(int ind) {
  if (ind == 0) {
    return themeSpacing0;
  } else {
    return themeSpacing1;
  }
}



// Get builtin UI theme color (0-3).
mjuiThemeColor mjui_themeColor(int ind) {
  if (ind == 0) {
    return themeColor0;
  } else if (ind == 1) {
    return themeColor1;
  } else if (ind == 2) {
    return themeColor2;
  } else {
    return themeColor3;
  }
}



// Add definitions to UI.
void mjui_add(mjUI* ui, const mjuiDef* def) {
  int n = 0, i, start, num;
  double x[1+2*mjMAXUIEDIT];

  // process entries until end marker
  while (def[n].type != mjITEM_END) {
    // section
    if (def[n].type == mjITEM_SECTION) {
      // check limit
      if (ui->nsect >= mjMAXUISECT) {
        mju_error("mjui_add: too many sections");
      }

      // check data
      if (strlen(def[n].name) >= mjMAXUINAME-1) {
        mju_error("mjui_add: section name too long");
      }
      if (def[n].state != mjSECT_CLOSED && def[n].state != mjSECT_OPEN &&
          def[n].state != mjSECT_FIXED && def[n].state != mjPRESERVE) {
        mju_error("mjui_add: invalid section state");
      }

      // add section, save state
      ui->nsect++;
      mjuiSection* se = ui->sect + (ui->nsect-1);
      int oldstate = se->state;

      // clear, but preserve item states
      int itemstate[mjMAXUIITEM];
      for (int i = 0; i < mjMAXUIITEM; ++i) {
        itemstate[i] = se->item[i].state;
      }
      memset(se, 0, sizeof(mjuiSection));
      for (int i = 0; i < mjMAXUIITEM; ++i) {
        se->item[i].state = itemstate[i];
      }

      // set or restore section state
      se->state = (def[n].state == mjPRESERVE ? oldstate : def[n].state);

      // copy remaining data
      mjSTRNCPY(se->name, def[n].name);
      se->checkbox = def[n].otherint;
      parseshortcut(def[n].other, &(se->modifier), &(se->shortcut));
    }

    // item
    else if (def[n].type >= 0 && def[n].type < mjNITEM) {
      // first section must be defined
      if (ui->nsect <= 0) {
        mju_error("mjui_add: item defined outside section");
      }
      mjuiSection* se = ui->sect + (ui->nsect-1);

      // check limit
      if (se->nitem >= mjMAXUIITEM) {
        mju_error("mjui_add: too many items in section");
      }

      // check item data
      if (def[n].type < 0 || def[n].type >= mjNITEM) {
        mju_error("mjui_add: invalid item type");
      }
      if (strlen(def[n].name) >= mjMAXUINAME) {
        mju_error("mjui_add: item name too long");
      }
      if (def[n].state < 0) {
        mju_error("mjui_add: invalid item state");
      }

      // add item, save state, clear
      se->nitem++;
      mjuiItem* it = se->item + (se->nitem-1);
      int oldstate = it->state;
      memset(it, 0, sizeof(mjuiItem));

      // set or restore state for collapsible separator, copy state for others
      if (def[n].type == mjITEM_SEPARATOR && def[n].state == mjPRESERVE) {
        // mjSEPCLOSED makes separator collapsible
        it->state = (oldstate < mjSEPCLOSED ? mjSEPCLOSED : oldstate);
      }
      else {
        it->state = def[n].state;
      }

      // copy common data
      it->type = def[n].type;
      it->pdata = def[n].pdata;
      mjSTRNCPY(it->name, def[n].name);
      it->sectionid = ui->nsect - 1;
      it->itemid = se->nitem - 1;
      it->userid = def[n].otherint;

      // data pointer check
      if (it->type > mjITEM_BUTTON && it->pdata == 0) {
        mju_error("mjui_add: no data pointer for item with data");
      }
      if (it->type <= mjITEM_BUTTON && it->pdata) {
        mju_error("mjui_add: data pointer for item without data");
      }

      // parse button and check
      if (it->type == mjITEM_BUTTON ||
          it->type == mjITEM_CHECKINT ||
          it->type == mjITEM_CHECKBYTE) {
        parseshortcut(def[n].other, &(it->single.modifier), &(it->single.shortcut));
      }

      // parse static, radio, radioline, select
      else if (it->type == mjITEM_STATIC    ||
               it->type == mjITEM_RADIO     ||
               it->type == mjITEM_RADIOLINE ||
               it->type == mjITEM_SELECT) {
        // init
        it->multi.nelem = 0;
        num = strlen(def[n].other);
        i = 0;

        // find names in '/n'-separated string
        while (i < num) {
          // check limit
          if (it->multi.nelem >= mjMAXUIMULTI) {
            mju_error("mjui_add: too many multi elements");
          }

          // find next '\n' or 0
          start = i;
          while (def[n].other[i] != '\n' && def[n].other[i] != 0) {
            i++;
          }

          // check string
          if (i == start || i-start >= mjMAXUINAME-1) {
            mju_error("mjui_add: invalid multi element name");
          }

          // add
          int ind = it->multi.nelem;
          (it->multi.nelem)++;
          strncpy(it->multi.name[ind], def[n].other+start, i-start);
          it->multi.name[ind][i-start] = 0;

          // advance
          i++;
        }
      }

      // parse slider
      else if (it->type == mjITEM_SLIDERINT || it->type == mjITEM_SLIDERNUM) {
        // read and check number
        num = sscanf(def[n].other, "%lf %lf %lf", x, x+1, x+2);
        if (num != 2 && num != 3) {
          mju_error("mjui_add: slider expects 'min max [div]'");
        }

        // assign range
        it->slider.range[0] = x[0];
        it->slider.range[1] = x[1];

        // assign divisions if provided, otherwise default
        if (num == 3) {
          it->slider.divisions = mjMAX(1, x[2]);
        } else {
          if (it->type == mjITEM_SLIDERINT) {
            it->slider.divisions = mjMAX(1, x[1]-x[0]);
          } else {
            it->slider.divisions = 200;
          }
        }
      }

      // parse edit numeric
      else if (it->type == mjITEM_EDITINT || it->type == mjITEM_EDITNUM || it->type == mjITEM_EDITFLOAT) {
        // check mjMAXUIEDIT
        if (mjMAXUIEDIT > 7) {
          mju_error("internal error: mjMAXUIEDIT bigger than 7");
        }

        // parse nitem and up to 5 ranges
        num = sscanf(def[n].other, "%lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf",
                     x, x+1, x+2, x+3, x+4, x+5, x+6, x+7, x+8, x+9, x+10, x+11, x+12, x+13, x+14);

        // check length, assign
        if (num < 1) {
          mju_error("mjui_add: edit length missing");
        }
        it->edit.nelem = mju_round((mjtNum)x[0]);
        if (it->edit.nelem < 1 || it->edit.nelem > mjMAXUIEDIT) {
          mju_error("mjui_add: invalid edit length");
        }
        if (it->edit.nelem*2 != (num-1) && num > 1) {
          mju_error("mjui_add: incorrent number of edit ranges");
        }

        // copy ranges
        if (num > 1) {
          for (int i=0; i < it->edit.nelem; i++) {
            it->edit.range[i][0] = x[1+2*i];
            it->edit.range[i][1] = x[2+2*i];
          }
        }
      }

      // edit text: nothing to parse
      else if (it->type == mjITEM_EDITTXT) {
        // clear nelem, for style
        it->edit.nelem = 0;
      }
    }

    // invalid item type
    else {
      mju_error("mjui_add: invalid item type");
    }

    // advance to next definition
    n++;
  }
}



// Add definitions to UI section.
void mjui_addToSection(mjUI* ui, int sect, const mjuiDef* def) {
  int nsect = ui->nsect;
  ui->nsect = sect + 1;
  mjui_add(ui, def);
  ui->nsect = nsect;
}



// set item skip flags within section, but not in pass 0
static void setitemskip(mjuiSection* s, int pass) {
  int skip = 0;

  // process section items
  for (int i = 0; i < s->nitem; ++i) {
    mjuiItem* it = s->item + i;

    // pass 0: nothing is skipped
    if (pass == 0) {
      it->skip = 0;
      continue;
    }

    // item is a separator: update skip state for subsequent items
    if (it->type == mjITEM_SEPARATOR) {
      skip = (it->state == mjSEPCLOSED);
    }

    // item is not a separator: set skip state
    else {
      it->skip = skip;
    }
  }
}



// Compute UI sizes: internal function, may be called twice per resize
static void tryresize(mjUI* ui, const mjrContext* con) {
  // scale theme sizes
  int w_master =   SCL(ui->spacing.total,    con);
  int w_scroll =   SCL(ui->spacing.scroll,   con);
  int g_section =  SCL(ui->spacing.section,  con);
  int g_itemside = SCL(ui->spacing.itemside, con);
  int g_itemmid =  SCL(ui->spacing.itemmid,  con);
  int g_itemver =  SCL(ui->spacing.itemver,  con);
  int g_textver =  SCL(ui->spacing.textver,  con);
  int g_label =    SCL(ui->spacing.label,    con);

  // text element height, with gap above and below
  int textheight = con->charHeight + 2*g_textver;

  // column width
  int colwidth = (w_master - w_scroll - 2*g_section - 2*g_itemside - g_itemmid)/2;

  // pass 0 includes skipped items, pass 1 does not
  int Height, MaxHeight;
  for (int pass = 0; pass < 2; ++pass) {
    // init UI heights
    int height = 0;
    int maxheight = 0;

    // process sections
    for (int n = 0; n < ui->nsect; n++) {
      // vertical padding before section
      height += g_section;
      maxheight += g_section;

      // get section pointer
      mjuiSection* s = ui->sect + n;

      // set item skip flags for section, depending on pass
      setitemskip(s, pass);

      // title rectangle
      s->rtitle.left = g_section;
      s->rtitle.width = w_master - w_scroll - 2 * g_section;
      if (s->state == mjSECT_FIXED) {  // fixed section: no title
        s->rtitle.bottom = height;
        s->rtitle.height = 0;
      }
      else {                             // regular section with title
        s->rtitle.bottom = height + textheight;
        s->rtitle.height = textheight;
      }

      // count title height
      height += s->rtitle.height;
      maxheight += s->rtitle.height;

      // init content rectangle
      s->rcontent.left = s->rtitle.left;
      s->rcontent.width = s->rtitle.width;
      s->rcontent.height = 0;
      s->rcontent.bottom = 0;

      // process items within section
      for (int i = 0; i < s->nitem; i++) {
        // get item pointer, clear rectangle
        mjuiItem* it = s->item + i;
        memset(&it->rect, 0, sizeof(mjrRect));

        // item is skipped: nothing to do
        if (it->skip) {
          continue;
        }

        // vertical padding before item
        s->rcontent.height += it->type == mjITEM_SEPARATOR ? g_section : g_itemver;

        // packed pair of items
        if (i < s->nitem - 1 && s->item[i + 1].type == it->type &&
          (it->type == mjITEM_BUTTON ||
            it->type == mjITEM_CHECKINT ||
            it->type == mjITEM_CHECKBYTE)) {
          // get next item pointer
          mjuiItem* it1 = s->item + (i + 1);

          // this item rectangle
          it->rect.left = s->rcontent.left + g_itemside;
          it->rect.width = colwidth;
          it->rect.height = textheight;

          // next item rectangle (set bottom here)
          it1->rect.left = s->rcontent.left + g_itemside + colwidth + g_itemmid;
          it1->rect.width = colwidth;
          it1->rect.height = textheight;
          it1->rect.bottom = height + s->rcontent.height + it->rect.height;

          // advance
          i++;
        }

        // single-line item
        else {
          // common left border (except for labeled controls at the end)
          it->rect.left = s->rcontent.left + g_itemside;

          // static
          if (it->type == mjITEM_STATIC) {
            it->rect.width = s->rcontent.width - 2 * g_itemside;
            it->rect.height = (con->charHeight + g_textver) * it->multi.nelem;
          }

          // single column
          else if (it->type == mjITEM_BUTTON ||
            it->type == mjITEM_CHECKINT ||
            it->type == mjITEM_CHECKBYTE) {
            it->rect.width = colwidth;
            it->rect.height = textheight;
          }

          // radio
          else if (it->type == mjITEM_RADIO) {
            int ncol = ui->radiocol ? ui->radiocol : 2;
            int nrow = (it->multi.nelem - 1) / ncol + 1;
            it->rect.width = s->rcontent.width - 2 * g_itemside;
            it->rect.height = textheight * nrow;
          }

          // separator, select, slider, edit, radioline
          else {
            it->rect.width = s->rcontent.width - 2 * g_itemside;
            it->rect.height = textheight;
          }

          // add room for label
          if (it->name[0] &&
            (it->type >= mjITEM_RADIO ||
              it->type >= mjITEM_RADIOLINE ||
              it->type == mjITEM_STATIC)) {
            it->rect.left = s->rcontent.left + g_itemside + g_label;
            it->rect.width = s->rcontent.width - (2 * g_itemside + g_label);
          }
        }

        // set bottom, count height
        it->rect.bottom = height + s->rcontent.height + it->rect.height;
        s->rcontent.height += it->rect.height;
      }

      // vertical padding after last item, compute bottom
      s->rcontent.height += g_itemver;
      s->rcontent.bottom = height + s->rcontent.height;

      // count content height
      if (s->state != mjSECT_CLOSED) {
        height += s->rcontent.height;
      }
      maxheight += s->rcontent.height;
    }

    // vertical padding after last section
    height += g_section;
    maxheight += g_section;

    // save data: maxheight from pass 0, height from pass 1
    if (pass == 0) {
      MaxHeight = maxheight;
    }
    else {
      Height = height;
    }
  }

  // invert bottom for all sections and items
  for (int n=0; n < ui->nsect; n++) {
    // section
    mjuiSection* s = ui->sect + n;
    s->rtitle.bottom = Height - s->rtitle.bottom;
    s->rcontent.bottom = Height - s->rcontent.bottom;

    // items
    for (int i=0; i < s->nitem; i++) {
      s->item[i].rect.bottom = Height - s->item[i].rect.bottom;
    }
  }

  // assign UI sizes
  ui->width = w_master;
  ui->height = Height;
  ui->maxheight = MaxHeight;
}



// insertion sort of groups of ints: increasing order of leading int
static void insertionsortgroup(int* list, int num, int stride) {
  // allocate buffer of 10 ints, cannot handle more
  if (stride > 10) {
    mju_error("insertionsortgroup cannot handle stride greater than 10");
  }
  int x[10];

  for (int i = 1; i < num; i++) {
    memcpy(x, list + i * stride, sizeof(int) * stride);

    int j = i - 1;
    while (j >= 0 && list[j * stride] > x[0]) {
      memcpy(list + (j + 1) * stride, list + j * stride, sizeof(int) * stride);
      j--;
    }

    memcpy(list + (j + 1) * stride, x, sizeof(int) * stride);
  }
}



// Compute UI sizes.
void mjui_resize(mjUI* ui, const mjrContext* con) {
  // get maximum buffer size allowed by OpenGL driver
  int maxBufferSize = 0;
  glGetIntegerv(GL_MAX_RENDERBUFFER_SIZE, &maxBufferSize);

  // USED FOR TESTING OF SMALL BUFFER SIZES
  // maxBufferSize = 3000;

  // resize with current section states, clamp maxheight
  tryresize(ui, con);
  ui->maxheight = mjMIN(ui->maxheight, maxBufferSize);

  // if height is too large, close some sections
  if (ui->height > ui->maxheight) {
    // init new height with section gaps
    int hnew = (ui->nsect + 1) * SCL(ui->spacing.section, con);

    // add titles of regular sections and contents of fixed sections
    for (int n = 0; n < ui->nsect; ++n) {
      if (ui->sect[n].state == mjSECT_FIXED) {
        hnew += ui->sect[n].rcontent.height;
      }
      else {
        hnew += ui->sect[n].rtitle.height;
      }
    }

    // if fixed height is too big, nothing we can do
    if (hnew > ui->maxheight) {
      mju_error("fixed section height already too big, closing sections cannot help");
    }

    // sort open sections by lastclick
    int nopen = 0;
    int sortbuf[2 * mjMAXUISECT] = { 0 };
    for (int n = 0; n < ui->nsect; ++n) {
      if (ui->sect[n].state == mjSECT_OPEN) {
        sortbuf[2 * nopen] = ui->sect[n].lastclick;
        sortbuf[2 * nopen + 1] = n;
        ++nopen;
      }
    }
    insertionsortgroup(sortbuf, nopen, 2);

    // nothing is open; SHOULD NOT OCCUR
    if (nopen == 0) {
      mju_error("internal error: expected some sections to be open");
    }

    // keep most recent sections: as many as can fit in maxheight
    for (int i = nopen - 1; i >= 0; --i) {
      // section fits: add height
      if (hnew + ui->sect[sortbuf[2 * i + 1]].rcontent.height <= ui->maxheight) {
        hnew += ui->sect[sortbuf[2 * i + 1]].rcontent.height;
      }

      // section does not fit: mark for closing
      else {
        sortbuf[2 * i] = -1;
      }
    }

    // close sections that were marked
    for (int i = 0; i < nopen; ++i) {
      if (sortbuf[2 * i] == -1) {
        ui->sect[sortbuf[2 * i + 1]].state = mjSECT_CLOSED;
      }
    }

    // resize with new section states, clamp maxheight again
    tryresize(ui, con);
    ui->maxheight = mjMIN(ui->maxheight, maxBufferSize);

    // make sure tryresize did what we expected; SHOULD NOT OCCUR
    if (ui->height != hnew) {
      mju_error("internal error: tryresize produced unexpeced ui height");
    }
  }
}



// predicate handler
static int evalpredicate(int state, mjfItemEnable predicate, void* userdata) {
  if (state <= 0) {
    return 0;
  } else if (state == 1 || predicate == NULL) {
    return 1;
  } else {
    return predicate(state, userdata);
  }
}



// draw shortcut text
static void shortcuthelp(mjrRect r, int modifier, int shortcut,
                         const mjUI* ui, const mjrContext* con) {
  // map of key codes and corresponding names
#define NMAP 27
  const struct {
    int key;
    const char* value;
  } keymap[NMAP] = {
    {32              , "Space"},
    {mjKEY_ESCAPE    , "Esc"},
    {mjKEY_ENTER     , "Enter"},
    {mjKEY_TAB       , "Tab"},
    {mjKEY_BACKSPACE , "BackSpace"},
    {mjKEY_INSERT    , "Ins"},
    {mjKEY_DELETE    , "Del"},
    {mjKEY_RIGHT     , "Right"},
    {mjKEY_LEFT      , "Left"},
    {mjKEY_DOWN      , "Down"},
    {mjKEY_UP        , "Up"},
    {mjKEY_PAGE_UP   , "PgUp"},
    {mjKEY_PAGE_DOWN , "PgDn"},
    {mjKEY_HOME      , "Home"},
    {mjKEY_END       , "End"},
    {mjKEY_F1        , "F1"},
    {mjKEY_F2        , "F2"},
    {mjKEY_F3        , "F3"},
    {mjKEY_F4        , "F4"},
    {mjKEY_F5        , "F5"},
    {mjKEY_F6        , "F6"},
    {mjKEY_F7        , "F7"},
    {mjKEY_F8        , "F8"},
    {mjKEY_F9        , "F9"},
    {mjKEY_F10       , "F10"},
    {mjKEY_F11       , "F11"},
    {mjKEY_F12       , "F12"}
  };

  // key: ascii or decode map
  char key[10] = "";
  if (shortcut > 32 && shortcut <= 126) {
    key[0] = (char)shortcut;
    key[1] = 0;
  } else {
    for (int i=0; i < NMAP; i++) {
      if (keymap[i].key == shortcut) {
        mjSTRNCPY(key, keymap[i].value);
        break;
      }
    }
  }

  // modifier
  char text[50] = "";
  if (modifier == 1) {
    mjSTRNCPY(text, "Ctrl ");
  } else if (modifier == 2) {
    mjSTRNCPY(text, "Shift ");
  } else if (modifier == 4) {
    mjSTRNCPY(text, "Alt ");
  }

  // combine
  strcat(text, key);

  // make rectangle for shortcut
  int g_textver = SCL(ui->spacing.textver, con);
  int width = textwidth(text, con, -1) + 2*g_textver;
  r.left += (r.width-width);
  r.width = width;
  r.bottom += g_textver;
  r.height -= 2*g_textver;

  // render
  drawrectangle(r, ui->color.shortcut, NULL, con);
  drawtext(text, r.left+g_textver, r.bottom,
           r.width, ui->color.fontactive, con);
}



// Update specific section/item; -1: update all.
void mjui_update(int section, int item, const mjUI* ui,
                 const mjuiState* state, const mjrContext* con) {
  int g_texthor =  SCL(ui->spacing.texthor,  con);
  int g_textver =  SCL(ui->spacing.textver,  con);
  int g_label =    SCL(ui->spacing.label,    con);
  int g_itemside = SCL(ui->spacing.itemside, con);
  int g_itemmid =  SCL(ui->spacing.itemmid,  con);
  int cellheight = con->charHeight + 2*g_textver;
  const float* rgbpane = ui->color.sectpane;

  // locate mouse in ui
  int msect, mitem;
  findmouse(ui, state, con, &msect, &mitem);

  // start rendering
  mjr_setAux(ui->auxid, con);
  mjrRect rgl = { 0, 0, ui->width, ui->height };
  initOpenGL(&rgl, con);

  // all sections: clear background
  if (section < 0) {
    glClearColor(ui->color.master[0], ui->color.master[1],
                 ui->color.master[2], 1);
    glClear(GL_COLOR_BUFFER_BIT);
  }

  // select sections
  int start_section = 0;
  int num_section = ui->nsect;
  if (section >= 0) {
    start_section = section;
    num_section = 1;
  }

  // draw section(s)
  mjtNum sel;
  mjrRect r;
  char text[mjMAXUITEXT];
  int sep[mjMAXUIMULTI+1];
  for (int n=start_section; n < start_section+num_section; n++) {
    // get section pointer
    const mjuiSection* s = ui->sect + n;

    // standard maxwidth for text
    int maxwidth = (s->rtitle.width - 2*g_itemside - g_itemmid)/2 - 2*g_texthor;

    // redraw section title and pane
    if (section < 0 || item < 0) {
      r = s->rtitle;

      // title shown
      if (s->state != mjSECT_FIXED) {
        // section without checkbox
        if (s->checkbox == 0) {
          // interpolated rectangle
          glBegin(GL_QUADS);
          glColor3fv(ui->color.secttitle2);
          glVertex2i(r.left, r.bottom);
          glVertex2i(r.left + r.width, r.bottom);
          glColor3fv(ui->color.secttitle);
          glVertex2i(r.left + r.width, r.bottom + r.height);
          glVertex2i(r.left, r.bottom + r.height);
          glEnd();

          // symbol and text
          drawsymbol(r, s->state, 0, ui, con);
          drawtext(s->name, r.left + g_texthor,
            r.bottom + g_textver, 2 * maxwidth,
            ui->color.sectfont, con);
        }

        // section with checkbox
        else {
          // select colors depending on check state
          const float* rgb = (s->checkbox == 1 ? ui->color.secttitleuncheck
                                               : ui->color.secttitlecheck);
          const float* rgb2 = (s->checkbox == 1 ? ui->color.secttitleuncheck2
                                                : ui->color.secttitlecheck2);

          // draw rectangle with gradient
          glBegin(GL_QUADS);
          glColor3fv(rgb2);
          glVertex2i(r.left, r.bottom);
          glVertex2i(r.left + r.width, r.bottom);
          glColor3fv(rgb);
          glVertex2i(r.left + r.width, r.bottom + r.height);
          glVertex2i(r.left, r.bottom + r.height);
          glEnd();

          // symbol and text with offset
          drawsymbol(r, s->state, s->checkbox, ui, con);
          drawtext(s->name, r.left + r.height,
            r.bottom + g_textver, 2 * maxwidth - r.height,
            ui->color.sectfont, con);

          // draw checkmark as specified
          int cgap = r.height / 4;
          mjrRect cr = {r.left + cgap,
                        r.bottom + cgap,
                        r.height - 2 * cgap,
                        r.height - 2 * cgap};
          float rgbmean[3] = {
            0.5f * (rgb[0] + rgb2[0]),
            0.5f * (rgb[1] + rgb2[1]),
            0.5f * (rgb[2] + rgb2[2]),
          };
          drawrectangle(cr, ui->color.sectsymbol,
            s->checkbox == 1 ? rgbmean : NULL, con);
        }

        // shortcut
        if (ui->mousehelp && s->shortcut) {
          shortcuthelp(r, s->modifier, s->shortcut, ui, con);
        }
      }

      // content pane, active only
      if (s->state != mjSECT_CLOSED) {
        drawrectangle(s->rcontent, ui->color.sectpane, NULL, con);
      }

      // round corners
      mjrRect rround = s->rtitle;
      if (s->state == mjSECT_FIXED) {
        rround = s->rcontent;
      }
      else if (s->state == mjSECT_OPEN) {
        rround.bottom = s->rcontent.bottom;
        rround.height = s->rtitle.height + s->rcontent.height;
      }
      roundcorner(rround, 0, 0, ui, con);
    }

    // closed: skip items
    if (!s->state) {
      continue;
    }

    // select items
    int start_item = 0;
    int num_item = s->nitem;
    if (section >= 0 && item >= 0) {
      start_item = item;
      num_item = 1;
    }

    // draw item(s)
    for (int i=start_item; i < start_item+num_item; i++) {
      // get item pointer
      const mjuiItem* it = s->item + i;

      // zero size: skip
      if (it->rect.height == 0) {
        continue;
      }

      // set rgb pointers to inactive state
      const float* rgbfont = ui->color.fontinactive;
      const float* rgbdecor = ui->color.decorinactive;
      const float* rgbdecor2 = ui->color.decorinactive2;

      // get actual state, adjust font rgb
      int state = evalpredicate(it->state, ui->predicate, ui->userdata);
      if (state) {
        rgbfont = ui->color.fontactive;
      }

      // type-specific draw
      switch (it->type) {
      case mjITEM_SEPARATOR:
        // background
        r = it->rect;
        glBegin(GL_QUADS);
        glColor3fv(ui->color.separator2);
        glVertex2i(r.left, r.bottom);
        glVertex2i(r.left+r.width, r.bottom);
        glColor3fv(ui->color.separator);
        glVertex2i(r.left+r.width, r.bottom+r.height);
        glVertex2i(r.left, r.bottom+r.height);
        glEnd();

        // name
        drawtext(it->name,
                 it->rect.left+g_texthor,
                 it->rect.bottom+g_textver,
                 it->rect.width-2*g_texthor, ui->color.sectfont, con);

        // symbol and round corners for collapsible
        if (it->state >= mjSEPCLOSED) {
          int flg_open = (it->state == mjSEPCLOSED + 1);
          drawsymbol(it->rect, flg_open, 3, ui, con);
          roundcorner(it->rect, flg_open, 1, ui, con);
        }
        break;

      case mjITEM_STATIC:
        r = it->rect;

        // name: at top
        drawtext(it->name,
                 s->rcontent.left+g_itemside+g_texthor,
                 r.bottom+g_textver+(it->multi.nelem-1)*(con->charHeight+g_textver),
                 g_label-2*g_texthor, rgbfont, con);

        // background
        drawrectangle(r, rgbpane, rgbpane, con);

        // text lines
        for (int k=0; k < it->multi.nelem; k++) {
          drawtext(it->multi.name[k],
                   r.left+g_texthor,
                   r.bottom+g_textver+(it->multi.nelem-k-1)*(con->charHeight+g_textver),
                   r.width-2*g_texthor, rgbfont, con);
        }
        break;

      case mjITEM_BUTTON:
        if (state) {
          rgbdecor = ui->color.button;
        }

        // outline or filled, depending on mouse
        if (ui->mousesect == n+1 && ui->mouseitem == i && msect == n+1 && mitem == i) {
          drawoval(it->rect, rgbdecor, NULL, con);
        } else {
          drawoval(it->rect, rgbdecor, rgbpane, con);
        }

        // name
        drawtext(it->name,
                 it->rect.left+g_texthor,
                 it->rect.bottom+g_textver,
                 maxwidth, rgbfont, con);

        // shortcut
        if (ui->mousehelp && it->single.shortcut) {
          shortcuthelp(it->rect, it->single.modifier, it->single.shortcut, ui, con);
        }
        break;

      case mjITEM_CHECKINT:
      case mjITEM_CHECKBYTE:
        {
          if (state) {
            rgbdecor = ui->color.check;
          }

          // get value according to type
          int k;
          if (it->type == mjITEM_CHECKINT) {
            k = *(int*)it->pdata;
          } else {
            k = *(mjtByte*)it->pdata;
          }

          // filled or outline
          if (k) {
            drawrectangle(it->rect, rgbdecor, NULL, con);
          } else {
            drawrectangle(it->rect, rgbdecor, rgbpane, con);
          }

          // name
          drawtext(it->name,
                  it->rect.left+g_texthor,
                  it->rect.bottom+g_textver,
                  maxwidth, rgbfont, con);

          // shortcut
          if (ui->mousehelp && it->single.shortcut)
            shortcuthelp(it->rect, it->single.modifier, it->single.shortcut,
                        ui, con);
        }
        break;

      case mjITEM_RADIO:
        if (state) {
          rgbdecor = ui->color.radio;
        }

        // name: at top
        drawtext(it->name,
                 s->rcontent.left+g_itemside+g_texthor,
                 it->rect.bottom+it->rect.height-cellheight+g_textver,
                 g_label-2*g_texthor, rgbfont, con);

        // outline
        drawrectangle(it->rect, rgbdecor, rgbpane, con);

        // fill selection
        r = radioelement(it, *(int*)it->pdata, ui, con);
        drawrectangle(r, rgbdecor, NULL, con);

        // element names
        for (int k=0; k < it->multi.nelem; k++) {
          r = radioelement(it, k, ui, con);
          drawtext(it->multi.name[k],
                   r.left+g_texthor,
                   r.bottom+g_textver,
                   r.width-2*g_texthor, rgbfont, con);
        }
        break;

      case mjITEM_RADIOLINE:
        {
          if (state) {
            rgbdecor = ui->color.radio;
          }

          // name
          drawtext(it->name,
                  s->rcontent.left+g_itemside+g_texthor,
                  it->rect.bottom+g_textver,
                  g_label-2*g_texthor, rgbfont, con);

          // outline
          drawrectangle(it->rect, rgbdecor, rgbpane, con);

          // make separators
          makeradioline(it, con, sep);

          // fill selected
          int k = *(int*)it->pdata;
          r = it->rect;
          r.left += sep[k];
          r.width = sep[k+1] - sep[k];
          drawrectangle(r, rgbdecor, NULL, con);

          // element names
          for (int k=0; k < it->multi.nelem; k++) {
            // compute rectangle for element
            r = it->rect;
            r.left += sep[k];
            r.width = sep[k+1] - sep[k];

            // draw centered
            drawtextrect(r, it->multi.name[k], rgbfont, con);
          }
        }
        break;

      case mjITEM_SELECT:
        if (state) {
          rgbdecor = ui->color.select;
        }

        // name
        drawtext(it->name,
                 s->rcontent.left+g_itemside+g_texthor,
                 it->rect.bottom+g_textver,
                 g_label-2*g_texthor, rgbfont, con);

        // box
        drawrectangle(it->rect, rgbdecor, NULL, con);

        // value: only if non-empty
        if (it->multi.nelem > 0) {
          drawtext(it->multi.name[*(int*)it->pdata],
                   it->rect.left+g_texthor,
                   it->rect.bottom+g_textver,
                   it->rect.width-2*g_texthor, rgbfont, con);
        }

        // draw tracking in mjui_render()
        break;

      case mjITEM_SLIDERINT:
      case mjITEM_SLIDERNUM:
        if (state) {
          rgbdecor = ui->color.slider;
          rgbdecor2 = ui->color.slider2;
        }

        // compute relative slider position
        if (it->type == mjITEM_SLIDERINT) {
          sel = (mjtNum)(*(int*)it->pdata);
        } else {
          sel = *(mjtNum*)it->pdata;
        }
        sel = (sel - it->slider.range[0]) /
              mjMAX(1e-10, (it->slider.range[1] - it->slider.range[0]));
        sel = mjMIN(1, mjMAX(0, sel));

        // fill slider with two colors
        r = it->rect;
        drawrectangle(r, rgbdecor, NULL, con);
        r.width = mju_round(r.width*sel);
        drawrectangle(r, rgbdecor2, NULL, con);

        // show divisions if not too many
        if (it->slider.divisions <= 20) {
          // repare rectangle
          r.width = SCL(2, con);
          r.height = g_textver;

          // draw ticks
          for (int k=1; k < (int)it->slider.divisions; k++) {
            r.left = it->rect.left - r.width/2 +
                     it->rect.width*k/it->slider.divisions;
            drawrectangle(r, rgbpane, NULL, con);
          }
        }

        // name
        drawtext(it->name,
                 s->rcontent.left+g_itemside+g_texthor,
                 it->rect.bottom+g_textver,
                 g_label-2*g_texthor, rgbfont, con);

        // value
        if (it->type == mjITEM_SLIDERINT) {
          mjSNPRINTF(text, "%d", *(int*)it->pdata);
        } else {
          mjSNPRINTF(text, "%.3g", *(mjtNum*)it->pdata);
        }
        drawtext(text,
                 it->rect.left+g_texthor,
                 it->rect.bottom+g_textver,
                 it->rect.width-2*g_texthor, rgbfont, con);
        break;

      case mjITEM_EDITINT:
      case mjITEM_EDITNUM:
      case mjITEM_EDITFLOAT:
      case mjITEM_EDITTXT:
        if (state) {
          rgbdecor = ui->color.edit;
        }

        // name
        drawtext(it->name,
                 s->rcontent.left+g_itemside+g_texthor,
                 it->rect.bottom+g_textver,
                 g_label-2*g_texthor, rgbfont, con);

        // activated
        if (ui->editsect > 0 && ui->editsect == n+1 && ui->edititem == i) {
          // fill box, indicate valid state with color
          if (checkedit(ui->edittext, it) == 0) {
            drawrectangle(it->rect, rgbdecor, NULL, con);
          } else {
            drawrectangle(it->rect, ui->color.edit2, NULL, con);
          }

          // show cursor
          int k = textwidth(ui->edittext + ui->editscroll, con,
                            ui->editcursor - ui->editscroll);
          r.left = it->rect.left + g_texthor + k - SCL(1, con);
          r.width = 2*SCL(1, con);
          r.bottom = it->rect.bottom + g_textver/2;
          r.height = it->rect.height - 2*(g_textver/2);
          drawrectangle(r, ui->color.cursor, NULL, con);

          // value from edittext, with scroll
          drawtext(ui->edittext + ui->editscroll,
                   it->rect.left+g_texthor,
                   it->rect.bottom+g_textver,
                   it->rect.width-2*g_texthor, rgbfont, con);
        }

        // not activated
        else {
          // outline box
          drawrectangle(it->rect, rgbdecor, rgbpane, con);

          // value from pdata, no scroll
          array2text(text, it);
          drawtext(text,
                   it->rect.left+g_texthor,
                   it->rect.bottom+g_textver,
                   it->rect.width-2*g_texthor, rgbfont, con);
        }
        break;

      default:
        mju_error("mjui_update: internal error: unexpected item type");
      }
    }
  }

  // stop rendering
  mjr_restoreBuffer(con);
}



// Handle UI event, return pointer to changed item, NULL if no change.
mjuiItem* mjui_event(mjUI* ui, mjuiState* state, const mjrContext* con) {
  int i, key, change = 0;
  mjuiItem* it;
  ui->editchanged = NULL;

  // count mouse clicks over UI
  if (state->type == mjEVENT_PRESS) {
    ++ui->mouseclicks;
  }

  // non-left mouse events: handle shortcut help
  if ((state->type == mjEVENT_PRESS || state->type == mjEVENT_MOVE ||
       state->type == mjEVENT_RELEASE) && state->button != mjBUTTON_LEFT) {
    if (state->button == mjBUTTON_RIGHT) {
      if (state->type == mjEVENT_PRESS) {
        ui->mousehelp = 1;
        mjui_update(-1, -1, ui, state, con);
      } else if (state->type == mjEVENT_RELEASE) {
        ui->mousehelp = 0;
        mjui_update(-1, -1, ui, state, con);
      }
    }

    return NULL;
  }

  // get current mouse section and item
  int sect_cur = -1;
  int item_cur = -1;
  mjuiItem* it_cur = NULL;
  findmouse(ui, state, con, &sect_cur, &item_cur);
  if (sect_cur > 0 && item_cur >= 0) {
    it_cur = ui->sect[sect_cur-1].item + item_cur;
  }

  // update section lastclick
  if (sect_cur > 0 && state->type == mjEVENT_PRESS) {
    ui->sect[sect_cur - 1].lastclick = ui->mouseclicks;
  }

  // get recorded mouse section and item
  int sect_rec = ui->mousesect;
  int item_rec = -1;
  mjuiItem* it_rec = NULL;
  if (sect_rec > 0) {
    item_rec = ui->mouseitem;
    it_rec = ui->sect[sect_rec-1].item + item_rec;
  }

  // get edit section and item
  int sect_edit = ui->editsect;
  int item_edit = -1;
  mjuiItem* it_edit = NULL;
  if (sect_edit > 0) {
    item_edit = ui->edititem;
    it_edit = ui->sect[sect_edit-1].item + item_edit;
  }

  // process according to type
  switch (state->type) {
  case mjEVENT_MOVE:
    // move scrollbar
    if (sect_rec == -1) {
      ui->scroll -= mju_round((state->dy * ui->height) /
                              state->rect[ui->rectid].height);
      ui->scroll = mjMAX(0, mjMIN(ui->scroll,
                                  ui->height-state->rect[ui->rectid].height));
    }

    // item
    else if (it_rec) {
      // move slider
      if (it_rec->type == mjITEM_SLIDERINT || it_rec->type == mjITEM_SLIDERNUM) {
        setslider(it_rec, ui, state, con);

        // redraw, return change
        mjui_update(sect_rec-1, item_rec, ui, state, con);
        return it_rec;
      }

      // move edit
      else if (it_rec->type == mjITEM_EDITINT ||
               it_rec->type == mjITEM_EDITNUM ||
               it_rec->type == mjITEM_EDITFLOAT ||
               it_rec->type == mjITEM_EDITTXT) {
        setcursor(it_rec->rect, ui, state, con);
      }

      // redraw (any item type)
      mjui_update(sect_rec-1, item_rec, ui, state, con);
    }
    return NULL;

  case mjEVENT_PRESS:
    // edit in progress
    if (sect_edit > 0) {
      // same: adjust cursor position
      if (sect_edit == sect_cur && item_edit == item_cur) {
        // start mouse tracking
        ui->mousesect = sect_cur;
        ui->mouseitem = item_cur;

        // adjust cursor and scroll
        setcursor(it_edit->rect, ui, state, con);

        // redraw, return no change
        mjui_update(sect_edit-1, item_edit, ui, state, con);
        return NULL;
      }

      // different: instantiate, record editchange
      if (text2array(ui->edittext, it_edit) == 0) {
        ui->editchanged = it_edit;
      }

      // stop editing, even if invalid
      ui->editsect = 0;

      // redraw
      mjui_update(sect_edit-1, item_edit, ui, state, con);
    }

    // free mouse focus, just in case
    ui->mousesect = 0;

    // start scrollbar drag
    if (sect_cur == -1) {
      ui->mousesect = -1;
      ui->mouseitem = 0;
    }

    // scroll down
    else if (sect_cur == -2) {
      ui->scroll = ui->height - state->rect[ui->rectid].height;
    }

    // scroll up
    else if (sect_cur == -3) {
      ui->scroll = 0;
    }

    // section title
    else if (sect_cur > 0 && item_cur < 0) {
      mjuiSection* se = ui->sect + sect_cur - 1;

      // handle section checkbox
      if (item_cur == -2 && se->checkbox > 0) {
        ui->mousesectcheck = sect_cur;
        return NULL; // leave it to user, because sections may interact
      }
      else {
        ui->mousesectcheck = 0;
      }

      // double-click: make all sections like this (exclude fixed)
      if (state->doubleclick) {
        for (int i=0; i < ui->nsect; i++) {
          if (ui->sect[i].state != mjSECT_FIXED && se->state != mjSECT_FIXED) {
            ui->sect[i].state = se->state;
          }
        }
      }

      // single click: toggle section state (exclude fixed)
      else {
        if (se->state == mjSECT_OPEN) {
          se->state = mjSECT_CLOSED;
        }
        else if (se->state == mjSECT_CLOSED) {
          se->state = mjSECT_OPEN;
        }
      }

      // resize and redraw all
      mjui_resize(ui, con);
      mjui_update(-1, -1, ui, state, con);
    }

    // item
    else if (sect_cur > 0 && item_cur >= 0) {
      // nothing to do for inactive item
      if (!evalpredicate(it_cur->state, ui->predicate, ui->userdata)) {
        return ui->editchanged;
      }

      // process according to type, only if active
      switch (it_cur->type) {
      case mjITEM_SEPARATOR:
        // expanded: collapse
        if (it_cur->state == mjSEPCLOSED+1) {
          it_cur->state = mjSEPCLOSED;
          mjui_resize(ui, con);
          mjui_update(-1, -1, ui, state, con);
        }

        // collapsed: expand
        else if (it_cur->state == mjSEPCLOSED) {
          it_cur->state = mjSEPCLOSED+1;
          mjui_resize(ui, con);
          mjui_update(-1, -1, ui, state, con);
        }

        // nothing else to do for separator
        return ui->editchanged;

      case mjITEM_BUTTON:
        // start tracking
        ui->mousesect = sect_cur;
        ui->mouseitem = item_cur;
        change = 1;
        break;

      case mjITEM_CHECKINT:
        // toggle check
        *(int*)it_cur->pdata = 1 - *(int*)it_cur->pdata;
        change = 1;
        break;

      case mjITEM_CHECKBYTE:
        // toggle check
        *(mjtByte*)it_cur->pdata = 1 - *(mjtByte*)it_cur->pdata;
        change = 1;
        break;

      case mjITEM_RADIO:
        // set selected element
        i = findradio(it_cur, ui, state, con);
        if (i >= 0) {
          *(int*)it_cur->pdata = i;
          change = 1;
        }
        break;

      case mjITEM_RADIOLINE:
        // set selected element
        i = findradioline(it_cur, ui, state, con);
        if (i >= 0) {
          *(int*)it_cur->pdata = i;
          change = 1;
        }
        break;

      case mjITEM_SELECT:
        // start tracking
        ui->mousesect = sect_cur;
        ui->mouseitem = item_cur;
        break;

      case mjITEM_SLIDERINT:
      case mjITEM_SLIDERNUM:
        // set value, start tracking
        setslider(it_cur, ui, state, con);
        ui->mousesect = sect_cur;
        ui->mouseitem = item_cur;
        change = 1;
        break;

      case mjITEM_EDITINT:
      case mjITEM_EDITNUM:
      case mjITEM_EDITFLOAT:
      case mjITEM_EDITTXT:
        // set edit text, clear scroll
        array2text(ui->edittext, it_cur);
        ui->editscroll = 0;

        // set editcursor, adjust editscroll
        setcursor(it_cur->rect, ui, state, con);

        // start tracking: both edit and mouse
        ui->editsect = sect_cur;
        ui->edititem = item_cur;
        ui->mousesect = sect_cur;
        ui->mouseitem = item_cur;
        break;
      }

      // redraw
      mjui_update(sect_cur-1, item_cur, ui, state, con);

      // return if change (otherwise return below)
      if (change) {
        return it_cur;
      }
    }

    // return editchanged, since there was no other change
    return ui->editchanged;

  case mjEVENT_RELEASE:
    // selection box change
    if (it_rec && it_rec->type == mjITEM_SELECT) {
      // find and set value
      i = findselect(it_rec, ui, state, con);
      if (i >= 0) {
        *(int*)it_rec->pdata = i;
      }

      // free mouse and redraw ALL (selection box spills over)
      ui->mousesect = 0;
      mjui_update(-1, -1, ui, state, con);

      // return if value set change
      if (i >= 0) {
        return it_rec;
      }
    }

    // button release
    else if (it_rec && it_rec->type == mjITEM_BUTTON) {
      // free mouse and redraw
      ui->mousesect = 0;
      mjui_update(sect_rec-1, item_rec, ui, state, con);
    }

    // free mouse, return no change
    ui->mousesect = 0;
    return NULL;

  case mjEVENT_SCROLL:
    // adjust scroll
    ui->scroll -= mju_round(state->sy * SCL(ui->spacing.linescroll, con));

    // clamp scroll
    ui->scroll = mjMAX(0, mjMIN(ui->scroll,
                                ui->height-state->rect[ui->rectid].height));
    return NULL;

  case mjEVENT_KEY:
    // editing
    if (sect_edit > 0) {
      // copy key and clear
      key = state->key;
      state->key = 0;

      // process key
      switch (key) {
      case mjKEY_ESCAPE:          // abandon
        ui->editsect = 0;
        break;

      case mjKEY_ENTER:           // instantiate
        if (text2array(ui->edittext, it_edit) == 0) {
          ui->editsect = 0;

          // redraw
          mjui_update(sect_edit-1, item_edit, ui, state, con);

          // record editchanged and return
          ui->editchanged = it_edit;
          return it_edit;
        }
        break;

      case mjKEY_LEFT:            // move cursor left
        // control: emulate Home
        if (state->control) {
          ui->editcursor = 0;
        } else {
          ui->editcursor = mjMAX(0, ui->editcursor-1);
        }
        break;

      case mjKEY_RIGHT:           // move cursor left
        // control: emulate End
        if (state->control) {
          ui->editcursor = strlen(ui->edittext);
        } else {
          ui->editcursor = mjMIN(strlen(ui->edittext), ui->editcursor+1);
        }
        break;

      case mjKEY_HOME:            // move cursor to first position
        ui->editcursor = 0;
        break;

      case mjKEY_END:             // move cursor to last position
        ui->editcursor = strlen(ui->edittext);
        break;

      case mjKEY_BACKSPACE:       // delete before cursor
        if (ui->editcursor > 0) {
          // shift chars after cursor to the left
          for (int i=ui->editcursor; i <= strlen(ui->edittext); i++) {
            ui->edittext[i-1] = ui->edittext[i];
          }

          // move cursor left
          ui->editcursor = ui->editcursor - 1;
        }
        break;

      case mjKEY_DELETE:          // delete after cursor
        if (ui->editcursor < strlen(ui->edittext)) {
          // shift chars after cursor to the left
          for (int i=ui->editcursor; i <= strlen(ui->edittext); i++) {
            ui->edittext[i] = ui->edittext[i+1];
          }
        }
        break;

      default:                    // insert valid key at cursor
        key = validkey(key, strlen(ui->edittext), it_edit->type, state);
        if (key) {
          // shift chars after cursor to the right
          for (int i=strlen(ui->edittext); i >= ui->editcursor; i--) {
            ui->edittext[i+1] = ui->edittext[i];
          }

          // set at cursor
          ui->edittext[ui->editcursor] = key;

          // move cursor right
          ui->editcursor = ui->editcursor + 1;
        }
      }

      // reveal cursor if still editing
      if (ui->editsect > 0) {
        revealcursor(it_edit->rect, ui, con);
      }

      // redraw
      mjui_update(sect_edit-1, item_edit, ui, state, con);
    }

    // shortcut search
    else {
      // search section shortcuts
      for (int n=0; n < ui->nsect; n++)
        if (matchshortcut(state, ui->sect[n].modifier, ui->sect[n].shortcut)) {
          // collapse all
          for (int i=0; i < ui->nsect; i++) {
            if (ui->sect[i].state < 2) {
              ui->sect[i].state = 0;
            }
          }

          // expand this
          if (ui->sect[n].state < 2) {
            ui->sect[n].state = 1;
          }

          // size and update all
          mjui_resize(ui, con);
          mjui_update(-1, -1, ui, state, con);

          // clear key
          state->key = 0;
          return NULL;
        }

      // search item shortcuts
      for (int n=0; n < ui->nsect; n++) {
        for (int i=0; i < ui->sect[n].nitem; i++) {
          // get pointer to item
          it = ui->sect[n].item + i;;

          // check
          if ((it->type == mjITEM_BUTTON || it->type == mjITEM_CHECKINT ||
               it->type == mjITEM_CHECKBYTE) &&
              matchshortcut(state, it->single.modifier, it->single.shortcut)) {
            // clear key
            state->key = 0;

            // active: process shortcut
            if (evalpredicate(it->state, ui->predicate, ui->userdata)) {
              // toggle if check
              if (it->type == mjITEM_CHECKINT) {
                *(int*)it->pdata = 1 - *(int*)it->pdata;
                mjui_update(n, i, ui, state, con);
              } else if (it->type == mjITEM_CHECKBYTE) {
                *(mjtByte*)it->pdata = 1 - *(mjtByte*)it->pdata;
                mjui_update(n, i, ui, state, con);
              }

              // return item
              return it;
            }

            // inactive: nothing to do
            else {
              return NULL;
            }
          }
        }
      }
    }

    return NULL;

  case mjEVENT_RESIZE:
    // clamp scroll
    ui->scroll = mjMAX(0, mjMIN(ui->scroll, ui->height - state->rect[ui->rectid].height));
    return NULL;
  }

  // should not get here, but just in case
  return NULL;
}



// Copy UI image to current buffer.
void mjui_render(mjUI* ui, const mjuiState* state, const mjrContext* con) {
  // get ui rectangle
  mjrRect rect = state->rect[ui->rectid];

  // clear entire rectangle
  mjr_rectangle(rect, ui->color.master[0], ui->color.master[1],
                ui->color.master[2], 1);

  // adjust scroll
  if (ui->scroll > 0 && ui->height-ui->scroll < rect.height) {
    ui->scroll = mjMAX(0, ui->height - rect.height);
  }

  // blit to current buffer
  mjrRect raux = {0, mjMAX(0, ui->height - ui->scroll - rect.height),
                  ui->width, mjMIN(rect.height, ui->height - ui->scroll)};
  mjr_blitAux(ui->auxid, raux, rect.left,
              rect.bottom + mjMAX(0, rect.height - ui->height + ui->scroll), con);

  // draw scrollbar over blit if needed
  if (ui->height > rect.height) {
    // construct rectangles
    mjrRect bar;
    mjrRect thumb;
    scrollrect(rect, ui, con, &bar, &thumb);

    // draw
    mjr_rectangle(thumb, ui->color.thumb[0], ui->color.thumb[1],
                  ui->color.thumb[2], 1);
  }

  // draw selection box tracking over blit if needed
  if (ui->mousesect > 0 && ui->mouseitem >= 0) {
    // get item pointer
    const mjuiItem* it = ui->sect[ui->mousesect-1].item + ui->mouseitem;

    // proceed if select type
    if (it->type == mjITEM_SELECT) {
      // get relevant sizes
      int g_texthor = SCL(ui->spacing.texthor, con);
      int g_textver = SCL(ui->spacing.textver, con);
      int g_itemside = SCL(ui->spacing.itemside, con);
      int cellheight = con->charHeight + 2 * g_textver;
      int offset = mjMAX(0, rect.height - ui->height + ui->scroll) -
                   mjMAX(0, ui->height - ui->scroll - rect.height);

      // margin
      mjrRect r = it->rect;
      r.left -= g_itemside;
      r.width += 2*g_itemside;
      r.height = it->multi.nelem * cellheight + g_itemside;
      r.bottom -= r.height;
      r.bottom += offset;
      r.left += rect.left;
      mjr_rectangle(r, ui->color.sectpane[0],
        ui->color.sectpane[1], ui->color.sectpane[2], 1);

      // box
      r = it->rect;
      r.height = it->multi.nelem * cellheight;
      r.bottom -= r.height;
      r.bottom += offset;
      r.left += rect.left;
      mjr_rectangle(r, ui->color.select2[0],
        ui->color.select2[1], ui->color.select2[2], 1);

      // highlight row under mouse
      int k = findselect(it, ui, state, con);
      if (k >= 0) {
        mjrRect r1 = r;
        r1.bottom = r.bottom + (it->multi.nelem-1-k)*cellheight;
        r1.height = cellheight;
        mjr_rectangle(r1, ui->color.select[0],
          ui->color.select[1], ui->color.select[2], 1);
      }

      // text values
      initOpenGL(&rect, con);
      for (int k=0; k < it->multi.nelem; k++) {
        drawtext(it->multi.name[k],
                 r.left+g_texthor - rect.left,
                 r.bottom+g_textver+(it->multi.nelem-1-k)*cellheight,
                 r.width-2*g_texthor, ui->color.fontactive, con);
      }
    }
  }
}