virtual std::string Tooltip() = 0;

virtual void Draw(UiCanvas *uiCanvas, int x, int y, bool asHovered) = 0;

virtual int AdvanceWidth() = 0;

virtual void Click() = 0;

std::string Tooltip() override { return ""; }

void Draw(UiCanvas *uiCanvas, int x, int y, bool asHovered) override {

// Draw a darker-grey spacer in between the groups of icons.

uiCanvas->DrawRect(x, x + 4, y, y - 24,

/*fillColor=*/{ 45, 45, 45, 255 },

/*outlineColor=*/{});

}

int AdvanceWidth() override { return 12; }

void Click() override {}

bool *variable;

std::string tooltip;

std::string iconName;

std::shared_ptr<Pixmap> icon;

ShowHideButton(bool *variable, std::string iconName, std::string tooltip)

: variable(variable), tooltip(tooltip), iconName(iconName) {}

std::string Tooltip() override {

return ((*variable) ? "Hide " : "Show ") + tooltip;

}

void Draw(UiCanvas *uiCanvas, int x, int y, bool asHovered) override {

if(icon == NULL) {

icon = LoadPng("icons/text-window/" + iconName + ".png");

}

uiCanvas->DrawPixmap(icon, x, y - 24);

if(asHovered) {

uiCanvas->DrawRect(x - 2, x + 26, y + 2, y - 26,

/*fillColor=*/{ 255, 255, 0, 75 },

/*outlineColor=*/{});

}

if(!*(variable)) {

int s = 0, f = 24;

RgbaColor color = { 255, 0, 0, 150 };

uiCanvas->DrawLine(x+s, y-s, x+f, y-f, color, 2);

uiCanvas->DrawLine(x+s, y-f, x+f, y-s, color, 2);

}

}

int AdvanceWidth() override { return 32; }

void Click() override { SS.GW.ToggleBool(variable); }

FacesButton()

: ShowHideButton(&(SS.GW.showFaces), "faces", "") {}

std::string Tooltip() override {

if(*variable) {

return "Don't make faces selectable with mouse";

} else {

return "Make faces selectable with mouse";

}

}

std::shared_ptr<Pixmap> visibleIcon;

std::shared_ptr<Pixmap> stippledIcon;

std::shared_ptr<Pixmap> invisibleIcon;

std::string Tooltip() override {

switch(SS.GW.drawOccludedAs) {

case GraphicsWindow::DrawOccludedAs::INVISIBLE:

return "Stipple occluded lines";

case GraphicsWindow::DrawOccludedAs::STIPPLED:

return "Draw occluded lines";

case GraphicsWindow::DrawOccludedAs::VISIBLE:

return "Don't draw occluded lines";

default: ssassert(false, "Unexpected mode");

}

}

void Draw(UiCanvas *uiCanvas, int x, int y, bool asHovered) override {

if(visibleIcon == NULL) {

visibleIcon = LoadPng("icons/text-window/occluded-visible.png");

}

if(stippledIcon == NULL) {

stippledIcon = LoadPng("icons/text-window/occluded-stippled.png");

}

if(invisibleIcon == NULL) {

invisibleIcon = LoadPng("icons/text-window/occluded-invisible.png");

}

std::shared_ptr<Pixmap> icon;

switch(SS.GW.drawOccludedAs) {

case GraphicsWindow::DrawOccludedAs::INVISIBLE: icon = invisibleIcon; break;

case GraphicsWindow::DrawOccludedAs::STIPPLED: icon = stippledIcon; break;

case GraphicsWindow::DrawOccludedAs::VISIBLE: icon = visibleIcon; break;

}

uiCanvas->DrawPixmap(icon, x, y - 24);

if(asHovered) {

uiCanvas->DrawRect(x - 2, x + 26, y + 2, y - 26,

/*fillColor=*/{ 255, 255, 0, 75 },

/*outlineColor=*/{});

}

}

int AdvanceWidth() override { return 32; }

