forks
/
arsd
mirror of https://github.com/adamdruppe/arsd.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

random fixes

This commit is contained in:
Adam D. Ruppe 2021-02-01 21:35:56 -05:00
parent 16975aba4c
commit a8ec499f2b
6 changed files with 810 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
jni.d
View File

@ -2513,7 +2513,7 @@ union jvalue
}
/*
Copyright 2019-2020, Adam D. Ruppe.
Copyright 2019-2021, Adam D. Ruppe.
Boost license. or whatever.
Most work done in December 2019.
*/

2
minigui.d
View File

@ -2276,7 +2276,7 @@ class ListWidget : ListWidgetBase {
switch(code) {
case LBN_SELCHANGE:
auto sel = SendMessageW(hwnd, LB_GETCURSEL, 0, 0);
setSelection(sel);
setSelection(cast(int) sel);
break;
default:
}

7
mysql.d
View File

@ -648,6 +648,11 @@ struct Statement
}
}
void reset()
{
mysql_stmt_reset(statement);
}
private:
MYSQL_STMT* statement;
MYSQL_BIND[] params;
@ -656,7 +661,7 @@ private:
Statement* prepare(MySql m, string query) @trusted
{
MYSQL_STMT* s = m.getHandle.mysql_stmt_init();
immutable x = s.mysql_stmt_prepare(query.toStringz, query.length);
immutable x = s.mysql_stmt_prepare(query.toStringz, cast(int) query.length);
if (x != 0)
{

562
simpledisplay.d
View File

@ -6990,6 +6990,18 @@ class OperatingSystemFont {
load(name, size, weight, italic);
}
/++
Constructs the object, but does nothing. Call one of [load] or [loadDefault] to populate the object.
You can also call the platform-specific [loadXft], [loadCoreX], or [loadWin32] functions if appropriate for you.
History:
Added January 24, 2021.
+/
this() {
// this space intentionally left blank
}
/++
Loads specifically with the Xft library - a freetype font from a fontconfig string.
@ -7039,12 +7051,17 @@ class OperatingSystemFont {
this.isXft = true;
if(xftFont !is null)
if(xftFont !is null) {
isMonospace_ = stringWidth("x") == stringWidth("M");
ascent_ = xftFont.ascent;
descent_ = xftFont.descent;
}
return !isNull();
}
// see also: XftLockFace(font) which gives a FT_Face. from /usr/include/X11/Xft/Xft.h line 352
private string weightToString(FontWeight weight) {
with(FontWeight)
final switch(weight) {
@ -7100,12 +7117,20 @@ class OperatingSystemFont {
char* lol3;
fontset = XCreateFontSet(display, xfontstr.ptr, &lol, &lol2, &lol3);
if(font !is null)
isMonospace_ = stringWidth("l") == stringWidth("M");
prepareFontInfo();
return !isNull();
}
version(X11)
private void prepareFontInfo() {
if(font !is null) {
isMonospace_ = stringWidth("l") == stringWidth("M");
ascent_ = font.max_bounds.ascent;
descent_ = font.max_bounds.descent;
}
}
/++
Loads a Windows font. You probably want to use [load] instead to be more generic.
@ -7113,24 +7138,36 @@ class OperatingSystemFont {
Added November 13, 2020. Before then, this code was integrated in the [load] function.
+/
version(Windows)
bool loadWin32(string name, int size = 0, FontWeight weight = FontWeight.dontcare, bool italic = false) {
bool loadWin32(string name, int size = 0, FontWeight weight = FontWeight.dontcare, bool italic = false, HDC hdc = null) {
unload();
WCharzBuffer buffer = WCharzBuffer(name);
font = CreateFont(size, 0, 0, 0, cast(int) weight, italic, 0, 0, 0, 0, 0, 0, 0, buffer.ptr);
prepareFontInfo(hdc);
return !isNull();
}
version(Windows)
void prepareFontInfo(HDC hdc = null) {
if(font is null)
return;
TEXTMETRIC tm;
auto dc = GetDC(null);
SelectObject(dc, font);
auto dc = hdc ? hdc : GetDC(null);
auto orig = SelectObject(dc, font);
GetTextMetrics(dc, &tm);
ReleaseDC(null, dc);
SelectObject(dc, orig);
if(hdc is null)
ReleaseDC(null, dc);
width_ = tm.tmAveCharWidth;
height_ = tm.tmHeight;
ascent_ = tm.tmAscent;
descent_ = tm.tmDescent;
// If this bit is set the font is a variable pitch font. If this bit is clear the font is a fixed pitch font. Note very carefully that those meanings are the opposite of what the constant name implies.
isMonospace_ = (tm.tmPitchAndFamily & TMPF_FIXED_PITCH) == 0;
return !isNull();
}
@ -7246,7 +7283,8 @@ class OperatingSystemFont {
History:
Added January 16, 2021
+/
int stringWidth(string s, SimpleWindow window = null) {
int stringWidth(scope const(char)[] s, SimpleWindow window = null) {
// FIXME: what about tab?
if(isNull)
return 0;
@ -7272,19 +7310,77 @@ class OperatingSystemFont {
} else version(Windows) {
WCharzBuffer buffer = WCharzBuffer(s);
SIZE size;
auto dc = GetDC(window is null ? null : window.impl.hwnd);
SelectObject(dc, font);
GetTextExtentPoint32W(dc, buffer.ptr, cast(int) buffer.length, &size);
ReleaseDC(null, dc);
return size.cx;
return stringWidth(buffer.slice, window);
}
else assert(0);
}
version(Windows)
/// ditto
int stringWidth(scope const(wchar)[] s, SimpleWindow window = null) {
if(isNull)
return 0;
version(Windows) {
SIZE size;
prepareContext(window);
scope(exit) releaseContext();
GetTextExtentPoint32W(dc, s.ptr, cast(int) s.length, &size);
return size.cx;
} else {
// std.conv can do this easily but it is slow to import and i don't think it is worth it
static assert(0, "not implemented yet");
//return stringWidth(s, window);
}
}
private {
int prepRefcount;
version(Windows) {
HDC dc;
HANDLE orig;
HWND hwnd;
}
}
/++
[stringWidth] can be slow. This helps speed it up if you are doing a lot of calculations. Just prepareContext when you start this work and releaseContext when you are done. Important to release before too long though as it can be a scarce system resource.
History:
Added January 23, 2021
+/
void prepareContext(SimpleWindow window = null) {
prepRefcount++;
if(prepRefcount == 1) {
version(Windows) {
hwnd = window is null ? null : window.impl.hwnd;
dc = GetDC(hwnd);
orig = SelectObject(dc, font);
}
}
}
/// ditto
void releaseContext() {
prepRefcount--;
if(prepRefcount == 0) {
version(Windows) {
SelectObject(dc, orig);
ReleaseDC(hwnd, dc);
hwnd = null;
dc = null;
orig = null;
}
}
}
/+
FIXME: I think I need advance and kerning pair
int advance(dchar from, dchar to) { } // use dchar.init for first item in string
+/
/++
Returns the height of the font.
@ -7305,9 +7401,63 @@ class OperatingSystemFont {
else assert(0);
}
/// FIXME not implemented
void loadDefault() {
private int ascent_;
private int descent_;
/++
Max ascent above the baseline.
History:
Added January 22, 2021
+/
int ascent() {
return ascent_;
}
/++
Max descent below the baseline.
History:
Added January 22, 2021
+/
int descent() {
return descent_;
}
/++
Loads the default font used by [ScreenPainter] if none others are loaded.
Returns:
This method mutates the `this` object, but then returns `this` for
easy chaining like:
---
auto font = foo.isNull ? foo : foo.loadDefault
---
History:
Added previously, but left unimplemented until January 24, 2021.
+/
OperatingSystemFont loadDefault() {
unload();
version(X11) {
// another option would be https://tronche.com/gui/x/xlib/graphics/font-metrics/XQueryFont.html
// but meh since sdpy does its own thing, this should be ok too
ScreenPainterImplementation.ensureDefaultFontLoaded();
this.font = ScreenPainterImplementation.defaultfont;
this.fontset = ScreenPainterImplementation.defaultfontset;
prepareFontInfo();
} else version(Windows) {
ScreenPainterImplementation.ensureDefaultFontLoaded();
this.font = ScreenPainterImplementation.defaultGuiFont;
prepareFontInfo();
} else throw new NotYetImplementedException();
return this;
}
///
@ -7329,7 +7479,6 @@ class OperatingSystemFont {
what happens when I draw the full string with the OS functions.
subclasses might do the same thing while getting the glyphs on images
+/
struct GlyphInfo {
int glyph;
@ -7343,6 +7492,7 @@ class OperatingSystemFont {
return null;
}
+/
~this() {
unload();
@ -7627,6 +7777,18 @@ struct ScreenPainter {
font.drawString(this, upperLeft, text);
}
version(Windows)
void drawText(Point upperLeft, scope const(wchar)[] text) {
if(impl is null) return;
if(isClipped(upperLeft, Point(int.max, int.max))) return;
transform(upperLeft);
if(text.length && text[$-1] == '\n')
text = text[0 .. $-1]; // tailing newlines are weird on windows...
TextOutW(impl.hdc, upperLeft.x, upperLeft.y, text.ptr, cast(int) text.length);
}
static struct TextDrawingContext {
Point boundingBoxUpperLeft;
Point boundingBoxLowerRight;
@ -8972,7 +9134,16 @@ version(Windows) {
// X doesn't draw a text background, so neither should we
SetBkMode(hdc, TRANSPARENT);
ensureDefaultFontLoaded();
if(defaultGuiFont) {
SelectObject(hdc, defaultGuiFont);
// DeleteObject(defaultGuiFont);
}
}
static HFONT defaultGuiFont;
static void ensureDefaultFontLoaded() {
static bool triedDefaultGuiFont = false;
if(!triedDefaultGuiFont) {
NONCLIENTMETRICS params;
@ -8982,15 +9153,8 @@ version(Windows) {
}
triedDefaultGuiFont = true;
}
if(defaultGuiFont) {
SelectObject(hdc, defaultGuiFont);
// DeleteObject(defaultGuiFont);
}
}
static HFONT defaultGuiFont;
void setFont(OperatingSystemFont font) {
if(font && font.font) {
if(SelectObject(hdc, font.font) == HGDI_ERROR) {
@ -10101,8 +10265,20 @@ version(X11) {
XCopyGC(display, dgc, 0xffffffff, this.gc);
ensureDefaultFontLoaded();
font = defaultfont;
fontset = defaultfontset;
if(font) {
XSetFont(display, gc, font.fid);
}
}
static void ensureDefaultFontLoaded() {
if(!fontAttempted) {
font = XLoadQueryFont(display, xfontstr.ptr);
auto display = XDisplayConnection.get;
auto font = XLoadQueryFont(display, xfontstr.ptr);
// if the user font choice fails, fixed is pretty reliable (required by X to start!) and not bad either
if(font is null)
font = XLoadQueryFont(display, "-*-fixed-medium-r-*-*-13-*-*-*-*-*-*-*".ptr);
@ -10110,20 +10286,13 @@ version(X11) {
char** lol;
int lol2;
char* lol3;
fontset = XCreateFontSet(display, xfontstr.ptr, &lol, &lol2, &lol3);
auto fontset = XCreateFontSet(display, xfontstr.ptr, &lol, &lol2, &lol3);
fontAttempted = true;
defaultfont = font;
defaultfontset = fontset;
}
font = defaultfont;
fontset = defaultfontset;
if(font) {
XSetFont(display, gc, font.fid);
}
}
arsd.color.Rectangle _clipRectangle;
@ -15982,7 +16151,7 @@ version(X11) {
}
}
mixin template ExperimentalTextComponent2() {
class ExperimentalTextComponent2 {
/+
Stage 1: get it working monospace
Stage 2: use proportional font
@ -15994,6 +16163,321 @@ mixin template ExperimentalTextComponent2() {
Stage 8: justification
Stage 9: editing, selection, etc.
+/
/++
It asks for a window so it can translate abstract font sizes to actual on-screen values depending on the window's current dpi, scaling settings, etc.
+/
this(SimpleWindow window) {
this.window = window;
}
private SimpleWindow window;
/++
When you render a [ComponentInFlow], it returns an arbitrary number of these interfaces
representing the internal parts. The first pass is focused on the x parameter, then the
renderer is responsible for going back to the parts in the current line and calling
adjustDownForAscent to change the y params.
+/
static interface ComponentRenderHelper {
void adjustDownForAscent(int amount); // at the end of the line it needs to do these
int ascent() const;
int descent() const;
int advance() const;
bool endsWithExplititLineBreak() const;
}
static interface RenderResult {
/++
This is responsible for using what space is left (your object is responsible for keeping its own state after getting it updated from [repositionForNextLine]) and not going over if at all possible. If you can word wrap, you should when space is out. Otherwise, you can keep going if it means overflow hidden or scroll.
+/
void popFront();
@property bool empty() const;
@property ComponentRenderHelper front() const;
void repositionForNextLine(Point baseline, int availableWidth);
}
static interface ComponentInFlow {
void draw(ScreenPainter painter);
//RenderResult render(Point baseline, int availableWidth); // FIXME: it needs to be able to say "my cache is good, nothing different"
bool startsWithExplicitLineBreak() const;
}
static class TextFlowComponent : ComponentInFlow {
bool startsWithExplicitLineBreak() const { return false; } // FIXME: if it is block this can return true
Color foreground;
Color background;
OperatingSystemFont font; // should NEVER be null
ubyte attributes; // underline, strike through, display on new block
version(Windows)
const(wchar)[] content;
else
const(char)[] content; // this should NEVER have a newline, except at the end
RenderedComponent[] rendered; // entirely controlled by [rerender]
// could prolly put some spacing around it too like margin / padding
this(Color f, Color b, OperatingSystemFont font, ubyte attr, const(char)[] c)
in { assert(font !is null);
assert(!font.isNull); }
body
{
this.foreground = f;
this.background = b;
this.font = font;
this.attributes = attr;
version(Windows) {
auto conversionFlags = 0;//WindowsStringConversionFlags.convertNewLines;
auto sz = sizeOfConvertedWstring(c, conversionFlags);
auto buffer = new wchar[](sz);
this.content = makeWindowsString(c, buffer, conversionFlags);
} else {
this.content = c.dup;
}
}
void draw(ScreenPainter painter) {
painter.setFont(this.font);
painter.outlineColor = this.foreground;
painter.fillColor = Color.transparent;
foreach(rendered; this.rendered) {
// the component works in term of baseline,
// but the painter works in term of upper left bounding box
// so need to translate that
if(this.background.a) {
painter.fillColor = this.background;
painter.outlineColor = this.background;
painter.drawRectangle(Point(rendered.startX, rendered.startY - this.font.ascent), Size(rendered.width, this.font.height));
painter.outlineColor = this.foreground;
painter.fillColor = Color.transparent;
}
painter.drawText(Point(rendered.startX, rendered.startY - this.font.ascent), rendered.slice);
// FIXME: strike through, underline, highlight selection, etc.
}
}
}
// I could split the parts into words on render
// for easier word-wrap, each one being an unbreakable "inline-block"
private TextFlowComponent[] parts;
private int needsRerenderFrom;
void addPart(Color f, Color b, OperatingSystemFont font, ubyte attr, const(char)[] c) {
// FIXME: needsRerenderFrom. Basically if the bounding box and baseline is the same as the previous thing, it can prolly just stop.
parts ~= new TextFlowComponent(f, b, font, attr, c);
}
static struct RenderedComponent {
int startX;
int startY;
short width;
// height is always from the containing part's font. This saves some space and means recalculations need not continue past the current line, unless a new part is added with a different font!
// for individual chars in here you've gotta process on demand
version(Windows)
const(wchar)[] slice;
else
const(char)[] slice;
}
void rerender(Rectangle boundingBox) {
Point baseline = boundingBox.upperLeft;
this.boundingBox.left = boundingBox.left;
this.boundingBox.top = boundingBox.top;
auto remainingParts = parts;
int largestX;
foreach(part; parts)
part.font.prepareContext(window);
scope(exit)
foreach(part; parts)
part.font.releaseContext();
calculateNextLine:
int nextLineHeight = 0;
int nextBiggestDescent = 0;
foreach(part; remainingParts) {
auto height = part.font.ascent;
if(height > nextLineHeight)
nextLineHeight = height;
if(part.font.descent > nextBiggestDescent)
nextBiggestDescent = part.font.descent;
if(part.content.length && part.content[$-1] == '\n')
break;
}
baseline.y += nextLineHeight;
auto lineStart = baseline;
while(remainingParts.length) {
remainingParts[0].rendered = null;
bool eol;
if(remainingParts[0].content.length && remainingParts[0].content[$-1] == '\n')
eol = true;
// FIXME: word wrap
auto font = remainingParts[0].font;
auto slice = remainingParts[0].content[0 .. $ - (eol ? 1 : 0)];
auto width = font.stringWidth(slice, window);
remainingParts[0].rendered ~= RenderedComponent(baseline.x, baseline.y, cast(short) width, slice);
remainingParts = remainingParts[1 .. $];
baseline.x += width;
if(eol) {
baseline.y += nextBiggestDescent;
if(baseline.x > largestX)
largestX = baseline.x;
baseline.x = lineStart.x;
goto calculateNextLine;
}
}
if(baseline.x > largestX)
largestX = baseline.x;
this.boundingBox.right = largestX;
this.boundingBox.bottom = baseline.y;
}
// you must call rerender first!
void draw(ScreenPainter painter) {
foreach(part; parts) {
part.draw(painter);
}
}
struct IdentifyResult {
TextFlowComponent part;
int charIndexInPart;
int totalCharIndex = -1; // if this is -1, it just means the end
Rectangle boundingBox;
}
IdentifyResult identify(Point pt, bool exact = false) {
if(parts.length == 0)
return IdentifyResult(null, 0);
if(pt.y < boundingBox.top) {
if(exact)
return IdentifyResult(null, 1);
return IdentifyResult(parts[0], 0);
}
if(pt.y > boundingBox.bottom) {
if(exact)
return IdentifyResult(null, 2);
return IdentifyResult(parts[$-1], cast(int) parts[$-1].content.length);
}
int tci = 0;
// I should probably like binary search this or something...
foreach(ref part; parts) {
foreach(rendered; part.rendered) {
auto rect = Rectangle(rendered.startX, rendered.startY - part.font.ascent, rendered.startX + rendered.width, rendered.startY + part.font.descent);
if(rect.contains(pt)) {
auto x = pt.x - rendered.startX;
auto estimatedIdx = x / part.font.averageWidth;
if(estimatedIdx < 0)
estimatedIdx = 0;
if(estimatedIdx > rendered.slice.length)
estimatedIdx = cast(int) rendered.slice.length;
int idx;
int x1, x2;
if(part.font.isMonospace) {
auto w = part.font.averageWidth;
if(!exact && x > (estimatedIdx + 1) * w)
return IdentifyResult(null, 4);
idx = estimatedIdx;
x1 = idx * w;
x2 = (idx + 1) * w;
} else {
idx = estimatedIdx;
part.font.prepareContext(window);
scope(exit) part.font.releaseContext();
// int iterations;
while(true) {
// iterations++;
x1 = idx ? part.font.stringWidth(rendered.slice[0 .. idx - 1]) : 0;
x2 = part.font.stringWidth(rendered.slice[0 .. idx]); // should be the maximum since `averageWidth` kinda lies.
x1 += rendered.startX;
x2 += rendered.startX;
if(pt.x < x1) {
if(idx == 0) {
if(exact)
return IdentifyResult(null, 6);
else
break;
}
idx--;
} else if(pt.x > x2) {
idx++;
if(idx > rendered.slice.length) {
if(exact)
return IdentifyResult(null, 5);
else
break;
}
} else if(pt.x >= x1 && pt.x <= x2) {
if(idx)
idx--; // point it at the original index
break; // we fit
}
}
// import std.stdio; writeln(iterations)
}
return IdentifyResult(part, idx, tci + idx, Rectangle(x1, rect.top, x2, rect.bottom)); // FIXME: utf-8?
}
}
tci += cast(int) part.content.length; // FIXME: utf-8?
}
return IdentifyResult(null, 3);
}
Rectangle boundingBox; // only set after [rerender]
// text will be positioned around the exclusion zone
static struct ExclusionZone {
}
ExclusionZone[] exclusionZones;
}

306
terminal.d
View File

@ -4335,7 +4335,7 @@ class LineGetter {
/// Call this before letting LineGetter die so it can do any necessary
/// cleanup and save the updated history to a file.
void dispose() {
if(historyFilename.length)
if(historyFilename.length && historyCommitMode == HistoryCommitMode.atTermination)
saveSettingsAndHistoryToFile();
}
@ -4414,12 +4414,38 @@ class LineGetter {
return candidate;
}
/// You may override this to do nothing
/++
History is normally only committed to the file when the program is
terminating, but if you are losing data due to crashes, you might want
to change this to `historyCommitMode = HistoryCommitMode.afterEachLine;`.
History:
Added January 26, 2021 (version 9.2)
+/
public enum HistoryCommitMode {
/// The history file is written to disk only at disposal time by calling [saveSettingsAndHistoryToFile]
atTermination,
/// The history file is written to disk after each line of input by calling [appendHistoryToFile]
afterEachLine
}
/// ditto
public HistoryCommitMode historyCommitMode;
/++
You may override this to do nothing. If so, you should
also override [appendHistoryToFile] if you ever change
[historyCommitMode].
You should call [historyPath] to get the proper filename.
+/
/* virtual */ void saveSettingsAndHistoryToFile() {
import std.file;
if(!exists(historyFileDirectory))
mkdir(historyFileDirectory);
mkdirRecurse(historyFileDirectory);
auto fn = historyPath();
import std.stdio;
auto file = File(fn, "wb");
file.write("// getline history file\r\n");
@ -4427,6 +4453,30 @@ class LineGetter {
file.writeln(item, "\r");
}
/++
If [historyCommitMode] is [HistoryCommitMode.afterEachLine],
this line is called after each line to append to the file instead
of [saveSettingsAndHistoryToFile].
Use [historyPath] to get the proper full path.
History:
Added January 26, 2021 (version 9.2)
+/
/* virtual */ void appendHistoryToFile(string item) {
import std.file;
if(!exists(historyFileDirectory))
mkdirRecurse(historyFileDirectory);
// this isn't exactly atomic but meh tbh i don't care.
auto fn = historyPath();
if(exists(fn)) {
append(fn, item ~ "\r\n");
} else {
std.file.write(fn, "// getline history file\r\n" ~ item ~ "\r\n");
}
}
/// You may override this to do nothing
/* virtual */ void loadSettingsAndHistoryFromFile() {
import std.file;
@ -4669,7 +4719,7 @@ class LineGetter {
Introduced on January 30, 2020
+/
protected string helpMessage() {
return "Press F2 to edit current line in your editor. F3 searches. F9 runs current line while maintaining current edit state.";
return "Press F2 to edit current line in your external editor. F3 searches history. F9 runs current line while maintaining current edit state.";
}
/++
@ -4819,6 +4869,77 @@ class LineGetter {
+/
HistoryRecallFilterMethod historyRecallFilterMethod = HistoryRecallFilterMethod.chronological;
/++
Enables automatic closing of brackets like (, {, and [ when the user types.
Specifically, you subclass and return a string of the completions you want to
do, so for that set, return `"()[]{}"`
$(WARNING
If you subclass this and return anything other than `null`, your subclass must also
realize that the `line` member and everything that slices it ([tabComplete] and more)
need to mask away the extra bits to get the original content. See [PRIVATE_BITS_MASK].
`line[] &= cast(dchar) ~PRIVATE_BITS_MASK;`
)
Returns:
A string with pairs of characters. When the user types the character in an even-numbered
position, it automatically inserts the following character after the cursor (without moving
the cursor). The inserted character will be automatically overstriken if the user types it
again.
The default is `return null`, which disables the feature.
History:
Added January 25, 2021 (version 9.2)
+/
protected string enableAutoCloseBrackets() {
return null;
}
/++
If [enableAutoCloseBrackets] does not return null, you should ignore these bits in the line.
+/
protected enum PRIVATE_BITS_MASK = 0x80_00_00_00;
// note: several instances in the code of PRIVATE_BITS_MASK are kinda conservative; masking it away is destructive
// but less so than crashing cuz of invalid unicode character popping up later. Besides the main intention is when
// you are kinda immediately typing so it forgetting is probably fine.
/++
Subclasses that implement this function can enable syntax highlighting in the line as you edit it.
The library will call this when it prepares to draw the line, giving you the full line as well as the
current position in that array it is about to draw. You return a [SyntaxHighlightMatch]
object with its `charsMatched` member set to how many characters the given colors should apply to.
If it is set to zero, default behavior is retained for the next character, and [syntaxHighlightMatch]
will be called again immediately. If it is set to -1 syntax highlighting is disabled for the rest of
the line. If set to int.max, it will apply to the remainder of the line.
If it is set to another positive value, the given colors are applied for that number of characters and
[syntaxHighlightMatch] will NOT be called again until those characters are consumed.
Note that the first call may have `currentDrawPosition` be greater than zero due to horizontal scrolling.
After that though, it will be called based on your `charsMatched` in the return value.
`currentCursorPosition` is passed in case you want to do things like highlight a matching parenthesis over
the cursor or similar. You can also simply ignore it.
History:
Added January 25, 2021 (version 9.2)
+/
protected SyntaxHighlightMatch syntaxHighlightMatch(in dchar[] line, in size_t currentDrawPosition, in size_t currentCursorPosition) {
return SyntaxHighlightMatch(-1); // -1 just means syntax highlighting is disabled and it shouldn't try again
}
/// ditto
static struct SyntaxHighlightMatch {
int charsMatched = 0;
Color foreground = Color.DEFAULT;
Color background = Color.DEFAULT;
}
private int currentHistoryViewPosition = 0;
private dchar[] uncommittedHistoryCandidate;
private int uncommitedHistoryCursorPosition;
@ -5111,10 +5232,27 @@ class LineGetter {
int written;
int lineLength;
Color currentFg_ = Color.DEFAULT;
Color currentBg_ = Color.DEFAULT;
int colorChars = 0;
Color currentFg() {
if(colorChars <= 0 || currentFg_ == Color.DEFAULT)
return lg.regularForeground;
return currentFg_;
}
Color currentBg() {
if(colorChars <= 0 || currentBg_ == Color.DEFAULT)
return lg.background;
return currentBg_;
}
void specialChar(char c) {
lg.terminal.color(lg.regularForeground, lg.specialCharBackground);
lg.terminal.write(c);
lg.terminal.color(lg.regularForeground, lg.background);
lg.terminal.color(currentFg, currentBg);
written++;
lineLength--;
@ -5131,19 +5269,32 @@ class LineGetter {
lineLength--;
}
void drawContent(T)(T towrite, int highlightBegin = 0, int highlightEnd = 0, bool inverted = false) {
void drawContent(T)(T towrite, int highlightBegin = 0, int highlightEnd = 0, bool inverted = false, int lineidx = -1) {
// FIXME: if there is a color at the end of the line it messes up as you scroll
// FIXME: need a way to go to multi-line editing
bool highlightOn = false;
void highlightOff() {
lg.terminal.color(lg.regularForeground, lg.background, ForceOption.automatic, inverted);
lg.terminal.color(currentFg, currentBg, ForceOption.automatic, inverted);
highlightOn = false;
}
foreach(idx, dchar ch; towrite) {
if(lineLength <= 0)
break;
static if(is(T == dchar[])) {
if(lineidx != -1 && colorChars == 0) {
auto shm = lg.syntaxHighlightMatch(lg.line, lineidx + idx, lg.cursorPosition);
if(shm.charsMatched > 0) {
colorChars = shm.charsMatched;
currentFg_ = shm.foreground;
currentBg_ = shm.background;
lg.terminal.color(currentFg, currentBg);
}
}
}
switch(ch) {
case '\n': specialChar('n'); break;
case '\r': specialChar('r'); break;
@ -5162,7 +5313,13 @@ class LineGetter {
}
}
regularChar(ch);
regularChar(ch & ~PRIVATE_BITS_MASK);
}
if(colorChars > 0) {
colorChars--;
if(colorChars == 0)
lg.terminal.color(currentFg, currentBg);
}
}
if(highlightOn)
@ -5191,6 +5348,7 @@ class LineGetter {
}
terminal.moveTo(startOfLineX + cdi.cursorPositionToDrawX + promptLength, startOfLineY + cdi.cursorPositionToDrawY);
endRedraw(); // make sure the cursor is turned back on
}
static struct CoreRedrawInfo {
@ -5200,23 +5358,29 @@ class LineGetter {
int cursorPositionToDrawY;
}
private void endRedraw() {
version(Win32Console) {
// on Windows, we want to make sure all
// is displayed before the cursor jumps around
terminal.flush();
terminal.showCursor();
} else {
// but elsewhere, the showCursor is itself buffered,
// so we can do it all at once for a slight speed boost
terminal.showCursor();
//import std.string; import std.stdio; writeln(terminal.writeBuffer.replace("\033", "\\e"));
terminal.flush();
}
}
final CoreRedrawInfo coreRedraw() {
if(supplementalGetter)
return CoreRedrawInfo.init; // the supplementalGetter will be drawing instead...
terminal.hideCursor();
scope(exit) {
version(Win32Console) {
// on Windows, we want to make sure all
// is displayed before the cursor jumps around
terminal.flush();
terminal.showCursor();
} else {
// but elsewhere, the showCursor is itself buffered,
// so we can do it all at once for a slight speed boost
terminal.showCursor();
//import std.string; import std.stdio; writeln(terminal.writeBuffer.replace("\033", "\\e"));
terminal.flush();
}
scope(failure) {
// don't want to leave the cursor hidden on the event of an exception
// can't just scope(success) it here since the cursor will be seen bouncing when finalizeRedraw is run
endRedraw();
}
terminal.moveTo(startOfLineX, startOfLineY);
@ -5247,7 +5411,7 @@ class LineGetter {
terminal.color(regularForeground, background);
drawer.drawContent(afterSelection);
} else {
drawer.drawContent(towrite);
drawer.drawContent(towrite, 0, 0, false, horizontalScrollPosition);
}
string suggestion;
@ -5546,6 +5710,7 @@ class LineGetter {
if(selectionStart == selectionEnd)
return null;
import std.conv;
line[] &= cast(dchar) ~PRIVATE_BITS_MASK;
return to!string(line[selectionStart .. selectionEnd]);
}
}
@ -5596,14 +5761,15 @@ class LineGetter {
/* Insert the character (unless it is backspace, tab, or some other control char) */
auto ch = ev.which;
switch(ch) {
version(Windows) case 'z', 26: // and this is really for Windows
if(!(ev.modifierState & ModifierState.control))
goto default;
goto case;
case KeyboardEvent.ProprietaryPseudoKeys.SelectNone:
selectNone();
redraw();
break;
version(Windows) case 'z', 26: { // and this is really for Windows
if(!(ev.modifierState & ModifierState.control))
goto default;
goto case;
}
case 'd', 4: // ctrl+d will also send a newline-equivalent
if(ev.modifierState & ModifierState.alt) {
// gnu alias for kill word (also on ctrl+backspace)
@ -5641,6 +5807,11 @@ class LineGetter {
break;
}
// I want to hide the private bits from the other functions, but retain them across completions,
// which is why it does it on a copy here. Could probably be more efficient, but meh.
auto line = this.line.dup;
line[] &= cast(dchar) ~PRIVATE_BITS_MASK;
auto relevantLineSection = line[0 .. cursorPosition];
auto start = tabCompleteStartPoint(relevantLineSection, line[cursorPosition .. $]);
relevantLineSection = relevantLineSection[start .. $];
@ -5717,6 +5888,7 @@ class LineGetter {
break;
case KeyboardEvent.Key.F2:
justHitTab = justKilled = false;
line[] &= cast(dchar) ~PRIVATE_BITS_MASK;
auto got = editLineInEditor(line, cursorPosition);
if(got !is null) {
line = got;
@ -5728,6 +5900,17 @@ class LineGetter {
redraw();
}
break;
case 'l', 12:
if(!(ev.modifierState & ModifierState.control))
goto default;
goto case;
case KeyboardEvent.Key.F5:
// FIXME: I might not want to do this on full screen programs,
// but arguably the application should just hook the event then.
terminal.clear();
updateCursorPosition();
redraw();
break;
case 'r', 18:
if(!(ev.modifierState & ModifierState.control))
goto default;
@ -5736,6 +5919,7 @@ class LineGetter {
justHitTab = justKilled = false;
// search in history
// FIXME: what about search in completion too?
line[] &= cast(dchar) ~PRIVATE_BITS_MASK;
supplementalGetter = new HistorySearchLineGetter(this);
supplementalGetter.startGettingLine();
supplementalGetter.redraw();
@ -5764,8 +5948,9 @@ class LineGetter {
goto default;
justHitTab = justKilled = false;
// FIXME: would be cool if this worked with quotes and such too
// FIXME: in insert mode prolly makes sense to look at the position before the cursor tbh
if(cursorPosition >= 0 && cursorPosition < line.length) {
dchar at = line[cursorPosition];
dchar at = line[cursorPosition] & ~PRIVATE_BITS_MASK;
int direction;
dchar lookFor;
switch(at) {
@ -5781,9 +5966,10 @@ class LineGetter {
int pos = cursorPosition;
int count;
while(pos >= 0 && pos < line.length) {
if(line[pos] == at)
auto lp = line[pos] & ~PRIVATE_BITS_MASK;
if(lp == at)
count++;
if(line[pos] == lookFor)
if(lp == lookFor)
count--;
if(count == 0) {
cursorPosition = pos;
@ -5881,8 +6067,7 @@ class LineGetter {
if(ev.modifierState & ModifierState.shift) {
// ctrl+shift+a will select all...
// for now I will have it just copy to clipboard but later once I get the time to implement full selection handling, I'll change it
import std.conv;
terminal.requestCopyToClipboard(to!string(line));
terminal.requestCopyToClipboard(lineAsString());
break;
}
goto case;
@ -5970,8 +6155,38 @@ class LineGetter {
break;
default:
justHitTab = justKilled = false;
if(e.keyboardEvent.isCharacter)
if(e.keyboardEvent.isCharacter) {
// overstrike an auto-inserted thing if that's right there
if(cursorPosition < line.length)
if(line[cursorPosition] & PRIVATE_BITS_MASK) {
if((line[cursorPosition] & ~PRIVATE_BITS_MASK) == ch) {
line[cursorPosition] = ch;
cursorPosition++;
redraw();
break;
}
}
// the ordinary add, of course
addChar(ch);
// and auto-insert a closing pair if appropriate
auto autoChars = enableAutoCloseBrackets();
bool found = false;
foreach(idx, dchar ac; autoChars) {
if(found) {
addChar(ac | PRIVATE_BITS_MASK);
charBack();
break;
}
if((idx&1) == 0 && ac == ch)
found = true;
}
}
redraw();
}
break;
@ -6062,15 +6277,40 @@ class LineGetter {
replaceLine(tmp[0 .. idx]);
}
/++
Gets the current line buffer as a duplicated string.
History:
Added January 25, 2021
+/
string lineAsString() {
import std.conv;
// FIXME: I should prolly not do this on the internal copy but it isn't a huge deal
line[] &= cast(dchar) ~PRIVATE_BITS_MASK;
return to!string(line);
}
///
string finishGettingLine() {
import std.conv;
line[] &= cast(dchar) ~PRIVATE_BITS_MASK;
auto f = to!string(line);
auto history = historyFilter(f);
if(history !is null)
if(history !is null) {
this.history ~= history;
if(this.historyCommitMode == HistoryCommitMode.afterEachLine)
appendHistoryToFile(history);
}
// FIXME: we should hide the cursor if it was hidden in the call to startGettingLine
// also need to reset the color going forward
terminal.color(Color.DEFAULT, Color.DEFAULT);
return eof ? null : f.length ? f : "";
}
}

7
webview.d
View File

@ -3828,7 +3828,7 @@ void main() {
ICoreWebView2 webview_window;
ICoreWebView2Environment webview_env;
func(null, null, null,
auto result = func(null, null, null,
callback!(ICoreWebView2CreateCoreWebView2EnvironmentCompletedHandler)(
delegate(error, env) {
if(error)
@ -3893,6 +3893,11 @@ void main() {
)
);
if(result != S_OK) {
import std.stdio;
writeln("Failed: ", result);
}
window.eventLoop(0);
}