No CMS or framework detected, hosted on Vultr. Domain registered in 2025.
cascii.app is hosted on Vultr.
| Technology | Version | First seen |
|---|---|---|
| Web Servers, Languages & Backend Frameworks2 | ||
| 1.18.0 | 7 Nov 2026 | |
| – | 7 Nov 2026 | |
| CDN & Hosting1 | ||
| – | 7 Nov 2026 | |
Registration from the registry's RDAP record, the certificate the site serves, and its rank in public traffic lists.
The crew hasn’t read this site’s colors yet. We read a palette when we capture a site’s screenshot, busiest sites first. Meanwhile, browse palettes from other sites.
dns3.iwantmyname.comdns1.iwantmyname.comdns2.iwantmyname.comgoogle-site-verification=TEjJKUtUvbbyJBI3RXM_ps8pFcs1lgZwy7hle5OdH9s<!--
© Copyright 2025 Caspar Wylie <casparwylie@gmail.com>
██████╗ █████╗ ███████╗ ██████╗██╗██╗
██╔════╝██╔══██╗██╔════╝██╔════╝██║██║
██║ ███████║███████╗██║ ██║██║
██║ ██╔══██║╚════██║██║ ██║██║
╚██████╗██║ ██║███████║╚██████╗██║██║
╚═════╝╚═╝ ╚═╝╚══════╝ ╚═════╝╚═╝╚═╝
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.
-->
<head>
<title>CASCII</title>
<meta name="title" content="Cascii: A web-based ASCII diagram builder" />
<meta charset="UTF-8" />
<meta name="description" content="A free, open-source ASCII diagram builder written in vanilla Javascript" />
<meta name="keywords" content="Cascii, CASCII, ASCII, ascii, unicode, diagrams, drawing" />
<meta name="author" content="Caspar Wylie" />
<script>
const VERSION = "v1.0.4";
var layerManager;
var eventManager;
var externalHookManager;
var areaSelectManager;
var modeMaster;
var charManager;
var themeManager;
var bodyComponent;
var canvas;
const ArrowKeyGroup = ["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight"];
const firstVisit = !localStorage.getItem("visited");
//////////////////
////// UTILS /////
//////////////////
function getClipboardText(limit) {
let clipboardData = event.clipboardData || window.clipboardData;
return clipboardData.getData("Text").substring(0, limit);
}
function isTablet() {
return /iPhone|iPad|iPod|Android/i.test(navigator.userAgent);
}
function mobilePage() {
let helpContent = new HelpComponent().value;
document.body.innerHTML = `
<h4 style='font-family:monospace' align='center'>
<img src="https://i.postimg.cc/FzK68HLQ/cascii-logo.png" width="150"><br><br>
Desktop only - Please see the <a href="https://github.com/casparwylie/cascii-core">GitHub</a> page!
${helpContent}
</h4>
`;
}
function reportError(message) {
console.log(message);
}
function debugError(message) {
console.trace();
console.log(`[DEBUG]: ${message}`);
}
function roundHalf(value) {
return parseInt(Math.round(value));
}
function roundUp(value) {
return parseInt(Math.ceil(value));
}
function roundDown(value) {
return parseInt(Math.floor(value));
}
function randomInt(min, max) {
return Math.floor(Math.random() * (max - min + 1)) + min;
}
function sum(arr) {
return arr.reduce((a, b) => a + b, 0);
}
function keyGroup(...names) {
return names.join(",");
}
///////////////////
////// THEMES /////
///////////////////
class Theme {
static Color = {
blue: "#0394fc",
darkBlue: "#0069b5",
darkestBlue: "#1a3540",
lightestBlue: "#baebff",
lightRed: "#ff9494",
red: "#f52f2c",
darkRed: "#9e1910",
darkestRed: "#381111",
black: "black",
white: "white",
none: "transparent",
pink: "#ff78db",
green: "#49d65c",
darkGreen: "#11381b",
lightGreen: "#bdffdb",
grey: "#525252",
nearWhite: "#dedede",
nearBlack: "#1c1c1c",
nearGreenBlack: "#1a261a",
};
config = {
bodyFgColor: Theme.Color.none,
bodyBgColor: Theme.Color.none,
bodyFont: "monospace",
buttonBgColor: Theme.Color.black,
buttonFgColor: Theme.Color.white,
buttonBorderColor: Theme.Color.black,
buttonSelectedBgColor: Theme.Color.blue,
buttonClickBgColor: Theme.Color.blue,
canvasBgColor: Theme.Color.none,
pixelNormalBgColor: Theme.Color.none,
pixelNormalFgColor: Theme.Color.white,
pixelSelectedBgColor: Theme.Color.none,
pixelSelectedFgColor: Theme.Color.darkBlue,
pixelResizeBgColor: Theme.Color.red,
pixelJointBgColor: Theme.Color.pink,
pixelJointNearBgColor: Theme.Color.green,
pixelCursorColor: Theme.Color.red,
areaSelectionBgColor: Theme.Color.blue,
informerDefaultBgColor: Theme.Color.blue,
informerGoodBgColor: Theme.Color.green,
informerBadBgColor: Theme.Color.red,
informerDefaultFgColor: Theme.Color.black,
informerGoodFgColor: Theme.Color.black,
informerBadFgColor: Theme.Color.black,
canvasFont: "monospace",
warningRed: Theme.Color.red,
gridColor: Theme.Color.none,
};
constructor(config) {
for (let key in config) {
this.config[key] = config[key];
}
}
}
class ThemeManager {
defaultTheme = localStorage.getItem("theme") || "systemTheme";
themes = {
darkTheme: new Theme({
bodyBgColor: Theme.Color.black,
bodyFgColor: Theme.Color.white,
buttonBgColor: Theme.Color.black,
buttonFgColor: Theme.Color.white,
buttonBorderColor: Theme.Color.grey,
pixelCursorColor: Theme.Color.white,
pixelNormalFgColor: Theme.Color.white,
pixelResizeBgColor: Theme.Color.blue,
pixelJointNearBgColor: Theme.Color.pink,
pixelJointBgColor: Theme.Color.green,
areaSelectionBgColor: Theme.Color.darkestBlue,
gridColor: Theme.Color.nearBlack,
}),
lightTheme: new Theme({
bodyBgColor: Theme.Color.white,
bodyFgColor: Theme.Color.black,
buttonBgColor: Theme.Color.white,
buttonFgColor: Theme.Color.black,
buttonBorderColor: Theme.Color.black,
pixelCursorColor: Theme.Color.black,
pixelNormalFgColor: Theme.Color.black,
pixelResizeBgColor: Theme.Color.blue,
pixelJointNearBgColor: Theme.Color.pink,
pixelJointBgColor: Theme.Color.green,
areaSelectionBgColor: Theme.Color.lightestBlue,
gridColor: Theme.Color.nearWhite,
}),
consoleTheme: new Theme({
bodyBgColor: Theme.Color.black,
bodyFgColor: Theme.Color.green,
buttonBgColor: Theme.Color.black,
buttonFgColor: Theme.Color.green,
buttonBorderColor: Theme.Color.green,
buttonSelectedBgColor: Theme.Color.darkRed,
pixelSelectedFgColor: Theme.Color.lightGreen,
pixelResizeBgColor: Theme.Color.lightGreen,
pixelCursorColor: Theme.Color.green,
pixelNormalFgColor: Theme.Color.green,
pixelJointNearBgColor: Theme.Color.lightGreen,
pixelJointBgColor: Theme.Color.red,
areaSelectionBgColor: Theme.Color.darkRed,
gridColor: Theme.Color.nearGreenBlack,
}),
};
constructor() {
this.setTheme(this.defaultTheme);
}
getTheme() {
return this.currentTheme.config;
}
static getPreferredSystemTheme() {
return matchMedia("(prefers-color-scheme: light)").matches ? "lightTheme" : "darkTheme";
}
setTheme(theme) {
localStorage.setItem("theme", theme);
if (theme === "systemTheme") {
theme = ThemeManager.getPreferredSystemTheme();
}
this.currentTheme = this.themes[theme];
}
renderTheme() {
layerManager.refresh(() => bodyComponent.renderTheme());
}
}
//////////////////
////// MODES /////
//////////////////
class ModeMaster {
constructor() {
this.callbacks = [];
this._modes = [];
this.setDefault();
}
registerCallback(func) {
this.callbacks.push(func);
}
setDefault() {
if (!this.hasAny()) this.reset("select");
}
modeChangedCallback() {
for (var func of this.callbacks) func();
}
makeFunc(instruction) {
// This just gives dispatchers a prettier notation, and
// restricts us from getting carried away with complicated mode conditions.
// If a condition can't be described by this notation, there's probably a cleaner
// implementation (e.g introducing another mode or making custom method on the ModeMaster).
// () => modeMaster.has("x", "y") becomes [modeMaster.has, "x", "y"]
return instruction.length ? instruction[0].bind(this, ...instruction.slice(1)) : () => true;
}
change(beforeMode, afterMode) {
let index = this._modes.indexOf(beforeMode);
if (index == -1) return;
this._modes[index] = afterMode;
this.modeChangedCallback();
}
toggle(mode) {
this.has(mode) ? this.remove(mode) : this.add(mode);
}
remove(...modes) {
modes.forEach(mode => {
let index = this._modes.indexOf(mode);
if (index == -1) return;
this._modes.splice(index, 1);
});
this.modeChangedCallback();
}
reset(...modes) {
this._modes = modes;
this.modeChangedCallback();
}
add(...modes) {
modes = modes.filter(mode => !this.has(mode));
this._modes = this._modes.concat(modes);
this.modeChangedCallback();
}
has(...modes) {
return modes.map(mode => this._modes.includes(mode)).every(Boolean);
}
hasAny() {
// This is useful to determine if Cascii itself is active (any modes are on).
// E.g if not, we shouldn't prevent default browser events by capturing ctrl commands.
return this._modes.length > 0;
}
hasOr(...modes) {
return modes.map(mode => this._modes.includes(mode)).some(Boolean);
}
is(...modes) {
return this._modes.toString() == modes.toString();
}
isDrawyMode(layerMode) {
// Returns for any draw-related mode (for a given layer).
return this.hasOr("draw", "drawing", "writing") && this.has(layerMode);
}
removeLayerModes() {
layerManager.getLayerTypes().forEach(name => this.remove(name));
this.remove("line");
this.remove("line-based");
}
getLayerType() {
for (let type of layerManager.getLayerTypes()) {
if (this.has(type)) return type;
}
}
setSelectedLayerMode(layer) {
this.removeLayerModes();
this.add(layer.getType());
// Rules for dynamic layer modes
if (layer.isLine()) this.add("line");
if (layer.isLineBased()) this.add("line-based");
}
}
////////////////
//// EVENTS ////
////////////////
class BaseExternalHookManager {
/*
This class should be overridden by optional dependencies
allowing upstream functionality for specific hooks coming from this core app.
E.g It is used to trigger server hooks for the server layer which,
by design, is optionally attached.
I want this file to open as an index.html and work out-of-the box,
with 0 dependencies on a server, packaging, etc.
*/
async getShortKeyUrl() {
// Without a server, we return an empty short key.
return "";
}
triggerDrawingChanged() {}
}
class EventDef {
constructor(modeCondition, modeUpdate, callback = () => {}) {
this.callback = callback;
this.condition = modeMaster.makeFunc(modeCondition);
this.update = modeMaster.makeFunc(modeUpdate);
}
run(event) {
if (this.condition()) {
this.update();
this.callback(event);
return true;
}
}
}
class EventManager {
MAP = {
document: {
keyEvents: {
keypress: {
"*": [new EventDef([modeMaster.has, "writing", "text"], [], TextLayer.keyDownEvent)],
},
keydown: {
[keyGroup(...ArrowKeyGroup)]: [
new EventDef([modeMaster.has, "selected"], [], event =>
layerManager.selectedArrowKeyDownEvent(event.key)
),
],
[["Shift"]]: [new EventDef([modeMaster.hasAny], [modeMaster.add, "shift"])],
[keyGroup("Backspace", "Delete")]: [
new EventDef([modeMaster.has, "selected"], [modeMaster.reset, "select"], () =>
layerManager.deleteLayersEvent()
),
],
[keyGroup("Escape")]: [
new EventDef([modeMaster.hasOr, "writing", "selected"], [modeMaster.reset, "select"], () =>
layerManager.unselectAll()
),
],
[keyGroup("Backspace", "Delete", ...ArrowKeyGroup)]: [
new EventDef([modeMaster.has, "writing", "text"], [], TextLayer.keyDownEvent),
],
[keyGroup("Control")]: [new EventDef([modeMaster.hasAny], [modeMaster.add, "ctrl"])],
[keyGroup("Z", "z")]: [
new EventDef([modeMaster.has, "shift", "ctrl"], [], event => layerManager.redoEvent(event)),
],
[keyGroup("z")]: [new EventDef([modeMaster.has, "ctrl"], [], event => layerManager.undoEvent(event))],
[keyGroup("c")]: [
new EventDef([modeMaster.has, "ctrl", "selected"], [], () => layerManager.copySelectedLayersEvent()),
],
[keyGroup("a")]: [
new EventDef([modeMaster.has, "ctrl"], [modeMaster.reset, "selected"], event =>
layerManager.selectAllEvent(event)
),
],
[keyGroup("g")]: [
new EventDef([modeMaster.has, "selected"], [], () => layerManager.groupSelectedLayersEvent()),
],
},
keyup: {
[keyGroup("Shift")]: [new EventDef([modeMaster.has, "shift"], [modeMaster.remove, "shift"])],
[keyGroup("Control")]: [new EventDef([modeMaster.has, "ctrl"], [modeMaster.remove, "ctrl"])],
},
},
},
window: {
mouseEvents: {
resize: [new EventDef([], [], event => canvas.scale())],
paste: [
new EventDef([modeMaster.has, "writing", "text"], [], event => layerManager.pasteToTextLayerEvent(event)),
new EventDef([modeMaster.hasAny], [], event => layerManager.pasteAsTextLayerEvent(event)),
],
// A mouseup should be detected beyond the canvas, so it's here instead.
mouseup: [
new EventDef([modeMaster.has, "drawing"], [modeMaster.change, "drawing", "draw"], event =>
layerManager.changeEvent(event)
),
new EventDef([modeMaster.has, "erasing"], [modeMaster.change, "erasing", "erase"]),
new EventDef([modeMaster.has, "moving"], [modeMaster.remove, "moving"], event =>
layerManager.changeEvent(event)
),
new EventDef([modeMaster.has, "area-selecting"], [modeMaster.remove, "area-selecting"], event =>
areaSelectManager.areaSelectingMouseUpEvent(event)
),
new EventDef([modeMaster.has, "resizing"], [modeMaster.remove, "resizing"], event =>
layerManager.changeEvent(event)
),
],
},
},
canvas: {
mouseEvents: {
mousedown: [
new EventDef(
[modeMaster.has, "draw", "text"],
[modeMaster.change, "draw", "writing"],
TextLayer.drawMouseDownEvent
),
new EventDef([modeMaster.has, "draw"], [modeMaster.change, "draw", "drawing"], Layer.drawMouseDownEvent),
new EventDef([modeMaster.has, "writing", "text"], [], TextLayer.writingMouseDownEvent),
new EventDef([modeMaster.has, "erase"], [modeMaster.change, "erase", "erasing"], event =>
layerManager.erasePixelEvent(event)
),
new EventDef([modeMaster.hasOr, "selected", "select"], [], Layer.selectMouseDownEvent),
],
mouseover: [
new EventDef(
[modeMaster.has, "draw", "line"], // Technically this should be for any joiner layer...
[],
BaseLineLayer.drawMouseOver
),
new EventDef([modeMaster.has, "draw"], [], Layer.drawMouseOver),
new EventDef([modeMaster.has, "drawing"], [], Layer.drawingMouseOverEvent),
new EventDef([modeMaster.has, "erasing"], [], event => layerManager.erasePixelEvent(event)),
new EventDef([modeMaster.has, "area-selecting"], [], event =>
areaSelectManager.areaSelectingMouseOverEvent(event)
),
new EventDef([modeMaster.has, "moving"], [], event => layerManager.movingMouseOverEvent(event)),
new EventDef([modeMaster.has, "resizing"], [], event => layerManager.resizingMouseOverEvent(event)),
new EventDef([modeMaster.hasOr, "selected", "select"], [], event =>
layerManager.selectMouseOverEvent(event)
),
],
dblclick: [
new EventDef(
[modeMaster.has, "selected", "text"],
[modeMaster.change, "selected", "writing"],
TextLayer.selectedDoubleClickEvent
),
new EventDef([modeMaster.has, "writing"], [], TextLayer.selectedDoubleClickEvent),
],
},
},
};
assignMouseEventDefs(element, allDefs) {
for (const [eventType, defs] of Object.entries(allDefs)) {
element.addEventListener(eventType, event => {
for (var def of defs) if (def.run(event)) return;
});
}
}
assignKeyEventDefs(element, defs) {
Object.keys(defs).forEach(eventType => {
element.addEventListener(eventType, event => {
// This maps apple Command key to Ctrl.
var eventKey = event.key == "Meta" ? "Control" : event.key;
for (var keys in defs[eventType]) {
for (let key of keys.split(",")) {
if (key == eventKey || key == "*") {
for (var def of defs[eventType][keys]) {
if (def.run(event)) return;
}
}
}
}
});
});
}
assignAll(namedElements) {
for (const [elementName, eventGroups] of Object.entries(this.MAP)) {
for (const [eventGroup, eventDefs] of Object.entries(eventGroups)) {
switch (eventGroup) {
case "mouseEvents":
this.assignMouseEventDefs(namedElements[elementName], eventDefs);
break;
case "keyEvents":
this.assignKeyEventDefs(namedElements[elementName], eventDefs);
break;
}
}
}
}
}
///////////////
//// CHARS ////
///////////////
class CharManager {
// Useful: https://www.w3.org/TR/xml-entity-names/025.html
// And: https://www.amp-what.com/unicode/search/dot
charset = {
// Dotted lines
"•": ["dotted", "line", "vertical", "lateral", "corner", "generic", "unicode"],
".": ["dotted", "line", "vertical", "lateral", "corner", "generic", "ascii"],
// Solid lines
"━": ["solid-bold", "line", "lateral", "unicode"],
"┃": ["solid-bold", "line", "vertical", "unicode"],
"|": ["solid-thin", "solid-rounded", "solid-bold", "line", "<!--
© Copyright 2025 Caspar Wylie <casparwylie@gmail.com>
██████╗ █████╗ ███████╗ ██████╗██╗██╗
██╔════╝██╔══██╗██╔════╝██╔════╝██║██║
██║ ███████║███████╗██║ ██║██║
██║ ██╔══██║╚════██║██║ ██║██║
╚██████╗██║ ██║███████║╚██████╗██║██║
╚═════╝╚═╝ ╚═╝╚══════╝ ╚═════╝╚═╝╚═╝
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.
-->
<head>
<title>CASCII</title>
<meta name="title" content="Cascii: A web-based ASCII diagram builder" />
<meta charset="UTF-8" />
<meta name="description" content="A free, open-source ASCII diagram builder written in vanilla Javascript" />
<meta name="keywords" content="Cascii, CASCII, ASCII, ascii, unicode, diagrams, drawing" />
<meta name="author" content="Caspar Wylie" />
<script>
const VERSION = "v1.0.4";
var layerManager;
var eventManager;
var externalHookManager;
var areaSelectManager;
var modeMaster;
var charManager;
var themeManager;
var bodyComponent;
var canvas;
const ArrowKeyGroup = ["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight"];
const firstVisit = !localStorage.getItem("visited");
//////////////////
////// UTILS /////
//////////////////
function getClipboardText(limit) {
let clipboardData = event.clipboardData || window.clipboardData;
return clipboardData.getData("Text").substring(0, limit);
}
function isTablet() {
return /iPhone|iPad|iPod|Android/i.test(navigator.userAgent);
}
function mobilePage() {
let helpContent = new HelpComponent().value;
document.body.innerHTML = `
<h4 style='font-family:monospace' align='center'>
<img src="https://i.postimg.cc/FzK68HLQ/cascii-logo.png" width="150"><br><br>
Desktop only - Please see the <a href="https://github.com/casparwylie/cascii-core">GitHub</a> page!
${helpContent}
</h4>
`;
}
function reportError(message) {
console.log(message);
}
function debugError(message) {
console.trace();
console.log(`[DEBUG]: ${message}`);
}
function roundHalf(value) {
return parseInt(Math.round(value));
}
function roundUp(value) {
return parseInt(Math.ceil(value));
}
function roundDown(value) {
return parseInt(Math.floor(value));
}
function randomInt(min, max) {
return Math.floor(Math.random() * (max - min + 1)) + min;
}
function sum(arr) {
return arr.reduce((a, b) => a + b, 0);
}
function keyGroup(...names) {
return names.join(",");
}
///////////////////
////// THEMES /////
///////////////////
class Theme {
static Color = {
blue: "#0394fc",
darkBlue: "#0069b5",
darkestBlue: "#1a3540",
lightestBlue: "#baebff",
lightRed: "#ff9494",
red: "#f52f2c",
darkRed: "#9e1910",
darkestRed: "#381111",
black: "black",
white: "white",
none: "transparent",
pink: "#ff78db",
green: "#49d65c",
darkGreen: "#11381b",
lightGreen: "#bdffdb",
grey: "#525252",
nearWhite: "#dedede",
nearBlack: "#1c1c1c",
nearGreenBlack: "#1a261a",
};
config = {
bodyFgColor: Theme.Color.none,
bodyBgColor: Theme.Color.none,
bodyFont: "monospace",
buttonBgColor: Theme.Color.black,
buttonFgColor: Theme.Color.white,
buttonBorderColor: Theme.Color.black,
buttonSelectedBgColor: Theme.Color.blue,
buttonClickBgColor: Theme.Color.blue,
canvasBgColor: Theme.Color.none,
pixelNormalBgColor: Theme.Color.none,
pixelNormalFgColor: Theme.Color.white,
pixelSelectedBgColor: Theme.Color.none,
pixelSelectedFgColor: Theme.Color.darkBlue,
pixelResizeBgColor: Theme.Color.red,
pixelJointBgColor: Theme.Color.pink,
pixelJointNearBgColor: Theme.Color.green,
pixelCursorColor: Theme.Color.red,
areaSelectionBgColor: Theme.Color.blue,
informerDefaultBgColor: Theme.Color.blue,
informerGoodBgColor: Theme.Color.green,
informerBadBgColor: Theme.Color.red,
informerDefaultFgColor: Theme.Color.black,
informerGoodFgColor: Theme.Color.black,
informerBadFgColor: Theme.Color.black,
canvasFont: "monospace",
warningRed: Theme.Color.red,
gridColor: Theme.Color.none,
};
constructor(config) {
for (let key in config) {
this.config[key] = config[key];
}
}
}
class ThemeManager {
defaultTheme = localStorage.getItem("theme") || "systemTheme";
themes = {
darkTheme: new Theme({
bodyBgColor: Theme.Color.black,
bodyFgColor: Theme.Color.white,
buttonBgColor: Theme.Color.black,
buttonFgColor: Theme.Color.white,
buttonBorderColor: Theme.Color.grey,
pixelCursorColor: Theme.Color.white,
pixelNormalFgColor: Theme.Color.white,
pixelResizeBgColor: Theme.Color.blue,
pixelJointNearBgColor: Theme.Color.pink,
pixelJointBgColor: Theme.Color.green,
areaSelectionBgColor: Theme.Color.darkestBlue,
gridColor: Theme.Color.nearBlack,
}),
lightTheme: new Theme({
bodyBgColor: Theme.Color.white,
bodyFgColor: Theme.Color.black,
buttonBgColor: Theme.Color.white,
buttonFgColor: Theme.Color.black,
buttonBorderColor: Theme.Color.black,
pixelCursorColor: Theme.Color.black,
pixelNormalFgColor: Theme.Color.black,
pixelResizeBgColor: Theme.Color.blue,
pixelJointNearBgColor: Theme.Color.pink,
pixelJointBgColor: Theme.Color.green,
areaSelectionBgColor: Theme.Color.lightestBlue,
gridColor: Theme.Color.nearWhite,
}),
consoleTheme: new Theme({
bodyBgColor: Theme.Color.black,
bodyFgColor: Theme.Color.green,
buttonBgColor: Theme.Color.black,
buttonFgColor: Theme.Color.green,
buttonBorderColor: Theme.Color.green,
buttonSelectedBgColor: Theme.Color.darkRed,
pixelSelectedFgColor: Theme.Color.lightGreen,
pixelResizeBgColor: Theme.Color.lightGreen,
pixelCursorColor: Theme.Color.green,
pixelNormalFgColor: Theme.Color.green,
pixelJointNearBgColor: Theme.Color.lightGreen,
pixelJointBgColor: Theme.Color.red,
areaSelectionBgColor: Theme.Color.darkRed,
gridColor: Theme.Color.nearGreenBlack,
}),
};
constructor() {
this.setTheme(this.defaultTheme);
}
getTheme() {
return this.currentTheme.config;
}
static getPreferredSystemTheme() {
return matchMedia("(prefers-color-scheme: light)").matches ? "lightTheme" : "darkTheme";
}
setTheme(theme) {
localStorage.setItem("theme", theme);
if (theme === "systemTheme") {
theme = ThemeManager.getPreferredSystemTheme();
}
this.currentTheme = this.themes[theme];
}
renderTheme() {
layerManager.refresh(() => bodyComponent.renderTheme());
}
}
//////////////////
////// MODES /////
//////////////////
class ModeMaster {
constructor() {
this.callbacks = [];
this._modes = [];
this.setDefault();
}
registerCallback(func) {
this.callbacks.push(func);
}
setDefault() {
if (!this.hasAny()) this.reset("select");
}
modeChangedCallback() {
for (var func of this.callbacks) func();
}
makeFunc(instruction) {
// This just gives dispatchers a prettier notation, and
// restricts us from getting carried away with complicated mode conditions.
// If a condition can't be described by this notation, there's probably a cleaner
// implementation (e.g introducing another mode or making custom method on the ModeMaster).
// () => modeMaster.has("x", "y") becomes [modeMaster.has, "x", "y"]
return instruction.length ? instruction[0].bind(this, ...instruction.slice(1)) : () => true;
}
change(beforeMode, afterMode) {
let index = this._modes.indexOf(beforeMode);
if (index == -1) return;
this._modes[index] = afterMode;
this.modeChangedCallback();
}
toggle(mode) {
this.has(mode) ? this.remove(mode) : this.add(mode);
}
remove(...modes) {
modes.forEach(mode => {
let index = this._modes.indexOf(mode);
if (index == -1) return;
this._modes.splice(index, 1);
});
this.modeChangedCallback();
}
reset(...modes) {
this._modes = modes;
this.modeChangedCallback();
}
add(...modes) {
modes = modes.filter(mode => !this.has(mode));
this._modes = this._modes.concat(modes);
this.modeChangedCallback();
}
has(...modes) {
return modes.map(mode => this._modes.includes(mode)).every(Boolean);
}
hasAny() {
// This is useful to determine if Cascii itself is active (any modes are on).
// E.g if not, we shouldn't prevent default browser events by capturing ctrl commands.
return this._modes.length > 0;
}
hasOr(...modes) {
return modes.map(mode => this._modes.includes(mode)).some(Boolean);
}
is(...modes) {
return this._modes.toString() == modes.toString();
}
isDrawyMode(layerMode) {
// Returns for any draw-related mode (for a given layer).
return this.hasOr("draw", "drawing", "writing") && this.has(layerMode);
}
removeLayerModes() {
layerManager.getLayerTypes().forEach(name => this.remove(name));
this.remove("line");
this.remove("line-based");
}
getLayerType() {
for (let type of layerManager.getLayerTypes()) {
if (this.has(type)) return type;
}
}
setSelectedLayerMode(layer) {
this.removeLayerModes();
this.add(layer.getType());
// Rules for dynamic layer modes
if (layer.isLine()) this.add("line");
if (layer.isLineBased()) this.add("line-based");
}
}
////////////////
//// EVENTS ////
////////////////
class BaseExternalHookManager {
/*
This class should be overridden by optional dependencies
allowing upstream functionality for specific hooks coming from this core app.
E.g It is used to trigger server hooks for the server layer which,
by design, is optionally attached.
I want this file to open as an index.html and work out-of-the box,
with 0 dependencies on a server, packaging, etc.
*/
async getShortKeyUrl() {
// Without a server, we return an empty short key.
return "";
}
triggerDrawingChanged() {}
}
class EventDef {
constructor(modeCondition, modeUpdate, callback = () => {}) {
this.callback = callback;
this.condition = modeMaster.makeFunc(modeCondition);
this.update = modeMaster.makeFunc(modeUpdate);
}
run(event) {
if (this.condition()) {
this.update();
this.callback(event);
return true;
}
}
}
class EventManager {
MAP = {
document: {
keyEvents: {
keypress: {
"*": [new EventDef([modeMaster.has, "writing", "text"], [], TextLayer.keyDownEvent)],
},
keydown: {
[keyGroup(...ArrowKeyGroup)]: [
new EventDef([modeMaster.has, "selected"], [], event =>
layerManager.selectedArrowKeyDownEvent(event.key)
),
],
[["Shift"]]: [new EventDef([modeMaster.hasAny], [modeMaster.add, "shift"])],
[keyGroup("Backspace", "Delete")]: [
new EventDef([modeMaster.has, "selected"], [modeMaster.reset, "select"], () =>
layerManager.deleteLayersEvent()
),
],
[keyGroup("Escape")]: [
new EventDef([modeMaster.hasOr, "writing", "selected"], [modeMaster.reset, "select"], () =>
layerManager.unselectAll()
),
],
[keyGroup("Backspace", "Delete", ...ArrowKeyGroup)]: [
new EventDef([modeMaster.has, "writing", "text"], [], TextLayer.keyDownEvent),
],
[keyGroup("Control")]: [new EventDef([modeMaster.hasAny], [modeMaster.add, "ctrl"])],
[keyGroup("Z", "z")]: [
new EventDef([modeMaster.has, "shift", "ctrl"], [], event => layerManager.redoEvent(event)),
],
[keyGroup("z")]: [new EventDef([modeMaster.has, "ctrl"], [], event => layerManager.undoEvent(event))],
[keyGroup("c")]: [
new EventDef([modeMaster.has, "ctrl", "selected"], [], () => layerManager.copySelectedLayersEvent()),
],
[keyGroup("a")]: [
new EventDef([modeMaster.has, "ctrl"], [modeMaster.reset, "selected"], event =>
layerManager.selectAllEvent(event)
),
],
[keyGroup("g")]: [
new EventDef([modeMaster.has, "selected"], [], () => layerManager.groupSelectedLayersEvent()),
],
},
keyup: {
[keyGroup("Shift")]: [new EventDef([modeMaster.has, "shift"], [modeMaster.remove, "shift"])],
[keyGroup("Control")]: [new EventDef([modeMaster.has, "ctrl"], [modeMaster.remove, "ctrl"])],
},
},
},
window: {
mouseEvents: {
resize: [new EventDef([], [], event => canvas.scale())],
paste: [
new EventDef([modeMaster.has, "writing", "text"], [], event => layerManager.pasteToTextLayerEvent(event)),
new EventDef([modeMaster.hasAny], [], event => layerManager.pasteAsTextLayerEvent(event)),
],
// A mouseup should be detected beyond the canvas, so it's here instead.
mouseup: [
new EventDef([modeMaster.has, "drawing"], [modeMaster.change, "drawing", "draw"], event =>
layerManager.changeEvent(event)
),
new EventDef([modeMaster.has, "erasing"], [modeMaster.change, "erasing", "erase"]),
new EventDef([modeMaster.has, "moving"], [modeMaster.remove, "moving"], event =>
layerManager.changeEvent(event)
),
new EventDef([modeMaster.has, "area-selecting"], [modeMaster.remove, "area-selecting"], event =>
areaSelectManager.areaSelectingMouseUpEvent(event)
),
new EventDef([modeMaster.has, "resizing"], [modeMaster.remove, "resizing"], event =>
layerManager.changeEvent(event)
),
],
},
},
canvas: {
mouseEvents: {
mousedown: [
new EventDef(
[modeMaster.has, "draw", "text"],
[modeMaster.change, "draw", "writing"],
TextLayer.drawMouseDownEvent
),
new EventDef([modeMaster.has, "draw"], [modeMaster.change, "draw", "drawing"], Layer.drawMouseDownEvent),
new EventDef([modeMaster.has, "writing", "text"], [], TextLayer.writingMouseDownEvent),
new EventDef([modeMaster.has, "erase"], [modeMaster.change, "erase", "erasing"], event =>
layerManager.erasePixelEvent(event)
),
new EventDef([modeMaster.hasOr, "selected", "select"], [], Layer.selectMouseDownEvent),
],
mouseover: [
new EventDef(
[modeMaster.has, "draw", "line"], // Technically this should be for any joiner layer...
[],
BaseLineLayer.drawMouseOver
),
new EventDef([modeMaster.has, "draw"], [], Layer.drawMouseOver),
new EventDef([modeMaster.has, "drawing"], [], Layer.drawingMouseOverEvent),
new EventDef([modeMaster.has, "erasing"], [], event => layerManager.erasePixelEvent(event)),
new EventDef([modeMaster.has, "area-selecting"], [], event =>
areaSelectManager.areaSelectingMouseOverEvent(event)
),
new EventDef([modeMaster.has, "moving"], [], event => layerManager.movingMouseOverEvent(event)),
new EventDef([modeMaster.has, "resizing"], [], event => layerManager.resizingMouseOverEvent(event)),
new EventDef([modeMaster.hasOr, "selected", "select"], [], event =>
layerManager.selectMouseOverEvent(event)
),
],
dblclick: [
new EventDef(
[modeMaster.has, "selected", "text"],
[modeMaster.change, "selected", "writing"],
TextLayer.selectedDoubleClickEvent
),
new EventDef([modeMaster.has, "writing"], [], TextLayer.selectedDoubleClickEvent),
],
},
},
};
assignMouseEventDefs(element, allDefs) {
for (const [eventType, defs] of Object.entries(allDefs)) {
element.addEventListener(eventType, event => {
for (var def of defs) if (def.run(event)) return;
});
}
}
assignKeyEventDefs(element, defs) {
Object.keys(defs).forEach(eventType => {
element.addEventListener(eventType, event => {
// This maps apple Command key to Ctrl.
var eventKey = event.key == "Meta" ? "Control" : event.key;
for (var keys in defs[eventType]) {
for (let key of keys.split(",")) {
if (key == eventKey || key == "*") {
for (var def of defs[eventType][keys]) {
if (def.run(event)) return;
}
}
}
}
});
});
}
assignAll(namedElements) {
for (const [elementName, eventGroups] of Object.entries(this.MAP)) {
for (const [eventGroup, eventDefs] of Object.entries(eventGroups)) {
switch (eventGroup) {
case "mouseEvents":
this.assignMouseEventDefs(namedElements[elementName], eventDefs);
break;
case "keyEvents":
this.assignKeyEventDefs(namedElements[elementName], eventDefs);
break;
}
}
}
}
}
///////////////
//// CHARS ////
///////////////
class CharManager {
// Useful: https://www.w3.org/TR/xml-entity-names/025.html
// And: https://www.amp-what.com/unicode/search/dot
charset = {
// Dotted lines
"•": ["dotted", "line", "vertical", "lateral", "corner", "generic", "unicode"],
".": ["dotted", "line", "vertical", "lateral", "corner", "generic", "ascii"],
// Solid lines
"━": ["solid-bold", "line", "lateral", "unicode"],
"┃": ["solid-bold", "line", "vertical", "unicode"],
"|": ["solid-thin", "solid-rounded", "solid-bold", "line", "<!--
© Copyright 2025 Caspar Wylie <casparwylie@gmail.com>
██████╗ █████╗ ███████╗ ██████╗██╗██╗
██╔════╝██╔══██╗██╔════╝██╔════╝██║██║
██║ ███████║███████╗██║ ██║██║
██║ ██╔══██║╚════██║██║ ██║██║
╚██████╗██║ ██║███████║╚██████╗██║██║
╚═════╝╚═╝ ╚═╝╚══════╝ ╚═════╝╚═╝╚═╝
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.
-->
<head>
<title>CASCII</title>
<meta name="title" content="Cascii: A web-based ASCII diagram builder" />
<meta charset="UTF-8" />
<meta name="description" content="A free, open-source ASCII diagram builder written in vanilla Javascript" />
<meta name="keywords" content="Cascii, CASCII, ASCII, ascii, unicode, diagrams, drawing" />
<meta name="author" content="Caspar Wylie" />
<script>
const VERSION = "v1.0.4";
var layerManager;
var eventManager;
var externalHookManager;
var areaSelectManager;
var modeMaster;
var charManager;
var themeManager;
var bodyComponent;
var canvas;
const ArrowKeyGroup = ["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight"];
const firstVisit = !localStorage.getItem("visited");
//////////////////
////// UTILS /////
//////////////////
function getClipboardText(limit) {
let clipboardData = event.clipboardData || window.clipboardData;
return clipboardData.getData("Text").substring(0, limit);
}
function isTablet() {
return /iPhone|iPad|iPod|Android/i.test(navigator.userAgent);
}
function mobilePage() {
let helpContent = new HelpComponent().value;
document.body.innerHTML = `
<h4 style='font-family:monospace' align='center'>
<img src="https://i.postimg.cc/FzK68HLQ/cascii-logo.png" width="150"><br><br>
Desktop only - Please see the <a href="https://github.com/casparwylie/cascii-core">GitHub</a> page!
${helpContent}
</h4>
`;
}
function reportError(message) {
console.log(message);
}
function debugError(message) {
console.trace();
console.log(`[DEBUG]: ${message}`);
}
function roundHalf(value) {
return parseInt(Math.round(value));
}
function roundUp(value) {
return parseInt(Math.ceil(value));
}
function roundDown(value) {
return parseInt(Math.floor(value));
}
function randomInt(min, max) {
return Math.floor(Math.random() * (max - min + 1)) + min;
}
function sum(arr) {
return arr.reduce((a, b) => a + b, 0);
}
function keyGroup(...names) {
return names.join(",");
}
///////////////////
////// THEMES /////
///////////////////
class Theme {
static Color = {
blue: "#0394fc",
darkBlue: "#0069b5",
darkestBlue: "#1a3540",
lightestBlue: "#baebff",
lightRed: "#ff9494",
red: "#f52f2c",
darkRed: "#9e1910",
darkestRed: "#381111",
black: "black",
white: "white",
none: "transparent",
pink: "#ff78db",
green: "#49d65c",
darkGreen: "#11381b",
lightGreen: "#bdffdb",
grey: "#525252",
nearWhite: "#dedede",
nearBlack: "#1c1c1c",
nearGreenBlack: "#1a261a",
};
config = {
bodyFgColor: Theme.Color.none,
bodyBgColor: Theme.Color.none,
bodyFont: "monospace",
buttonBgColor: Theme.Color.black,
buttonFgColor: Theme.Color.white,
buttonBorderColor: Theme.Color.black,
buttonSelectedBgColor: Theme.Color.blue,
buttonClickBgColor: Theme.Color.blue,
canvasBgColor: Theme.Color.none,
pixelNormalBgColor: Theme.Color.none,
pixelNormalFgColor: Theme.Color.white,
pixelSelectedBgColor: Theme.Color.none,
pixelSelectedFgColor: Theme.Color.darkBlue,
pixelResizeBgColor: Theme.Color.red,
pixelJointBgColor: Theme.Color.pink,
pixelJointNearBgColor: Theme.Color.green,
pixelCursorColor: Theme.Color.red,
areaSelectionBgColor: Theme.Color.blue,
informerDefaultBgColor: Theme.Color.blue,
informerGoodBgColor: Theme.Color.green,
informerBadBgColor: Theme.Color.red,
informerDefaultFgColor: Theme.Color.black,
informerGoodFgColor: Theme.Color.black,
informerBadFgColor: Theme.Color.black,
canvasFont: "monospace",
warningRed: Theme.Color.red,
gridColor: Theme.Color.none,
};
constructor(config) {
for (let key in config) {
this.config[key] = config[key];
}
}
}
class ThemeManager {
defaultTheme = localStorage.getItem("theme") || "systemTheme";
themes = {
darkTheme: new Theme({
bodyBgColor: Theme.Color.black,
bodyFgColor: Theme.Color.white,
buttonBgColor: Theme.Color.black,
buttonFgColor: Theme.Color.white,
buttonBorderColor: Theme.Color.grey,
pixelCursorColor: Theme.Color.white,
pixelNormalFgColor: Theme.Color.white,
pixelResizeBgColor: Theme.Color.blue,
pixelJointNearBgColor: Theme.Color.pink,
pixelJointBgColor: Theme.Color.green,
areaSelectionBgColor: Theme.Color.darkestBlue,
gridColor: Theme.Color.nearBlack,
}),
lightTheme: new Theme({
bodyBgColor: Theme.Color.white,
bodyFgColor: Theme.Color.black,
buttonBgColor: Theme.Color.white,
buttonFgColor: Theme.Color.black,
buttonBorderColor: Theme.Color.black,
pixelCursorColor: Theme.Color.black,
pixelNormalFgColor: Theme.Color.black,
pixelResizeBgColor: Theme.Color.blue,
pixelJointNearBgColor: Theme.Color.pink,
pixelJointBgColor: Theme.Color.green,
areaSelectionBgColor: Theme.Color.lightestBlue,
gridColor: Theme.Color.nearWhite,
}),
consoleTheme: new Theme({
bodyBgColor: Theme.Color.black,
bodyFgColor: Theme.Color.green,
buttonBgColor: Theme.Color.black,
buttonFgColor: Theme.Color.green,
buttonBorderColor: Theme.Color.green,
buttonSelectedBgColor: Theme.Color.darkRed,
pixelSelectedFgColor: Theme.Color.lightGreen,
pixelResizeBgColor: Theme.Color.lightGreen,
pixelCursorColor: Theme.Color.green,
pixelNormalFgColor: Theme.Color.green,
pixelJointNearBgColor: Theme.Color.lightGreen,
pixelJointBgColor: Theme.Color.red,
areaSelectionBgColor: Theme.Color.darkRed,
gridColor: Theme.Color.nearGreenBlack,
}),
};
constructor() {
this.setTheme(this.defaultTheme);
}
getTheme() {
return this.currentTheme.config;
}
static getPreferredSystemTheme() {
return matchMedia("(prefers-color-scheme: light)").matches ? "lightTheme" : "darkTheme";
}
setTheme(theme) {
localStorage.setItem("theme", theme);
if (theme === "systemTheme") {
theme = ThemeManager.getPreferredSystemTheme();
}
this.currentTheme = this.themes[theme];
}
renderTheme() {
layerManager.refresh(() => bodyComponent.renderTheme());
}
}
//////////////////
////// MODES /////
//////////////////
class ModeMaster {
constructor() {
this.callbacks = [];
this._modes = [];
this.setDefault();
}
registerCallback(func) {
this.callbacks.push(func);
}
setDefault() {
if (!this.hasAny()) this.reset("select");
}
modeChangedCallback() {
for (var func of this.callbacks) func();
}
makeFunc(instruction) {
// This just gives dispatchers a prettier notation, and
// restricts us from getting carried away with complicated mode conditions.
// If a condition can't be described by this notation, there's probably a cleaner
// implementation (e.g introducing another mode or making custom method on the ModeMaster).
// () => modeMaster.has("x", "y") becomes [modeMaster.has, "x", "y"]
return instruction.length ? instruction[0].bind(this, ...instruction.slice(1)) : () => true;
}
change(beforeMode, afterMode) {
let index = this._modes.indexOf(beforeMode);
if (index == -1) return;
this._modes[index] = afterMode;
this.modeChangedCallback();
}
toggle(mode) {
this.has(mode) ? this.remove(mode) : this.add(mode);
}
remove(...modes) {
modes.forEach(mode => {
let index = this._modes.indexOf(mode);
if (index == -1) return;
this._modes.splice(index, 1);
});
this.modeChangedCallback();
}
reset(...modes) {
this._modes = modes;
this.modeChangedCallback();
}
add(...modes) {
modes = modes.filter(mode => !this.has(mode));
this._modes = this._modes.concat(modes);
this.modeChangedCallback();
}
has(...modes) {
return modes.map(mode => this._modes.includes(mode)).every(Boolean);
}
hasAny() {
// This is useful to determine if Cascii itself is active (any modes are on).
// E.g if not, we shouldn't prevent default browser events by capturing ctrl commands.
return this._modes.length > 0;
}
hasOr(...modes) {
return modes.map(mode => this._modes.includes(mode)).some(Boolean);
}
is(...modes) {
return this._modes.toString() == modes.toString();
}
isDrawyMode(layerMode) {
// Returns for any draw-related mode (for a given layer).
return this.hasOr("draw", "drawing", "writing") && this.has(layerMode);
}
removeLayerModes() {
layerManager.getLayerTypes().forEach(name => this.remove(name));
this.remove("line");
this.remove("line-based");
}
getLayerType() {
for (let type of layerManager.getLayerTypes()) {
if (this.has(type)) return type;
}
}
setSelectedLayerMode(layer) {
this.removeLayerModes();
this.add(layer.getType());
// Rules for dynamic layer modes
if (layer.isLine()) this.add("line");
if (layer.isLineBased()) this.add("line-based");
}
}
////////////////
//// EVENTS ////
////////////////
class BaseExternalHookManager {
/*
This class should be overridden by optional dependencies
allowing upstream functionality for specific hooks coming from this core app.
E.g It is used to trigger server hooks for the server layer which,
by design, is optionally attached.
I want this file to open as an index.html and work out-of-the box,
with 0 dependencies on a server, packaging, etc.
*/
async getShortKeyUrl() {
// Without a server, we return an empty short key.
return "";
}
triggerDrawingChanged() {}
}
class EventDef {
constructor(modeCondition, modeUpdate, callback = () => {}) {
this.callback = callback;
this.condition = modeMaster.makeFunc(modeCondition);
this.update = modeMaster.makeFunc(modeUpdate);
}
run(event) {
if (this.condition()) {
this.update();
this.callback(event);
return true;
}
}
}
class EventManager {
MAP = {
document: {
keyEvents: {
keypress: {
"*": [new EventDef([modeMaster.has, "writing", "text"], [], TextLayer.keyDownEvent)],
},
keydown: {
[keyGroup(...ArrowKeyGroup)]: [
new EventDef([modeMaster.has, "selected"], [], event =>
layerManager.selectedArrowKeyDownEvent(event.key)
),
],
[["Shift"]]: [new EventDef([modeMaster.hasAny], [modeMaster.add, "shift"])],
[keyGroup("Backspace", "Delete")]: [
new EventDef([modeMaster.has, "selected"], [modeMaster.reset, "select"], () =>
layerManager.deleteLayersEvent()
),
],
[keyGroup("Escape")]: [
new EventDef([modeMaster.hasOr, "writing", "selected"], [modeMaster.reset, "select"], () =>
layerManager.unselectAll()
),
],
[keyGroup("Backspace", "Delete", ...ArrowKeyGroup)]: [
new EventDef([modeMaster.has, "writing", "text"], [], TextLayer.keyDownEvent),
],
[keyGroup("Control")]: [new EventDef([modeMaster.hasAny], [modeMaster.add, "ctrl"])],
[keyGroup("Z", "z")]: [
new EventDef([modeMaster.has, "shift", "ctrl"], [], event => layerManager.redoEvent(event)),
],
[keyGroup("z")]: [new EventDef([modeMaster.has, "ctrl"], [], event => layerManager.undoEvent(event))],
[keyGroup("c")]: [
new EventDef([modeMaster.has, "ctrl", "selected"], [], () => layerManager.copySelectedLayersEvent()),
],
[keyGroup("a")]: [
new EventDef([modeMaster.has, "ctrl"], [modeMaster.reset, "selected"], event =>
layerManager.selectAllEvent(event)
),
],
[keyGroup("g")]: [
new EventDef([modeMaster.has, "selected"], [], () => layerManager.groupSelectedLayersEvent()),
],
},
keyup: {
[keyGroup("Shift")]: [new EventDef([modeMaster.has, "shift"], [modeMaster.remove, "shift"])],
[keyGroup("Control")]: [new EventDef([modeMaster.has, "ctrl"], [modeMaster.remove, "ctrl"])],
},
},
},
window: {
mouseEvents: {
resize: [new EventDef([], [], event => canvas.scale())],
paste: [
new EventDef([modeMaster.has, "writing", "text"], [], event => layerManager.pasteToTextLayerEvent(event)),
new EventDef([modeMaster.hasAny], [], event => layerManager.pasteAsTextLayerEvent(event)),
],
// A mouseup should be detected beyond the canvas, so it's here instead.
mouseup: [
new EventDef([modeMaster.has, "drawing"], [modeMaster.change, "drawing", "draw"], event =>
layerManager.changeEvent(event)
),
new EventDef([modeMaster.has, "erasing"], [modeMaster.change, "erasing", "erase"]),
new EventDef([modeMaster.has, "moving"], [modeMaster.remove, "moving"], event =>
layerManager.changeEvent(event)
),
new EventDef([modeMaster.has, "area-selecting"], [modeMaster.remove, "area-selecting"], event =>
areaSelectManager.areaSelectingMouseUpEvent(event)
),
new EventDef([modeMaster.has, "resizing"], [modeMaster.remove, "resizing"], event =>
layerManager.changeEvent(event)
),
],
},
},
canvas: {
mouseEvents: {
mousedown: [
new EventDef(
[modeMaster.has, "draw", "text"],
[modeMaster.change, "draw", "writing"],
TextLayer.drawMouseDownEvent
),
new EventDef([modeMaster.has, "draw"], [modeMaster.change, "draw", "drawing"], Layer.drawMouseDownEvent),
new EventDef([modeMaster.has, "writing", "text"], [], TextLayer.writingMouseDownEvent),
new EventDef([modeMaster.has, "erase"], [modeMaster.change, "erase", "erasing"], event =>
layerManager.erasePixelEvent(event)
),
new EventDef([modeMaster.hasOr, "selected", "select"], [], Layer.selectMouseDownEvent),
],
mouseover: [
new EventDef(
[modeMaster.has, "draw", "line"], // Technically this should be for any joiner layer...
[],
BaseLineLayer.drawMouseOver
),
new EventDef([modeMaster.has, "draw"], [], Layer.drawMouseOver),
new EventDef([modeMaster.has, "drawing"], [], Layer.drawingMouseOverEvent),
new EventDef([modeMaster.has, "erasing"], [], event => layerManager.erasePixelEvent(event)),
new EventDef([modeMaster.has, "area-selecting"], [], event =>
areaSelectManager.areaSelectingMouseOverEvent(event)
),
new EventDef([modeMaster.has, "moving"], [], event => layerManager.movingMouseOverEvent(event)),
new EventDef([modeMaster.has, "resizing"], [], event => layerManager.resizingMouseOverEvent(event)),
new EventDef([modeMaster.hasOr, "selected", "select"], [], event =>
layerManager.selectMouseOverEvent(event)
),
],
dblclick: [
new EventDef(
[modeMaster.has, "selected", "text"],
[modeMaster.change, "selected", "writing"],
TextLayer.selectedDoubleClickEvent
),
new EventDef([modeMaster.has, "writing"], [], TextLayer.selectedDoubleClickEvent),
],
},
},
};
assignMouseEventDefs(element, allDefs) {
for (const [eventType, defs] of Object.entries(allDefs)) {
element.addEventListener(eventType, event => {
for (var def of defs) if (def.run(event)) return;
});
}
}
assignKeyEventDefs(element, defs) {
Object.keys(defs).forEach(eventType => {
element.addEventListener(eventType, event => {
// This maps apple Command key to Ctrl.
var eventKey = event.key == "Meta" ? "Control" : event.key;
for (var keys in defs[eventType]) {
for (let key of keys.split(",")) {
if (key == eventKey || key == "*") {
for (var def of defs[eventType][keys]) {
if (def.run(event)) return;
}
}
}
}
});
});
}
assignAll(namedElements) {
for (const [elementName, eventGroups] of Object.entries(this.MAP)) {
for (const [eventGroup, eventDefs] of Object.entries(eventGroups)) {
switch (eventGroup) {
case "mouseEvents":
this.assignMouseEventDefs(namedElements[elementName], eventDefs);
break;
case "keyEvents":
this.assignKeyEventDefs(namedElements[elementName], eventDefs);
break;
}
}
}
}
}
///////////////
//// CHARS ////
///////////////
class CharManager {
// Useful: https://www.w3.org/TR/xml-entity-names/025.html
// And: https://www.amp-what.com/unicode/search/dot
charset = {
// Dotted lines
"•": ["dotted", "line", "vertical", "lateral", "corner", "generic", "unicode"],
".": ["dotted", "line", "vertical", "lateral", "corner", "generic", "ascii"],
// Solid lines
"━": ["solid-bold", "line", "lateral", "unicode"],
"┃": ["solid-bold", "line", "vertical", "unicode"],
"|": ["solid-thin", "solid-rounded", "solid-bold", "line", "