void Click() override {

switch(SS.GW.drawOccludedAs) {

case GraphicsWindow::DrawOccludedAs::INVISIBLE:

SS.GW.drawOccludedAs = GraphicsWindow::DrawOccludedAs::STIPPLED;

break;

case GraphicsWindow::DrawOccludedAs::STIPPLED:

SS.GW.drawOccludedAs = GraphicsWindow::DrawOccludedAs::VISIBLE;

break;

case GraphicsWindow::DrawOccludedAs::VISIBLE:

SS.GW.drawOccludedAs = GraphicsWindow::DrawOccludedAs::INVISIBLE;

break;

}

SS.GenerateAll();

SS.GW.Invalidate();

SS.ScheduleShowTW();

}

int i;

for(i = 0; in[i].c != 0; i++) {

int c = in[i].c;

ssassert(c >= 0 && c <= 255, "Unexpected color index");

out[c*3 + 0] = in[i].color.redF();

out[c*3 + 1] = in[i].color.greenF();

out[c*3 + 2] = in[i].color.blueF();

}

if(!window) {

window = Platform::CreateWindow(Platform::Window::Kind::TOOL, SS.GW.window);

if(window) {

canvas = CreateRenderer();

using namespace std::placeholders;

window->onClose = []() {

SS.TW.HideEditControl();

SS.GW.showTextWindow = false;

SS.GW.EnsureValidActives();

};

window->onMouseEvent = [this](Platform::MouseEvent event) {

using Platform::MouseEvent;

if(event.type == MouseEvent::Type::PRESS ||

event.type == MouseEvent::Type::DBL_PRESS ||

event.type == MouseEvent::Type::MOTION) {

bool isClick = (event.type != MouseEvent::Type::MOTION);

bool leftDown = (event.button == MouseEvent::Button::LEFT);

this->MouseEvent(isClick, leftDown, event.x, event.y);

return true;

} else if(event.type == MouseEvent::Type::LEAVE) {

MouseLeave();

return true;

} else if(event.type == MouseEvent::Type::SCROLL_VERT) {

if (event.scrollDelta == 0) {

return true;

}

if (abs(event.scrollDelta) < 0.2) {

if (event.scrollDelta > 0) {

event.scrollDelta = 0.2;

} else {

event.scrollDelta = -0.2;

}

}

double offset = LINE_HEIGHT / 2 * event.scrollDelta;

ScrollbarEvent(window->GetScrollbarPosition() - offset);

}

return false;

};

window->onKeyboardEvent = SS.GW.window->onKeyboardEvent;

window->onRender = std::bind(&TextWindow::Paint, this);

window->onEditingDone = std::bind(&TextWindow::EditControlDone, this, _1);

window->onScrollbarAdjusted = std::bind(&TextWindow::ScrollbarEvent, this, _1);

window->SetMinContentSize(370, 370);

}

}

ClearSuper();

// Ugly hack, but not so ugly as the next line

Platform::WindowRef oldWindow = std::move(window);

std::shared_ptr<ViewportCanvas> oldCanvas = canvas;

// Cannot use *this = {} here because TextWindow instances

// are 2.4MB long; this causes stack overflows in prologue

// when built with MSVC, even with optimizations.

memset(this, 0, sizeof(*this));

// Return old canvas

window = std::move(oldWindow);

canvas = oldCanvas;

HideEditControl();

MakeColorTable(fgColors, fgColorTable);

MakeColorTable(bgColors, bgColorTable);

ClearScreen();

Show();

editControl.colorPicker.show = false;

if(window) {

window->HideEditor();

window->Invalidate();

}

if(halfRow < 0) halfRow = top[hoveredRow];

editControl.halfRow = halfRow;

editControl.col = col;

int x = LEFT_MARGIN + CHAR_WIDTH_*col;

int y = (halfRow - SS.TW.scrollPos)*(LINE_HEIGHT/2);

double width, height;

window->GetContentSize(&width, &height);

window->ShowEditor(x, y + LINE_HEIGHT - 2, LINE_HEIGHT - 4,

width - x, /*isMonospace=*/true, str);

SS.ScheduleShowTW();

editControl.colorPicker.show = true;

editControl.colorPicker.rgb = rgb;

editControl.colorPicker.h = 0;

editControl.colorPicker.s = 0;

editControl.colorPicker.v = 1;

ShowEditControl(col, ssprintf("%.2f, %.2f, %.2f", rgb.redF(), rgb.greenF(), rgb.blueF()));

int i, j;

for(i = 0; i < MAX_ROWS; i++) {

for(j = 0; j < MAX_COLS; j++) {

text[i][j] = ' ';

meta[i][j].fg = 'd';

meta[i][j].bg = 'd';

meta[i][j].link = NOT_A_LINK;

}

top[i] = i*2;

}

rows = 0;

if(!canvas) return;

if(rows >= MAX_ROWS) return;

if(rows >= MAX_ROWS-2 && (fmt != endString)) {

// twice due to some half-row issues on resizing

Printf(halfLine, endString);

Printf(halfLine, endString);

return;

}

va_list vl;

va_start(vl, fmt);

int r, c;

r = rows;

top[r] = (r == 0) ? 0 : (top[r-1] + (halfLine ? 3 : 2));

rows++;

for(c = 0; c < MAX_COLS; c++) {

text[r][c] = ' ';

meta[r][c].link = NOT_A_LINK;

}

char fg = 'd';

char bg = 'd';

RgbaColor bgRgb = RGBi(0, 0, 0);

int link = NOT_A_LINK;

uint32_t data = 0;

LinkFunction *f = NULL, *h = NULL;

c = 0;

while(*fmt) {

char buf[1024];

if(*fmt == '%') {

fmt++;

if(*fmt == '\0') goto done;

strcpy(buf, "");

switch(*fmt) {

case 'd': {

int v = va_arg(vl, int);

sprintf(buf, "%d", v);

break;

}

case 'x': {

unsigned int v = va_arg(vl, unsigned int);

sprintf(buf, "%08x", v);

break;

}

case '@': {

double v = va_arg(vl, double);

sprintf(buf, "%.2f", v);

break;

}

case '2': {

double v = va_arg(vl, double);

sprintf(buf, "%s%.2f", v < 0 ? "" : " ", v);

break;

}

case '3': {

double v = va_arg(vl, double);

sprintf(buf, "%s%.3f", v < 0 ? "" : " ", v);

break;

}

case '#': {

double v = va_arg(vl, double);

sprintf(buf, "%.3f", v);

break;

}

case 's': {

char *s = va_arg(vl, char *);

memcpy(buf, s, min(sizeof(buf), strlen(s)+1));

break;

}

case 'c': {

// 'char' is promoted to 'int' when passed through '...'

int v = va_arg(vl, int);

if(v == 0) {

strcpy(buf, "");

} else {

sprintf(buf, "%c", v);

}

break;

}

case 'E':

fg = 'd';

// leave the background, though

link = NOT_A_LINK;

data = 0;

f = NULL;

h = NULL;

break;

case 'F':

case 'B': {

char cc = fmt[1]; // color code

RgbaColor *rgbPtr = NULL;

switch(cc) {

case 0: goto done; // truncated directive

case 'p': cc = (char)va_arg(vl, int); break;

case 'z': rgbPtr = va_arg(vl, RgbaColor *); break;

}

if(*fmt == 'F') {

fg = cc;

} else {

bg = cc;

if(rgbPtr) bgRgb = *rgbPtr;

}

fmt++;

break;

}

case 'L':

if(fmt[1] == '\0') goto done;

fmt++;

if(*fmt == 'p') {

link = va_arg(vl, int);

} else {

link = *fmt;

}

break;

case 'f':

f = va_arg(vl, LinkFunction *);

break;

case 'h':

h = va_arg(vl, LinkFunction *);

break;

case 'D': {

unsigned int v = va_arg(vl, unsigned int);

data = (uint32_t)v;

break;

}

case '%':

strcpy(buf, "%");

break;

}

} else {

utf8_iterator it2(fmt), it1 = it2++;

strncpy(buf, fmt, it2 - it1);

buf[it2 - it1] = '\0';

}

for(utf8_iterator it(buf); *it; ++it) {

for(size_t i = 0; i < canvas->GetBitmapFont()->GetWidth(*it); i++) {

if(c >= MAX_COLS) goto done;

text[r][c] = (i == 0) ? *it : ' ';

meta[r][c].fg = fg;

meta[r][c].bg = bg;

meta[r][c].bgRgb = bgRgb;

meta[r][c].link = link;

meta[r][c].data = data;

meta[r][c].f = f;

meta[r][c].h = h;

c++;

}

}

utf8_iterator it(fmt);

it++;

fmt = it.ptr();

}

while(c < MAX_COLS) {

meta[r][c].fg = fg;

meta[r][c].bg = bg;

meta[r][c].bgRgb = bgRgb;

c++;

}

done:

va_end(vl);

if(SS.GW.pending.operation == GraphicsWindow::Pending::NONE) {

SS.GW.ClearPending(/*scheduleShowTW=*/false);

}

SS.GW.GroupSelection();

auto const &gs = SS.GW.gs;

// Make sure these tests agree with test used to draw indicator line on

// main list of groups screen.

if(SS.GW.pending.description) {

// A pending operation (that must be completed with the mouse in

// the graphics window) will preempt our usual display.

HideEditControl();

ShowHeader(false);

Printf(false, "");

Printf(false, "%s", SS.GW.pending.description);

Printf(true, "%Fl%f%Ll(cancel operation)%E",

&TextWindow::ScreenUnselectAll);

} else if((gs.n > 0 || gs.constraints > 0) &&

shown.screen != Screen::PASTE_TRANSFORMED)

{

if(edit.meaning != Edit::TTF_TEXT) HideEditControl();

ShowHeader(false);

DescribeSelection();

} else {

if(edit.meaning == Edit::TTF_TEXT) HideEditControl();

ShowHeader(true);

switch(shown.screen) {

default:

shown.screen = Screen::LIST_OF_GROUPS;

// fall through

case Screen::LIST_OF_GROUPS: ShowListOfGroups(); break;

case Screen::GROUP_INFO: ShowGroupInfo(); break;

case Screen::GROUP_SOLVE_INFO: ShowGroupSolveInfo(); break;

case Screen::CONFIGURATION: ShowConfiguration(); break;

case Screen::STEP_DIMENSION: ShowStepDimension(); break;

case Screen::LIST_OF_STYLES: ShowListOfStyles(); break;

case Screen::STYLE_INFO: ShowStyleInfo(); break;

case Screen::PASTE_TRANSFORMED: ShowPasteTransformed(); break;

case Screen::EDIT_VIEW: ShowEditView(); break;

case Screen::TANGENT_ARC: ShowTangentArc(); break;

}

}

Printf(false, "");

// Make sure there's room for the color picker

if(editControl.colorPicker.show) {

int pickerHeight = 25;

int halfRow = editControl.halfRow;

if(top[rows-1] - halfRow < pickerHeight && rows < MAX_ROWS) {

rows++;

top[rows-1] = halfRow + pickerHeight;

}

}

if(window) Resize();

{

double width, height;

window->GetContentSize(&width, &height);

halfRows = (int)height / (LINE_HEIGHT/2);

int bottom = top[rows-1] + 2;

scrollPos = min(scrollPos, bottom - halfRows);

scrollPos = max(scrollPos, 0);

window->ConfigureScrollbar(0, top[rows - 1] + 1, halfRows);

window->SetScrollbarPosition(scrollPos);

window->SetScrollbarVisible(top[rows - 1] + 1 > halfRows);

window->Invalidate();

double mx, double my)

{

double width, height;

window->GetContentSize(&width, &height);

int x = 20, y = 33 + LINE_HEIGHT;

y -= scrollPos*(LINE_HEIGHT/2);

if(how == PAINT) {

int top = y - 28, bot = y + 4;

uiCanvas->DrawRect(0, (int)width, top, bot,

/*fillColor=*/{ 30, 30, 30, 255 }, /*outlineColor=*/{});

}

Button *oldHovered = hoveredButton;

if(how != PAINT) {

hoveredButton = NULL;

}

double hoveredX, hoveredY;

for(Button *button : buttons) {

if(how == PAINT) {

button->Draw(uiCanvas, x, y, (button == hoveredButton));

} else if(mx > x - 2 && mx < x + 26 &&

my < y + 2 && my > y - 26) {

hoveredButton = button;

hoveredX = x - 2;

hoveredY = y - 26;

if(how == CLICK) {

button->Click();

}

}

x += button->AdvanceWidth();

}

if(how != PAINT && hoveredButton != oldHovered) {

if(hoveredButton == NULL) {

window->SetTooltip("", 0, 0, 0, 0);

} else {

window->SetTooltip(hoveredButton->Tooltip(), hoveredX, hoveredY, 28, 28);

}

window->Invalidate();

}

if(hsv.x >= 6) hsv.x -= 6;

Vector rgb;

double hmod2 = hsv.x;

while(hmod2 >= 2) hmod2 -= 2;

double x = (1 - fabs(hmod2 - 1));

if(hsv.x < 1) {

rgb = Vector::From(1, x, 0);

} else if(hsv.x < 2) {

rgb = Vector::From(x, 1, 0);

} else if(hsv.x < 3) {

rgb = Vector::From(0, 1, x);

} else if(hsv.x < 4) {

rgb = Vector::From(0, x, 1);

} else if(hsv.x < 5) {

rgb = Vector::From(x, 0, 1);

} else {

rgb = Vector::From(1, 0, x);

}

double c = hsv.y*hsv.z;

double m = 1 - hsv.z;

rgb = rgb.ScaledBy(c);

rgb = rgb.Plus(Vector::From(m, m, m));

return rgb;

std::shared_ptr<Pixmap> pixmap = Pixmap::Create(Pixmap::Format::RGB, w, h);

for(size_t j = 0; j < pixmap->height; j++) {

size_t p = pixmap->stride * j;

for(size_t i = 0; i < pixmap->width; i++) {

Vector hsv = Vector::From(6.0*i/(pixmap->width-1), 1.0*j/(pixmap->height-1), 1);

Vector rgb = HsvToRgb(hsv);

rgb = rgb.ScaledBy(255);

pixmap->data[p++] = (uint8_t)rgb.x;

pixmap->data[p++] = (uint8_t)rgb.y;

pixmap->data[p++] = (uint8_t)rgb.z;

}

}

return pixmap;

std::shared_ptr<Pixmap> pixmap = Pixmap::Create(Pixmap::Format::RGB, w, h);

for(size_t i = 0; i < pixmap->height; i++) {

size_t p = i * pixmap->stride;

for(size_t j = 0; j < pixmap->width; j++) {

Vector hsv = Vector::From(6*hue, sat, 1.0*(pixmap->width - 1 - j)/pixmap->width);

Vector rgb = HsvToRgb(hsv);

rgb = rgb.ScaledBy(255);

pixmap->data[p++] = (uint8_t)rgb.x;

pixmap->data[p++] = (uint8_t)rgb.y;

pixmap->data[p++] = (uint8_t)rgb.z;

}

}

return pixmap;

double x, double y)

{

using Platform::Window;

bool mousePointerAsHand = false;

if(how == HOVER && !leftDown) {

editControl.colorPicker.picker1dActive = false;

editControl.colorPicker.picker2dActive = false;

}

if(!editControl.colorPicker.show) return false;

if(how == CLICK || (how == HOVER && leftDown)) window->Invalidate();

static const RgbaColor BaseColor[12] = {

RGBi(255, 0, 0),

RGBi( 0, 255, 0),

RGBi( 0, 0, 255),

RGBi( 0, 255, 255),

RGBi(255, 0, 255),

RGBi(255, 255, 0),

RGBi(255, 127, 0),

RGBi(255, 0, 127),

RGBi( 0, 255, 127),

RGBi(127, 255, 0),

RGBi(127, 0, 255),

RGBi( 0, 127, 255),

};

double width, height;

window->GetContentSize(&width, &height);

int px = LEFT_MARGIN + CHAR_WIDTH_*editControl.col;

int py = (editControl.halfRow - SS.TW.scrollPos)*(LINE_HEIGHT/2);

py += LINE_HEIGHT + 5;

static const int WIDTH = 16, HEIGHT = 12;

static const int PITCH = 18, SIZE = 15;

px = min(px, (int)width - (WIDTH*PITCH + 40));

int pxm = px + WIDTH*PITCH + 11,

pym = py + HEIGHT*PITCH + 7;

int bw = 6;

if(how == PAINT) {

uiCanvas->DrawRect(px, pxm+bw, py, pym+bw,

/*fillColor=*/{ 50, 50, 50, 255 },

/*outlineColor=*/{},

/*zIndex=*/1);

uiCanvas->DrawRect(px+(bw/2), pxm+(bw/2), py+(bw/2), pym+(bw/2),

/*fillColor=*/{ 0, 0, 0, 255 },

/*outlineColor=*/{},

/*zIndex=*/1);

} else {

if(x < px || x > pxm+(bw/2) ||

y < py || y > pym+(bw/2))

{

return false;

}

}

px += (bw/2);

py += (bw/2);

int i, j;

for(i = 0; i < WIDTH/2; i++) {

for(j = 0; j < HEIGHT; j++) {

Vector rgb;

RgbaColor d;

if(i == 0 && j < 8) {

d = SS.modelColor[j];

rgb = Vector::From(d.redF(), d.greenF(), d.blueF());

} else if(i == 0) {

double a = (j - 8.0)/3.0;

rgb = Vector::From(a, a, a);

} else {

d = BaseColor[j];

rgb = Vector::From(d.redF(), d.greenF(), d.blueF());

if(i >= 2 && i <= 4) {

double a = (i == 2) ? 0.2 : (i == 3) ? 0.3 : 0.4;

rgb = rgb.Plus(Vector::From(a, a, a));

}

if(i >= 5 && i <= 7) {

double a = (i == 5) ? 0.7 : (i == 6) ? 0.4 : 0.18;

rgb = rgb.ScaledBy(a);

}

}

rgb = rgb.ClampWithin(0, 1);

int sx = px + 5 + PITCH*(i + 8) + 4, sy = py + 5 + PITCH*j;

if(how == PAINT) {

uiCanvas->DrawRect(sx, sx+SIZE, sy, sy+SIZE,

/*fillColor=*/RGBf(rgb.x, rgb.y, rgb.z),

/*outlineColor=*/{},

/*zIndex=*/2);

} else if(how == CLICK) {

if(x >= sx && x <= sx+SIZE && y >= sy && y <= sy+SIZE) {

editControl.colorPicker.rgb = RGBf(rgb.x, rgb.y, rgb.z);

ColorPickerDone();

}

} else if(how == HOVER) {

if(x >= sx && x <= sx+SIZE && y >= sy && y <= sy+SIZE) {

mousePointerAsHand = true;

}

}

}

}

int hxm, hym;

int hx = px + 5, hy = py + 5;

hxm = hx + PITCH*7 + SIZE;

hym = hy + PITCH*2 + SIZE;

if(how == PAINT) {

uiCanvas->DrawRect(hx, hxm, hy, hym,

/*fillColor=*/editControl.colorPicker.rgb,

/*outlineColor=*/{},

/*zIndex=*/2);

} else if(how == CLICK) {

if(x >= hx && x <= hxm && y >= hy && y <= hym) {

ColorPickerDone();

}

} else if(how == HOVER) {

if(x >= hx && x <= hxm && y >= hy && y <= hym) {

mousePointerAsHand = true;

}

}

hy += PITCH*3;

hxm = hx + PITCH*7 + SIZE;

hym = hy + PITCH*1 + SIZE;

// The one-dimensional thing to pick the color's value

if(how == PAINT) {

uiCanvas->DrawPixmap(HsvPattern1d(editControl.colorPicker.h,

editControl.colorPicker.s,

hxm-hx, hym-hy),

hx, hy, /*zIndex=*/2);

int cx = hx+(int)((hxm-hx)*(1.0 - editControl.colorPicker.v));

uiCanvas->DrawLine(cx, hy, cx, hym,

/*fillColor=*/{ 0, 0, 0, 255 },

/*outlineColor=*/{},

/*zIndex=*/3);

} else if(how == CLICK ||

(how == HOVER && leftDown && editControl.colorPicker.picker1dActive))

{

if(x >= hx && x <= hxm && y >= hy && y <= hym) {

editControl.colorPicker.v = 1 - (x - hx)/(hxm - hx);

Vector rgb = HsvToRgb(Vector::From(

6*editControl.colorPicker.h,

editControl.colorPicker.s,

editControl.colorPicker.v));

editControl.colorPicker.rgb = RGBf(rgb.x, rgb.y, rgb.z);

editControl.colorPicker.picker1dActive = true;

}

}

// and advance our vertical position

hy += PITCH*2;

hxm = hx + PITCH*7 + SIZE;

hym = hy + PITCH*6 + SIZE;

// Two-dimensional thing to pick a color by hue and saturation

if(how == PAINT) {

uiCanvas->DrawPixmap(HsvPattern2d(hxm-hx, hym-hy), hx, hy,

/*zIndex=*/2);

int cx = hx+(int)((hxm-hx)*editControl.colorPicker.h),

cy = hy+(int)((hym-hy)*editControl.colorPicker.s);

uiCanvas->DrawLine(cx - 5, cy, cx + 5, cy,

/*fillColor=*/{ 255, 255, 255, 255 },

/*outlineColor=*/{},

/*zIndex=*/3);

uiCanvas->DrawLine(cx, cy - 5, cx, cy + 5,

/*fillColor=*/{ 255, 255, 255, 255 },

/*outlineColor=*/{},

/*zIndex=*/3);

} else if(how == CLICK ||

(how == HOVER && leftDown && editControl.colorPicker.picker2dActive))

{

if(x >= hx && x <= hxm && y >= hy && y <= hym) {

double h = (x - hx)/(hxm - hx),

s = (y - hy)/(hym - hy);

editControl.colorPicker.h = h;

editControl.colorPicker.s = s;

Vector rgb = HsvToRgb(Vector::From(

6*editControl.colorPicker.h,

editControl.colorPicker.s,

editControl.colorPicker.v));

editControl.colorPicker.rgb = RGBf(rgb.x, rgb.y, rgb.z);

editControl.colorPicker.picker2dActive = true;

}

}

window->SetCursor(mousePointerAsHand ?

Window::Cursor::HAND :

Window::Cursor::POINTER);

return true;

if (!canvas) return;

double width, height;

window->GetContentSize(&width, &height);

if(halfRows != (int)height / (LINE_HEIGHT/2))

Resize();

Camera camera = {};

camera.width = width;

camera.height = height;

camera.pixelRatio = window->GetDevicePixelRatio();

camera.gridFit = (window->GetDevicePixelRatio() == 1);

camera.LoadIdentity();

camera.offset.x = -camera.width / 2.0;

camera.offset.y = -camera.height / 2.0;

Lighting lighting = {};

lighting.backgroundColor = RGBi(0, 0, 0);

canvas->SetLighting(lighting);

canvas->SetCamera(camera);

canvas->StartFrame();

UiCanvas uiCanvas = {};

uiCanvas.canvas = canvas;

uiCanvas.flip = true;

int r, c, a;

for(a = 0; a < 2; a++) {

for(r = 0; r < rows; r++) {

int ltop = top[r];

if(ltop < (scrollPos-1)) continue;

if(ltop > scrollPos+halfRows) break;

for(c = 0; c < min(((int)width/CHAR_WIDTH_)+1, (int) MAX_COLS); c++) {

int x = LEFT_MARGIN + c*CHAR_WIDTH_;

int y = (ltop-scrollPos)*(LINE_HEIGHT/2) + 4;

int fg = meta[r][c].fg;

int bg = meta[r][c].bg;

// On the first pass, all the background quads; on the next

// pass, all the foreground (i.e., font) quads.

if(a == 0) {

RgbaColor bgRgb = meta[r][c].bgRgb;

int bh = LINE_HEIGHT, adj = 0;

if(bg == 'z') {

bh = CHAR_HEIGHT;

adj += 2;

} else {

bgRgb = RgbaColor::FromFloat(bgColorTable[bg*3+0],

bgColorTable[bg*3+1],

bgColorTable[bg*3+2]);

}

if(bg != 'd') {

// Move the quad down a bit, so that the descenders

// still have the correct background.

uiCanvas.DrawRect(x, x + CHAR_WIDTH_, y + adj, y + adj + bh,

/*fillColor=*/bgRgb, /*outlineColor=*/{});

}

} else if(a == 1) {

RgbaColor fgRgb = RgbaColor::FromFloat(fgColorTable[fg*3+0],

fgColorTable[fg*3+1],

fgColorTable[fg*3+2]);

if(text[r][c] != ' ') {

uiCanvas.DrawBitmapChar(text[r][c], x, y + CHAR_HEIGHT, fgRgb);

}