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

it just continues to get more awesome

This commit is contained in:
Adam D. Ruppe 2021-05-28 23:06:13 -04:00
parent 5ac7d88bd1
commit 543d3a2b5d
7 changed files with 1028 additions and 276 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

442
minigui.d
View File

@ -188,7 +188,9 @@ the virtual functions remain as the default calculated values. then the reads go
See [Widget.Style] for details.
* A widget must now opt in to receiving keyboard focus, rather than opting out.
// * A widget must now opt in to receiving keyboard focus, rather than opting out.
* Widgets now draw their keyboard focus by default instead of opt in. You may wish to set `tabStop = false;` if it wasn't supposed to receive it.
* Most Widget constructors no longer have a default `parent` argument. You must pass the parent to almost all widgets, or in rare cases, an explict `null`, but more often than not, you need the parent so the default argument was not very useful at best and misleading to a crash at worst.
@ -372,6 +374,36 @@ version(Windows) {
+/
class Widget {
/++
Sets some internal param, `name`, to the string `value`. It is meant to be used from things like XML loaders.
If you subclass this, you should add your derived members, then `return super.addParameter(name, value);` in the default case.
Returns:
`true` if you handled it, `false` if you did not. This can be used to give user feedback.
History:
Added May 22, 2021
+/
bool addParameter(string name, string value) {
switch(name) {
case "name": this.name = value; return true;
default: return false;
}
}
/++
If `encapsulatedChildren` returns true, it changes the event handling mechanism to act as if events from the child widgets are actually targeted on this widget.
The idea is then you can use child widgets as part of your implementation, but not expose those details through the event system; if someone checks the mouse coordinates and target of the event once it bubbles past you, it will show as it it came from you.
History:
Added May 22, 2021
+/
protected bool encapsulatedChildren() {
return false;
}
// Default layout properties {
int minWidth() { return 0; }
@ -570,14 +602,14 @@ class Widget {
}
///
Color backgroundColor() {
WidgetBackground background() {
// the default is a "transparent" background, which means
// it goes as far up as it can to get the color
if (widget.backgroundColor_ != Color.transparent)
return widget.backgroundColor_;
return WidgetBackground(widget.backgroundColor_);
if (widget.parent)
return StyleInformation.extractStyleProperty!"backgroundColor"(widget.parent);
return widget.backgroundColor_;
return WidgetBackground(StyleInformation.extractStyleProperty!"background"(widget.parent));
return WidgetBackground(widget.backgroundColor_);
}
private OperatingSystemFont fontCached_;
@ -1300,7 +1332,7 @@ class Widget {
version(win32_widgets)
if(hwnd) return; // Windows will do it. I think.
auto c = getComputedStyle().backgroundColor;
auto c = getComputedStyle().background.color;
painter.fillColor = c;
painter.outlineColor = c;
@ -1600,7 +1632,7 @@ abstract class ComboboxBase : Widget {
{
auto cs = getComputedStyle();
auto painter = dropDown.draw();
draw3dFrame(0, 0, w, h, painter, FrameStyle.risen, getComputedStyle().backgroundColor);
draw3dFrame(0, 0, w, h, painter, FrameStyle.risen, getComputedStyle().background.color);
auto p = Point(4, 4);
painter.outlineColor = cs.foregroundColor;
foreach(option; options) {
@ -1612,13 +1644,13 @@ abstract class ComboboxBase : Widget {
dropDown.setEventHandlers(
(MouseEvent event) {
if(event.type == MouseEventType.buttonReleased) {
dropDown.close();
auto element = (event.y - 4) / Window.lineHeight;
if(element >= 0 && element <= options.length) {
selection = element;
fireChangeEvent();
}
dropDown.close();
}
}
);
@ -2033,7 +2065,14 @@ int draw3dFrame(int x, int y, int width, int height, ScreenPainter painter, Fram
return borderWidth;
}
///
/++
An `Action` represents some kind of user action they can trigger through menu options, toolbars, hotkeys, and similar mechanisms. The text label, icon, and handlers are centrally held here instead of repeated in each UI element.
See_Also:
[MenuItem]
[ToolButton]
[Menu.addItem]
+/
class Action {
version(win32_widgets) {
private int id;
@ -2043,7 +2082,16 @@ class Action {
KeyEvent accelerator;
///
// FIXME: disable message
// and toggle thing?
// ??? and trigger arguments too ???
/++
Params:
label = the textual label
icon = icon ID. See [GenericIcons]. There is currently no way to do custom icons.
triggered = initial handler, more can be added via the [triggered] member.
+/
this(string label, ushort icon = 0, void delegate() triggered = null) {
this.label = label;
this.iconId = icon;
@ -2060,6 +2108,7 @@ class Action {
// icon
// when it is triggered, the triggered event is fired on the window
/// The list of handlers when it is triggered.
void delegate()[] triggered;
}
@ -2563,7 +2612,7 @@ struct WidgetPainter {
/// ditto
Color themeBackground() {
return drawingUpon.getComputedStyle().backgroundColor();
return drawingUpon.getComputedStyle().background.color;
}
int isDarkTheme() {
@ -2606,7 +2655,7 @@ struct WidgetPainter {
auto cs = drawingUpon.getComputedStyle();
auto bg = cs.backgroundColor;
auto bg = cs.background.color;
auto borderWidth = draw3dFrame(0, 0, drawingUpon.width, drawingUpon.height, this, cs.borderStyle, bg, cs.borderColor);
@ -2690,6 +2739,22 @@ struct WidgetPainter {
// done..........
}
struct Style {
static struct helper(string m, T) {
enum method = m;
T v;
mixin template MethodOverride(typeof(this) v) {
mixin("override typeof(v.v) "~v.method~"() { return v.v; }");
}
}
static auto opDispatch(string method, T)(T value) {
return helper!(method, T)(value);
}
}
/++
History:
Added Oct 28, 2020
@ -2727,6 +2792,15 @@ struct ContainerMeta {
}
}
/++
This is a helper for [addDataControllerWidget]. You can use it as a UDA on the type. See
http://dpldocs.info/this-week-in-d/Blog.Posted_2020_11_02.html for more information.
Please note that as of May 28, 2021, a dmd bug prevents this from compiling on module-level
structures. It works fine on structs declared inside functions though.
See: https://issues.dlang.org/show_bug.cgi?id=21984
+/
template Container(CArgs...) {
static if(CArgs.length && is(CArgs[0] : Widget)) {
private alias Super = CArgs[0];
@ -2835,17 +2909,57 @@ class DataControllerWidget(T) : Widget {
foreach(member; __traits(allMembers, T))
static if(member != "this") // wtf
static if(__traits(getProtection, __traits(getMember, this.datum, member)) == "public") {
auto w = widgetFor!(__traits(getMember, T, member))(&__traits(getMember, this.datum, member), helper(member));
void delegate() update;
auto w = widgetFor!(__traits(getMember, T, member))(&__traits(getMember, this.datum, member), helper(member), update);
if(update)
updaters ~= update;
static if(is(typeof(__traits(getMember, this.datum, member)) == function))
w.addEventListener("triggered", &__traits(getMember, this.datum, member));
else static if(is(w : DropDownSelection))
w.addEventListener("triggered", delegate() {
__traits(getMember, this.datum, member)();
notifyDataUpdated();
});
else static if(is(typeof(w.value) == string) || is(typeof(w.content) == string))
w.addEventListener("change", (Event e) { genericSetValue(&__traits(getMember, this.datum, member), e.stringValue); } );
else
w.addEventListener("change", (Event e) { genericSetValue(&__traits(getMember, this.datum, member), e.intValue); } );
}
}
Widget[string] memberWidgets;
/++
If you modify the data in the structure directly, you need to call this to update the UI and propagate any change messages.
History:
Added May 28, 2021
+/
void notifyDataUpdated() {
foreach(updater; updaters)
updater();
this.emit!(ChangeEvent!void)(delegate{});
}
private Widget[string] memberWidgets;
private void delegate()[] updaters;
override int maxHeight() {
if(this.children.length == 1)
return this.children[0].maxHeight;
else
return int.max;
}
override int maxWidth() {
if(this.children.length == 1)
return this.children[0].maxWidth;
else
return int.max;
}
mixin Emits!(ChangeEvent!void);
}
void genericSetValue(T, W)(T* where, W what) {
@ -2855,20 +2969,24 @@ void genericSetValue(T, W)(T* where, W what) {
}
// FIXME: integrate with AutomaticDialog
static auto widgetFor(alias tt, P)(P valptr, Widget parent) {
static auto widgetFor(alias tt, P)(P valptr, Widget parent, out void delegate() update) {
static if(controlledByCount!tt == 1) {
foreach(i, attr; __traits(getAttributes, tt)) {
static if(is(typeof(attr) == ControlledBy_!(T, Args), T, Args...)) {
auto w = attr.construct(parent);
static if(__traits(compiles, w.setPosition(*valptr)))
w.setPosition(*valptr);
update = () { w.setPosition(*valptr); };
else static if(__traits(compiles, w.setValue(*valptr)))
w.setValue(*valptr);
update = () { w.setValue(*valptr); };
if(update)
update();
return w;
}
}
} else static if(controlledByCount!tt == 0) {
static if(is(typeof(tt) == enum)) {
// FIXME: update
auto dds = new DropDownSelection(parent);
foreach(idx, option; __traits(allMembers, typeof(tt))) {
dds.addOption(option);
@ -2879,7 +2997,13 @@ static auto widgetFor(alias tt, P)(P valptr, Widget parent) {
} else static if(is(typeof(tt) : const long)) {
static assert(0);
} else static if(is(typeof(tt) : const string)) {
static assert(0);
auto le = new LabeledLineEdit(__traits(identifier, tt), parent);
update = () { le.content = *valptr; };
update();
return le;
} else static if(is(typeof(tt) == function)) {
auto w = new Button(__traits(identifier, tt), parent);
return w;
}
} else static assert(0, "multiple controllers not yet supported");
}
@ -2899,14 +3023,27 @@ private template controlledByCount(alias tt) {
/++
Intended for UFCS action like `window.addDataControllerWidget(new MyObject());`
If you provide a `redrawOnChange` widget, it will automatically register a change event handler that calls that widget's redraw method.
History:
The `redrawOnChange` parameter was added on May 28, 2021.
+/
DataControllerWidget!T addDataControllerWidget(T)(Widget parent, T t) if(is(T == class)) {
return new DataControllerWidget!T(t, parent);
DataControllerWidget!T addDataControllerWidget(T)(Widget parent, T t, Widget redrawOnChange = null) if(is(T == class)) {
auto dcw = new DataControllerWidget!T(t, parent);
initializeDataControllerWidget(dcw, redrawOnChange);
return dcw;
}
/// ditto
DataControllerWidget!T addDataControllerWidget(T)(Widget parent, T* t) if(is(T == struct)) {
return new DataControllerWidget!T(t, parent);
DataControllerWidget!T addDataControllerWidget(T)(Widget parent, T* t, Widget redrawOnChange = null) if(is(T == struct)) {
auto dcw = new DataControllerWidget!T(t, parent);
initializeDataControllerWidget(dcw, redrawOnChange);
return dcw;
}
private void initializeDataControllerWidget(Widget w, Widget redrawOnChange) {
if(redrawOnChange !is null)
w.addEventListener("change", delegate() { redrawOnChange.redraw(); });
}
/+
@ -2935,6 +3072,8 @@ struct StyleInformation {
return Color.fromString(str);
else static if(is(T == Measurement))
return Measurement(cast(int) toInternal!int(str));
else static if(is(T == WidgetBackground))
return WidgetBackground.fromString(str);
else static if(is(T == OperatingSystemFont)) {
if(auto f = str in fontCache)
return *f;
@ -2985,7 +3124,7 @@ struct StyleInformation {
int minWidth() { return getProperty("min-width", Measurement(w.minWidth())); }
Color backgroundColor() { return getProperty("background-color", extractStyleProperty!"backgroundColor"(w)); }
WidgetBackground background() { return getProperty("background", extractStyleProperty!"background"(w)); }
Color foregroundColor() { return getProperty("foreground-color", extractStyleProperty!"foregroundColor"(w)); }
OperatingSystemFont font() { return getProperty("font", extractStyleProperty!"fontCached"(w)); }
@ -3260,8 +3399,8 @@ class ListWidget : ListWidgetBase {
}
static class Style : Widget.Style {
override Color backgroundColor() {
return WidgetPainter.visualTheme.widgetBackgroundColor;
override WidgetBackground background() {
return WidgetBackground(WidgetPainter.visualTheme.widgetBackgroundColor);
}
}
mixin OverrideStyle!Style;
@ -4175,6 +4314,7 @@ class HorizontalSlider : Slider {
protected override void setPositionCustom(int a) {
if(max())
thumb.positionX = a * (thumb.width - 16) / max();
redraw();
}
}
@ -4774,6 +4914,8 @@ class TabWidget : Widget {
this(Widget parent) {
super(parent);
tabStop = false;
version(win32_widgets) {
createWin32Window(this, WC_TABCONTROL, "", 0);
} else version(custom_widgets) {
@ -4883,11 +5025,14 @@ class TabWidget : Widget {
int tabWidth = 80;
}
version(win32_widgets)
override void paint(WidgetPainter painter) {}
version(custom_widgets)
override void paint(WidgetPainter painter) {
auto cs = getComputedStyle();
draw3dFrame(0, tabBarHeight - 2, width, height - tabBarHeight + 2, painter, FrameStyle.risen, cs.backgroundColor);
draw3dFrame(0, tabBarHeight - 2, width, height - tabBarHeight + 2, painter, FrameStyle.risen, cs.background.color);
int posX = 0;
foreach(idx, child; children) {
@ -5075,6 +5220,7 @@ class TabWidgetPage : Widget {
string title;
this(string title, Widget parent) {
this.title = title;
this.tabStop = false;
super(parent);
///*
@ -5441,11 +5587,11 @@ class Window : Widget {
}
static class Style : Widget.Style {
override Color backgroundColor() {
override WidgetBackground background() {
version(custom_widgets)
return WidgetPainter.visualTheme.windowBackgroundColor;
return WidgetBackground(WidgetPainter.visualTheme.windowBackgroundColor);
else version(win32_widgets)
return Color.transparent;
return WidgetBackground(Color.transparent);
else static assert(0);
}
}
@ -5843,15 +5989,17 @@ class Window : Widget {
auto eleR = widgetAtPoint(this, ev.x, ev.y);
auto ele = eleR.widget;
auto captureEle = ele;
if(mouseCapturedBy !is null) {
if(ele !is mouseCapturedBy && !mouseCapturedBy.isAParentOf(ele))
ele = mouseCapturedBy;
captureEle = mouseCapturedBy;
}
// a hack to get it relative to the widget.
eleR.x = ev.x;
eleR.y = ev.y;
auto pain = ele;
auto pain = captureEle;
while(pain) {
eleR.x -= pain.x;
eleR.y -= pain.y;
@ -5859,7 +6007,7 @@ class Window : Widget {
}
if(ev.type == MouseEventType.buttonPressed) {
MouseEventBase event = new MouseDownEvent(ele);
MouseEventBase event = new MouseDownEvent(captureEle);
event.button = ev.button;
event.buttonLinear = ev.buttonLinear;
event.state = ev.modifierState;
@ -5868,7 +6016,7 @@ class Window : Widget {
event.dispatch();
if(ev.button != MouseButton.wheelDown && ev.button != MouseButton.wheelUp && mouseLastDownOn is ele && ev.doubleClick) {
event = new DoubleClickEvent(ele);
event = new DoubleClickEvent(captureEle);
event.button = ev.button;
event.buttonLinear = ev.buttonLinear;
event.state = ev.modifierState;
@ -5883,7 +6031,7 @@ class Window : Widget {
mouseLastDownOn = ele;
} else if(ev.type == MouseEventType.buttonReleased) {
{
auto event = new MouseUpEvent(ele);
auto event = new MouseUpEvent(captureEle);
event.button = ev.button;
event.buttonLinear = ev.buttonLinear;
event.clientX = eleR.x;
@ -5892,7 +6040,7 @@ class Window : Widget {
event.dispatch();
}
if(!lastWasDoubleClick && mouseLastDownOn is ele) {
MouseEventBase event = new ClickEvent(ele);
MouseEventBase event = new ClickEvent(captureEle);
event.clientX = eleR.x;
event.clientY = eleR.y;
event.state = ev.modifierState;
@ -5903,7 +6051,7 @@ class Window : Widget {
} else if(ev.type == MouseEventType.motion) {
// motion
{
auto event = new MouseMoveEvent(ele);
auto event = new MouseMoveEvent(captureEle);
event.state = ev.modifierState;
event.clientX = eleR.x;
event.clientY = eleR.y;
@ -6143,11 +6291,11 @@ class Labeled(T) : Widget {
override int marginBottom() { return 4; }
///
string content() {
@property string content() {
return lineEdit.content;
}
///
void content(string c) {
@property void content(string c) {
return lineEdit.content(c);
}
@ -6171,8 +6319,65 @@ class Labeled(T) : Widget {
+/
alias LabeledPasswordEdit = Labeled!PasswordEdit;
private string toMenuLabel(string s) {
string n;
n.reserve(s.length);
foreach(c; s)
if(c == '_')
n ~= ' ';
else
n ~= c;
return n;
}
///
private void delegate() makeAutomaticHandler(alias fn, T)(T t) {
static if(is(T : void delegate())) {
return t;
} else {
static if(is(typeof(fn) Params == __parameters))
struct S {
static foreach(idx, ignore; Params) {
mixin("Params[idx] " ~ __traits(identifier, Params[idx .. idx + 1]) ~ ";");
}
}
return () {
dialog((S s) {
t(s.tupleof);
}, null, __traits(identifier, fn));
};
}
}
private template hasAnyRelevantAnnotations(a...) {
bool helper() {
bool any;
foreach(attr; a) {
static if(is(typeof(attr) == .menu))
any = true;
else static if(is(typeof(attr) == .toolbar))
any = true;
else static if(is(attr == .separator))
any = true;
else static if(is(typeof(attr) == .accelerator))
any = true;
else static if(is(typeof(attr) == .hotkey))
any = true;
else static if(is(typeof(attr) == .icon))
any = true;
else static if(is(typeof(attr) == .label))
any = true;
else static if(is(typeof(attr) == .tip))
any = true;
}
return any;
}
enum bool hasAnyRelevantAnnotations = helper();
}
/++
A `MainWindow` is a window that includes turnkey support for a menu bar, tool bar, and status bar automatically positioned around a client area where you put your widgets.
+/
class MainWindow : Window {
///
this(string title = null, int initialWidth = 500, int initialHeight = 500) {
@ -6200,7 +6405,7 @@ class MainWindow : Window {
void Open() {}
void Save() {}
@separator
void Exit() @accelerator("Alt+F4") {
void Exit() @accelerator("Alt+F4") @hotkey('x') {
window.close();
}
}
@ -6225,6 +6430,8 @@ class MainWindow : Window {
window.setMenuAndToolbarFromAnnotatedCode(commands);
---
Note that you can call this function multiple times and it will add the items in order to the given items.
+/
void setMenuAndToolbarFromAnnotatedCode(T)(ref T t) if(!is(T == class) && !is(T == interface)) {
setMenuAndToolbarFromAnnotatedCode_internal(t);
@ -6241,10 +6448,9 @@ class MainWindow : Window {
mcs[menu.label] = menu;
}
void delegate() triggering;
foreach(memberName; __traits(derivedMembers, T)) {
static if(__traits(compiles, triggering = &__traits(getMember, t, memberName))) {
static if(memberName != "this")
static if(hasAnyRelevantAnnotations!(__traits(getAttributes, __traits(getMember, T, memberName)))) {
.menu menu;
.toolbar toolbar;
bool separator;
@ -6275,13 +6481,16 @@ class MainWindow : Window {
if(menu !is .menu.init || toolbar !is .toolbar.init) {
ushort correctIcon = icon.id; // FIXME
if(label.length == 0)
label = memberName;
auto action = new Action(label, correctIcon, &__traits(getMember, t, memberName));
label = memberName.toMenuLabel;
auto handler = makeAutomaticHandler!(__traits(getMember, T, memberName))(&__traits(getMember, t, memberName));
auto action = new Action(label, correctIcon, handler);
if(accelerator.keyString.length) {
auto ke = KeyEvent.parse(accelerator.keyString);
action.accelerator = ke;
accelerators[ke.toStr] = &__traits(getMember, t, memberName);
accelerators[ke.toStr] = handler;
}
if(toolbar !is .toolbar.init)
@ -6412,8 +6621,9 @@ class MainWindow : Window {
/+
This is really an implementation detail of [MainWindow]
+/
class ClientAreaWidget : Widget {
private class ClientAreaWidget : Widget {
this() {
this.tabStop = false;
super(null);
//sa = new ScrollableWidget(this);
}
@ -6433,7 +6643,7 @@ class ClientAreaWidget : Widget {
/**
Toolbars are lists of buttons (typically icons) that appear under the menu.
Each button ought to correspond to a menu item.
Each button ought to correspond to a menu item, represented by [Action] objects.
*/
class ToolBar : Widget {
version(win32_widgets) {
@ -6520,7 +6730,7 @@ class ToolBar : Widget {
enum toolbarIconSize = 24;
///
/// An implementation helper for [ToolBar]. Generally, you shouldn't create these yourself and instead just pass [Action]s to [ToolBar]'s constructor and let it create the buttons for you.
class ToolButton : Button {
///
this(string label, Widget parent) {
@ -6680,7 +6890,7 @@ class MenuBar : Widget {
version(custom_widgets)
override void paint(WidgetPainter painter) {
draw3dFrame(this, painter, FrameStyle.risen, getComputedStyle().backgroundColor);
draw3dFrame(this, painter, FrameStyle.risen, getComputedStyle().background.color);
}
///
@ -6839,13 +7049,13 @@ class StatusBar : Widget {
version(custom_widgets)
override void paint(WidgetPainter painter) {
auto cs = getComputedStyle();
this.draw3dFrame(painter, FrameStyle.sunk, cs.backgroundColor);
this.draw3dFrame(painter, FrameStyle.sunk, cs.background.color);
int cpos = 0;
int remainingLength = this.width;
foreach(idx, part; this.partsArray) {
auto partWidth = part.width ? part.width : ((idx + 1 == this.partsArray.length) ? remainingLength : 100);
painter.setClipRectangle(Point(cpos, 0), partWidth, height);
draw3dFrame(cpos, 0, partWidth, height, painter, FrameStyle.sunk, cs.backgroundColor);
draw3dFrame(cpos, 0, partWidth, height, painter, FrameStyle.sunk, cs.background.color);
painter.setClipRectangle(Point(cpos + 2, 2), partWidth - 4, height - 4);
painter.outlineColor = cs.foregroundColor();
@ -6898,7 +7108,7 @@ class ProgressBar : Widget {
version(custom_widgets)
override void paint(WidgetPainter painter) {
auto cs = getComputedStyle();
this.draw3dFrame(painter, FrameStyle.sunk, cs.backgroundColor);
this.draw3dFrame(painter, FrameStyle.sunk, cs.background.color);
painter.fillColor = cs.progressBarColor;
painter.drawRectangle(Point(0, 0), width * current / max, height);
}
@ -7236,7 +7446,7 @@ class Menu : Window {
version(custom_widgets)
override void paint(WidgetPainter painter) {
this.draw3dFrame(painter, FrameStyle.risen, getComputedStyle.backgroundColor);
this.draw3dFrame(painter, FrameStyle.risen, getComputedStyle.background.color);
}
}
@ -7282,7 +7492,7 @@ class MenuItem : MouseActivatedWidget {
override void paint(WidgetPainter painter) {
auto cs = getComputedStyle();
if(dynamicState & DynamicState.depressed)
this.draw3dFrame(painter, FrameStyle.sunk, cs.backgroundColor);
this.draw3dFrame(painter, FrameStyle.sunk, cs.background.color);
if(dynamicState & DynamicState.hover)
painter.outlineColor = cs.activeMenuItemColor;
else
@ -7340,23 +7550,28 @@ class MouseActivatedWidget : Widget {
private bool isChecked_;
override void attachedToWindow(Window w) {
w.addEventListener("mouseup", delegate (Widget _this, Event ev) {
setDynamicState(DynamicState.depressed, false);
});
}
this(Widget parent) {
super(parent);
addEventListener("mousedown", delegate (Widget _this, Event ev) {
setDynamicState(DynamicState.depressed, true);
redraw();
addEventListener((MouseDownEvent ev) {
if(ev.button == MouseButton.left) {
setDynamicState(DynamicState.depressed, true);
redraw();
}
});
addEventListener("mouseup", delegate (Widget _this, Event ev) {
setDynamicState(DynamicState.depressed, false);
redraw();
addEventListener((MouseUpEvent ev) {
if(ev.button == MouseButton.left) {
setDynamicState(DynamicState.depressed, false);
redraw();
}
});
addEventListener((MouseMoveEvent mme) {
if(!(mme.state & ModifierState.leftButtonDown)) {
setDynamicState(DynamicState.depressed, false);
redraw();
}
});
}
@ -7390,8 +7605,10 @@ class MouseActivatedWidget : Widget {
super.defaultEventHandler_click(ev);
if(this.tabStop)
this.focus();
auto event = new Event(EventType.triggered, this);
event.sendDirectly();
if(ev.button == MouseButton.left) {
auto event = new Event(EventType.triggered, this);
event.sendDirectly();
}
}
}
@ -7631,16 +7848,16 @@ class Button : MouseActivatedWidget {
override int minHeight() { return Window.lineHeight + 4; }
static class Style : Widget.Style {
override Color backgroundColor() {
override WidgetBackground background() {
auto cs = widget.getComputedStyle(); // FIXME: this is potentially recursive
auto pressed = DynamicState.depressed | DynamicState.hover;
if((widget.dynamicState & pressed) == pressed) {
return cs.depressedButtonColor();
return WidgetBackground(cs.depressedButtonColor());
} else if(widget.dynamicState & DynamicState.hover) {
return cs.hoveringColor();
return WidgetBackground(cs.hoveringColor());
} else {
return cs.buttonColor();
return WidgetBackground(cs.buttonColor());
}
}
@ -8609,13 +8826,12 @@ enum EventType : string {
---
class MyEvent : Event {
this(Widget w) { super(w); }
mixin Register; // adds EventString and other reflection information
}
---
## General Conventions
Change events should NOT be emitted when a value is changed programmatically. Indeed, methods should usually not send events. The point of an event is to know something changed and when you call a method, you already know about it.
Then declare that it is sent with the [Emits] mixin, so you can use [Widget.emit] to dispatch it.
History:
Prior to May 2021, Event had a set of pre-made members with no extensibility (outside of diy casts) and no static checks on field presence.
@ -8623,6 +8839,12 @@ enum EventType : string {
After that, those old pre-made members are deprecated accessors and the fields are moved to child classes. To transition, change string events to typed events or do a dynamic cast (don't forget the null check!) in your handler.
+/
/+
## General Conventions
Change events should NOT be emitted when a value is changed programmatically. Indeed, methods should usually not send events. The point of an event is to know something changed and when you call a method, you already know about it.
## Qt-style signals and slots
Some events make sense to use with just name and data type. These are one-way notifications with no propagation nor default behavior and thus separate from the other event system.
@ -8749,7 +8971,10 @@ class Event {
private bool isBubbling;
/// This is an internal implementation detail you should not use. It would be private if the language allowed it and it may be removed without notice.
protected void adjustScrolling() { }
/// ditto
protected void adjustClientCoordinates(int deltaX, int deltaY) { }
/++
this sends it only to the target. If you want propagation, use dispatch() instead.
@ -8839,6 +9064,9 @@ class Event {
break;
}
int adjustX;
int adjustY;
isBubbling = true;
if(!propagationStopped)
foreach(e; chain) {
@ -8853,6 +9081,14 @@ class Event {
if(propagationStopped)
break;
if(e.encapsulatedChildren()) {
adjustClientCoordinates(adjustX, adjustY);
target = e;
} else {
adjustX += e.x;
adjustY += e.y;
}
}
if(!defaultPrevented)
@ -9206,8 +9442,8 @@ abstract class MouseEventBase : Event {
int viewportX; /// The mouse event location relative to the window origin
int viewportY; /// ditto
int button; /// [MouseEvent.button]
int buttonLinear; /// [MouseEvent.buttonLinear]
int button; /// See: [MouseEvent.button]
int buttonLinear; /// See: [MouseEvent.buttonLinear]
int state; ///
@ -9221,6 +9457,12 @@ abstract class MouseEventBase : Event {
return button == MouseButton.wheelUp || button == MouseButton.wheelDown;
}
// private
override void adjustClientCoordinates(int deltaX, int deltaY) {
clientX += deltaX;
clientY += deltaY;
}
override void adjustScrolling() {
version(custom_widgets) { // TEMP
viewportX = clientX;
@ -9238,6 +9480,12 @@ abstract class MouseEventBase : Event {
Indicates that the user has worked with the mouse over your widget. For available properties, see [MouseEventBase].
$(WARNING
Important: MouseDownEvent, MouseUpEvent, ClickEvent, and DoubleClickEvent are all sent for all mouse buttons and
for wheel movement! You should check the [MouseEventBase.button|button] property in most your handlers to get correct
behavior.
)
[MouseDownEvent] is sent when the user presses a mouse button. It is also sent on mouse wheel movement.
[MouseUpEvent] is sent when the user releases a mouse button.
@ -9355,6 +9603,7 @@ private WidgetAtPointResponse widgetAtPoint(Widget starting, int x, int y) {
}
version(win32_widgets) {
private:
import core.sys.windows.commctrl;
pragma(lib, "comctl32");
@ -9927,8 +10176,8 @@ class ObjectInspectionWindowImpl(T) : ObjectInspectionWindow {
---
+/
/// Group: generating_from_code
void dialog(T)(void delegate(T) onOK, void delegate() onCancel = null) {
auto dg = new AutomaticDialog!T(onOK, onCancel);
void dialog(T)(void delegate(T) onOK, void delegate() onCancel = null, string title = T.stringof) {
auto dg = new AutomaticDialog!T(onOK, onCancel, title);
dg.show();
}
@ -9991,12 +10240,12 @@ class AutomaticDialog(T) : Dialog {
override int paddingLeft() { return Window.lineHeight; }
this(void delegate(T) onOK, void delegate() onCancel) {
this(void delegate(T) onOK, void delegate() onCancel, string title) {
static if(is(T == class))
t = new T();
this.onOK = onOK;
this.onCancel = onCancel;
super(400, cast(int)(__traits(allMembers, T).length * 2) * (Window.lineHeight + 4 + 2) + Window.lineHeight + 56, T.stringof);
super(400, cast(int)(__traits(allMembers, T).length * 2) * (Window.lineHeight + 4 + 2) + Window.lineHeight + 56, title);
foreach(memberName; __traits(allMembers, T)) {
alias member = I!(__traits(getMember, t, memberName))[0];
@ -10166,6 +10415,31 @@ interface Reflectable {
or stylesheets can override this. The virtual ones count as tag-level specificity in css.
+/
/++
Structure to represent a collection of background hints. New features can be added here, so make sure you use the provided constructors and factories for maximum compatibility.
History:
Added May 24, 2021.
+/
struct WidgetBackground {
/++
A background with the given solid color.
+/
this(Color color) {
this.color = color;
}
this(WidgetBackground bg) {
this = bg;
}
static WidgetBackground fromString(string s) {
return WidgetBackground(Color.fromString(s));
}
private Color color;
}
/++
Interface to a custom visual theme which is able to access and use style hint properties, draw stylistic elements, and even completely override existing class' paint methods (though I'd note that can be a lot harder than it may seem due to the various little details of state you need to reflect visually, so that should be your last result!)

16
minigui_addons/color_dialog.d
View File

@ -123,16 +123,16 @@ class ColorPickerDialog : Dialog {
override int maxWidth() { return 150; };
};
h = new LabeledLineEdit("Hue:", vlHsl);
s = new LabeledLineEdit("Saturation:", vlHsl);
l = new LabeledLineEdit("Lightness:", vlHsl);
h = new LabeledLineEdit("Hue:", TextAlignment.Right, vlHsl);
s = new LabeledLineEdit("Saturation:", TextAlignment.Right, vlHsl);
l = new LabeledLineEdit("Lightness:", TextAlignment.Right, vlHsl);
css = new LabeledLineEdit("CSS:", vlHsl);
css = new LabeledLineEdit("CSS:", TextAlignment.Right, vlHsl);
r = new LabeledLineEdit("Red:", vlRgb);
g = new LabeledLineEdit("Green:", vlRgb);
b = new LabeledLineEdit("Blue:", vlRgb);
a = new LabeledLineEdit("Alpha:", vlRgb);
r = new LabeledLineEdit("Red:", TextAlignment.Right, vlRgb);
g = new LabeledLineEdit("Green:", TextAlignment.Right, vlRgb);
b = new LabeledLineEdit("Blue:", TextAlignment.Right, vlRgb);
a = new LabeledLineEdit("Alpha:", TextAlignment.Right, vlRgb);
import std.conv;
import std.format;

337
minigui_xml.d
View File

@ -67,104 +67,347 @@
auto page = new PageWidget(parent);
page.name = "mypage";
select.addEventListener("change", (Event event) {
select.addEventListener("change", (Event event)
{
page.setCurrentTab(event.intValue);
});
---
+/
module arsd.minigui_xml;
module minigui_xml;
public import arsd.minigui;
public import arsd.minigui : Event;
import arsd.dom;
private template ident(T...) {
import std.conv;
import std.exception;
import std.functional : toDelegate;
import std.string : strip;
import std.traits;
private template ident(T...)
{
static if(is(T[0]))
alias ident = T[0];
else
alias ident = void;
}
private
Widget delegate(string[string] args, Widget parent)[string] widgetFactoryFunctions;
enum ParseContinue { recurse, next, abort }
private
void loadMiniguiPublicClasses() {
if(widgetFactoryFunctions !is null)
return;
alias WidgetFactory = ParseContinue delegate(Widget parent, Element element, out Widget result);
alias WidgetTextHandler = void delegate(Widget widget, string text);
WidgetFactory[string] widgetFactoryFunctions;
WidgetTextHandler[string] widgetTextHandlers;
void delegate(string eventName, Widget, Event, string content) xmlScriptEventHandler;
static this()
{
xmlScriptEventHandler = toDelegate(&nullScriptEventHandler);
}
void nullScriptEventHandler(string eventName, Widget w, Event e, string)
{
import std.stdio : stderr;
stderr.writeln("Ignoring event ", eventName, " ", e, " on widget ", w.elementName, " because xmlScriptEventHandler is not set");
}
private bool startsWith(T)(T[] doesThis, T[] startWithThis)
{
return doesThis.length >= startWithThis.length && doesThis[0 .. startWithThis.length] == startWithThis;
}
private bool isLower(char c)
{
return c >= 'a' && c <= 'z';
}
private bool isUpper(char c)
{
return c >= 'A' && c <= 'Z';
}
private char assumeLowerToUpper(char c)
{
return cast(char)(c - 'a' + 'A');
}
private char assumeUpperToLower(char c)
{
return cast(char)(c - 'A' + 'a');
}
string hyphenate(string argname)
{
int hyphen;
foreach (i, char c; argname)
if (c.isUpper && (i == 0 || !argname[i - 1].isUpper))
hyphen++;
if (hyphen == 0)
return argname;
char[] ret = new char[argname.length + hyphen];
int i;
bool prevUpper;
foreach (char c; argname)
{
bool upper = c.isUpper;
if (upper)
{
if (!prevUpper)
ret[i++] = '-';
ret[i++] = c.assumeUpperToLower;
}
else
{
ret[i++] = c;
}
prevUpper = upper;
}
assert(i == ret.length);
return cast(string) ret;
}
string unhyphen(string argname)
{
int hyphen;
foreach (i, char c; argname)
if (c == '-' && (i == 0 || argname[i - 1] != '-'))
hyphen++;
if (hyphen == 0)
return argname;
char[] ret = new char[argname.length - hyphen];
int i;
char prev;
foreach (char c; argname)
{
if (c != '-')
{
if (prev == '-' && c.isLower)
ret[i++] = c.assumeLowerToUpper;
else
ret[i++] = c;
}
prev = c;
}
assert(i == ret.length);
return cast(string) ret;
}
void initMinigui(Modules...)()
{
import std.traits;
import std.conv;
foreach(memberName; __traits(allMembers, mixin("arsd.minigui"))) static if(!__traits(isDeprecated, __traits(getMember, mixin("arsd.minigui"), memberName))) {
alias Member = ident!(__traits(getMember, mixin("arsd.minigui"), memberName));
static if(is(Member == class) && !isAbstractClass!Member && is(Member : Widget) && __traits(getProtection, Member) != "private") {
widgetFactoryFunctions[memberName] = (string[string] args, Widget parent) {
static if(is(Member : Dialog)) {
return new Member();
} else static if(is(Member : Window)) {
return new Member("test");
} else {
auto paramNames = ParameterIdentifierTuple!(__traits(getMember, Member, "__ctor"));
static foreach (alias Module; Modules)
{
pragma(msg, Module.stringof);
appendMiniguiModule!Module;
}
}
void appendMiniguiModule(alias Module, string prefix = null)()
{
foreach(memberName; __traits(allMembers, Module)) static if(!__traits(isDeprecated, __traits(getMember, Module, memberName)))
{
alias Member = ident!(__traits(getMember, Module, memberName));
static if(is(Member == class) && !isAbstractClass!Member && is(Member : Widget) && __traits(getProtection, Member) != "private")
{
widgetFactoryFunctions[prefix ~ memberName] = (Widget parent, Element element, out Widget widget)
{
static if(is(Member : Dialog))
{
widget = new Member();
}
else static if(is(Member : Menu))
{
widget = new Menu(null, null);
}
else static if(is(Member : Window))
{
widget = new Member("test");
}
else
{
string[string] args = element.attributes;
enum paramNames = ParameterIdentifierTuple!(__traits(getMember, Member, "__ctor"));
Parameters!(__traits(getMember, Member, "__ctor")) params;
static assert(paramNames.length, Member);
bool[cast(int)paramNames.length - 1] requiredParams;
foreach(idx, param; params[0 .. $-1]) {
if(auto arg = paramNames[idx] in args) {
static if(is(typeof(param) == MemoryImage)) {
static foreach (idx, param; params[0 .. $-1])
{{
enum hyphenated = paramNames[idx].hyphenate;
if (auto arg = hyphenated in args)
{
enforce(!requiredParams[idx], "May pass required parameter " ~ hyphenated ~ " only exactly once");
requiredParams[idx] = true;
static if(is(typeof(param) == MemoryImage))
{
} else static if(is(typeof(param) == Color)) {
}
else static if(is(typeof(param) == Color))
{
params[idx] = Color.fromString(*arg);
} else
}
else
params[idx] = to!(typeof(param))(*arg);
}
}
else
{
enforce(false, "Missing required parameter " ~ hyphenated ~ " for Widget " ~ memberName);
assert(false);
}
}}
params[$-1] = parent;
auto widget = new Member(params);
auto member = new Member(params);
widget = member;
if(auto st = "statusTip" in args)
widget.statusTip = *st;
if(auto st = "name" in args)
widget.name = *st;
return widget;
foreach (argName, argValue; args)
{
if (argName.startsWith("on-"))
{
auto eventName = argName[3 .. $].unhyphen;
widget.addEventListener(eventName, (event) { xmlScriptEventHandler(eventName, member, event, argValue); });
}
else
{
argName = argName.unhyphen;
switch (argName)
{
static foreach (idx, param; params[0 .. $-1])
{
case paramNames[idx]:
}
break;
static if (is(typeof(Member.addParameter)))
{
default:
member.addParameter(argName, argValue);
break;
}
else
{
// TODO: add generic parameter setting here (iterate by UDA maybe)
default:
enforce(false, "Unknown parameter " ~ argName ~ " for Widget " ~ memberName);
assert(false);
}
}
}
}
}
return ParseContinue.recurse;
};
enum hasText = is(typeof(Member.text) == string) || is(typeof(Member.text()) == string);
enum hasContent = is(typeof(Member.content) == string) || is(typeof(Member.content()) == string);
enum hasLabel = is(typeof(Member.label) == string) || is(typeof(Member.label()) == string);
static if (hasText || hasContent || hasLabel)
{
enum member = hasText ? "text" : hasContent ? "content" : hasLabel ? "label" : null;
widgetTextHandlers[memberName] = (Widget widget, string text)
{
auto w = cast(Member)widget;
assert(w, "Called widget text handler with widget of type "
~ typeid(widget).name ~ " but it was registered for "
~ memberName ~ " which is incompatible");
mixin("w.", member, " = w.", member, " ~ text;");
};
}
// TODO: might want to check for child methods/structs that register as child nodes
}
}
}
///
Widget makeWidgetFromString(string xml, Widget parent) {
Widget makeWidgetFromString(string xml, Widget parent)
{
auto document = new Document(xml, true, true);
auto r = document.root;
return miniguiWidgetFromXml(r, parent);
}
///
Window createWindowFromXml(string xml) {
Window createWindowFromXml(string xml)
{
return createWindowFromXml(new Document(xml, true, true));
}
///
Window createWindowFromXml(Document document) {
Window createWindowFromXml(Document document)
{
auto r = document.root;
return cast(Window) miniguiWidgetFromXml(r, null);
}
///
Widget miniguiWidgetFromXml(Element element, Widget parent) {
if(widgetFactoryFunctions is null)
loadMiniguiPublicClasses();
if(auto factory = element.tagName in widgetFactoryFunctions) {
auto p = (*factory)(element.attributes, parent);
foreach(child; element.children)
if(child.tagName != "#text")
miniguiWidgetFromXml(child, p);
return p;
} else {
import std.stdio;
writeln("Unknown class: ", element.tagName);
return null;
Widget miniguiWidgetFromXml(Element element, Widget parent)
{
Widget w;
miniguiWidgetFromXml(element, parent, w);
return w;
}
///
ParseContinue miniguiWidgetFromXml(Element element, Widget parent, out Widget w)
{
assert(widgetFactoryFunctions !is null, "No widget factories have been registered, register them using initMinigui!(arsd.minigui); at startup");
if (auto factory = element.tagName in widgetFactoryFunctions)
{
auto c = (*factory)(parent, element, w);
if (c == ParseContinue.recurse)
{
c = ParseContinue.next;
Widget dummy;
foreach (child; element.children)
if (miniguiWidgetFromXml(child, w, dummy) == ParseContinue.abort)
{
c = ParseContinue.abort;
break;
}
}
return c;
}
else if (element.tagName == "#text")
{
string text = element.nodeValue.strip;
if (text.length)
{
assert(parent, "got xml text without parent, make sure you only pass elements!");
if (auto factory = parent.elementName in widgetTextHandlers)
(*factory)(parent, text);
else
{
import std.stdio : stderr;
stderr.writeln("WARN: no text handler for widget ", parent.elementName, " ~= ", [text]);
}
}
return ParseContinue.next;
}
else
{
enforce(false, "Unknown tag " ~ element.tagName);
assert(false);
}
}
string elementName(Widget w)
{
if (w is null)
return null;
auto name = typeid(w).name;
foreach_reverse (i, char c; name)
if (c == '.')
return name[i + 1 .. $];
return name;
}

160
nanovega.d
View File

@ -28,77 +28,38 @@ If you know canvas, you're up to speed with NanoVega in no time.
$(SIDE_BY_SIDE
$(COLUMN
D code with nanovega:
---
import arsd.nanovega;
import arsd.simpledisplay;
import arsd.nanovega;
void main () {
NVGContext nvg; // our NanoVega context
// The NVGWindow class creates a window and sets up the nvg context for you
// you can also do these steps yourself, see the other examples in these docs
auto window = new NVGWindow(800, 600, "NanoVega Simple Sample");
// we need at least OpenGL3 with GLSL to use NanoVega,
// so let's tell simpledisplay about that
setOpenGLContextVersion(3, 0);
window.redrawNVGScene = delegate (nvg) {
nvg.beginPath(); // start new path
nvg.roundedRect(20.5, 30.5, window.width-40, window.height-60, 8); // .5 to draw at pixel center (see NanoVega documentation)
// now set filling mode for our rectangle
// you can create colors using HTML syntax, or with convenient constants
nvg.fillPaint = nvg.linearGradient(20.5, 30.5, window.width-40, window.height-60,
NVGColor("#f70"), NVGColor.green);
// now fill our rect
nvg.fill();
// and draw a nice outline
nvg.strokeColor = NVGColor.white;
nvg.strokeWidth = 2;
nvg.stroke();
// that's all, folks!
};
// now create OpenGL window
auto sdmain = new SimpleWindow(800, 600, "NanoVega Simple Sample", OpenGlOptions.yes, Resizability.allowResizing);
// we need to destroy NanoVega context on window close
// stricly speaking, it is not necessary, as nothing fatal
// will happen if you'll forget it, but let's be polite.
// note that we cannot do that *after* our window was closed,
// as we need alive OpenGL context to do proper cleanup.
sdmain.onClosing = delegate () {
nvg.kill();
};
// this is called just before our window will be shown for the first time.
// we must create NanoVega context here, as it needs to initialize
// internal OpenGL subsystem with valid OpenGL context.
sdmain.visibleForTheFirstTime = delegate () {
// yes, that's all
nvg = nvgCreateContext();
if (nvg is null) assert(0, "cannot initialize NanoVega");
};
// this callback will be called when we will need to repaint our window
sdmain.redrawOpenGlScene = delegate () {
// fix viewport (we can do this in resize event, or here, it doesn't matter)
glViewport(0, 0, sdmain.width, sdmain.height);
// clear window
glClearColor(0, 0, 0, 0);
glClear(glNVGClearFlags); // use NanoVega API to get flags for OpenGL call
{
nvg.beginFrame(sdmain.width, sdmain.height); // begin rendering
scope(exit) nvg.endFrame(); // and flush render queue on exit
nvg.beginPath(); // start new path
nvg.roundedRect(20.5, 30.5, sdmain.width-40, sdmain.height-60, 8); // .5 to draw at pixel center (see NanoVega documentation)
// now set filling mode for our rectangle
// you can create colors using HTML syntax, or with convenient constants
nvg.fillPaint = nvg.linearGradient(20.5, 30.5, sdmain.width-40, sdmain.height-60, NVGColor("#f70"), NVGColor.green);
// now fill our rect
nvg.fill();
// and draw a nice outline
nvg.strokeColor = NVGColor.white;
nvg.strokeWidth = 2;
nvg.stroke();
// that's all, folks!
}
};
sdmain.eventLoop(0, // no pulse timer required
delegate (KeyEvent event) {
if (event == "*-Q" || event == "Escape") { sdmain.close(); return; } // quit on Q, Ctrl+Q, and so on
},
);
flushGui(); // let OS do it's cleanup
window.eventLoop(0,
delegate (KeyEvent event) {
if (event == "*-Q" || event == "Escape") { window.close(); return; } // quit on Q, Ctrl+Q, and so on
},
);
}
---
)
@ -470,6 +431,79 @@ The following code illustrates the OpenGL state touched by the rendering code:
TODO for Ketmar: write some nice example code here, and finish documenting FontStash API.
*/
module arsd.nanovega;
/// This example shows how to do the NanoVega sample without the [NVGWindow] helper class.
unittest {
import arsd.simpledisplay;
import arsd.nanovega;
void main () {
NVGContext nvg; // our NanoVega context
// we need at least OpenGL3 with GLSL to use NanoVega,
// so let's tell simpledisplay about that
setOpenGLContextVersion(3, 0);
// now create OpenGL window
auto sdmain = new SimpleWindow(800, 600, "NanoVega Simple Sample", OpenGlOptions.yes, Resizability.allowResizing);
// we need to destroy NanoVega context on window close
// stricly speaking, it is not necessary, as nothing fatal
// will happen if you'll forget it, but let's be polite.
// note that we cannot do that *after* our window was closed,
// as we need alive OpenGL context to do proper cleanup.
sdmain.onClosing = delegate () {
nvg.kill();
};
// this is called just before our window will be shown for the first time.
// we must create NanoVega context here, as it needs to initialize
// internal OpenGL subsystem with valid OpenGL context.
sdmain.visibleForTheFirstTime = delegate () {
// yes, that's all
nvg = nvgCreateContext();
if (nvg is null) assert(0, "cannot initialize NanoVega");
};
// this callback will be called when we will need to repaint our window
sdmain.redrawOpenGlScene = delegate () {
// fix viewport (we can do this in resize event, or here, it doesn't matter)
glViewport(0, 0, sdmain.width, sdmain.height);
// clear window
glClearColor(0, 0, 0, 0);
glClear(glNVGClearFlags); // use NanoVega API to get flags for OpenGL call
{
nvg.beginFrame(sdmain.width, sdmain.height); // begin rendering
scope(exit) nvg.endFrame(); // and flush render queue on exit
nvg.beginPath(); // start new path
nvg.roundedRect(20.5, 30.5, sdmain.width-40, sdmain.height-60, 8); // .5 to draw at pixel center (see NanoVega documentation)
// now set filling mode for our rectangle
// you can create colors using HTML syntax, or with convenient constants
nvg.fillPaint = nvg.linearGradient(20.5, 30.5, sdmain.width-40, sdmain.height-60, NVGColor("#f70"), NVGColor.green);
// now fill our rect
nvg.fill();
// and draw a nice outline
nvg.strokeColor = NVGColor.white;
nvg.strokeWidth = 2;
nvg.stroke();
// that's all, folks!
}
};
sdmain.eventLoop(0, // no pulse timer required
delegate (KeyEvent event) {
if (event == "*-Q" || event == "Escape") { sdmain.close(); return; } // quit on Q, Ctrl+Q, and so on
},
);
flushGui(); // let OS do it's cleanup
}
}
private:
version(aliced) {

5
simpleaudio.d
View File

@ -215,7 +215,10 @@ interface SampleController {
bool finished();
/++
If the sample has beend paused.
If the sample has been paused.
History:
Added May 26, 2021 (dub v10.0)
+/
bool paused();
}

28
simpledisplay.d
View File

@ -1109,7 +1109,8 @@ version(Windows) {
pragma(lib, "user32");
// for AlphaBlend... a breaking change....
pragma(lib, "msimg32");
version(CRuntime_DigitalMars) { } else
pragma(lib, "msimg32");
} else version (linux) {
//k8: this is hack for rdmd. sorry.
static import core.sys.linux.epoll;
@ -5051,8 +5052,8 @@ void getClipboardImage()(SimpleWindow clipboardOwner, void delegate(MemoryImage)
version(Windows)
struct WCharzBuffer {
wchar[256] staticBuffer;
wchar[] buffer;
wchar[256] staticBuffer = void;
size_t length() {
return buffer.length;
@ -6126,7 +6127,11 @@ version (X11) {
}
}
///
/++
Sends a fake press key event.
Please note you need to call [flushGui] or return to the event loop for this to actually be sent.
+/
void pressKey(Key key, bool pressed, int delay = 0) {
XTestFakeKeyEvent(XDisplayConnection.get, XKeysymToKeycode(XDisplayConnection.get, key), pressed, delay + pressed ? 0 : 5);
}
@ -8532,6 +8537,11 @@ class Sprite : CapableOfBeingDrawnUpon {
xrenderPicture = XRenderCreatePicture(display, handle, ARGB32, 0, &attrs);
}
} else version(Windows) {
version(CRuntime_DigitalMars) {
//if(enableAlpha)
//throw new Exception("Alpha support not available, try recompiling with -m32mscoff");
}
BITMAPINFO infoheader;
infoheader.bmiHeader.biSize = infoheader.bmiHeader.sizeof;
infoheader.bmiHeader.biWidth = width;
@ -9973,6 +9983,8 @@ version(Windows) {
GetObject(s.handle, bm.sizeof, &bm);
version(CRuntime_DigitalMars) goto noalpha;
// or should I AlphaBlend!??!?! note it is supposed to be premultiplied http://www.fengyuan.com/article/alphablend.html
if(s.enableAlpha) {
auto dw = w ? w : bm.bmWidth;
@ -9982,8 +9994,10 @@ version(Windows) {
bf.SourceConstantAlpha = 255;
bf.AlphaFormat = AC_SRC_ALPHA;
AlphaBlend(hdc, x, y, dw, dh, hdcMem, ix, iy, dw, dh, bf);
} else
} else {
noalpha:
BitBlt(hdc, x, y, w ? w : bm.bmWidth, h ? h : bm.bmHeight, hdcMem, ix, iy, SRCCOPY);
}
SelectObject(hdcMem, hbmOld);
DeleteDC(hdcMem);
@ -10974,8 +10988,9 @@ version(X11) {
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
xfontstr = "-*-fixed-medium-r-*-*-13-*-*-*-*-*-*-*";
if(font is null)
font = XLoadQueryFont(display, "-*-fixed-medium-r-*-*-13-*-*-*-*-*-*-*".ptr);
font = XLoadQueryFont(display, xfontstr.ptr);
char** lol;
int lol2;
@ -11096,6 +11111,8 @@ version(X11) {
xftDraw = null;
}
/+
// this should prolly legit never be used since if it destroys the font handle from a OperatingSystemFont, it also ruins a reusable resource.
if(font && font !is defaultfont) {
XFreeFont(display, font);
font = null;
@ -11104,6 +11121,7 @@ version(X11) {
XFreeFontSet(display, fontset);
fontset = null;
}
+/
XFlush(display);
if(window.paintingFinishedDg !is null)

316
terminal.d
View File

@ -976,10 +976,10 @@ struct Terminal {
uint tcaps;
bool inlineImagesSupported() {
bool inlineImagesSupported() const {
return (tcaps & TerminalCapabilities.arsdImage) ? true : false;
}
bool clipboardSupported() {
bool clipboardSupported() const {
version(Win32Console) return true;
else return (tcaps & TerminalCapabilities.arsdClipboard) ? true : false;
}
@ -1053,7 +1053,7 @@ struct Terminal {
}
// dependent on tcaps...
void displayInlineImage()(ubyte[] imageData) {
void displayInlineImage()(in ubyte[] imageData) {
if(inlineImagesSupported) {
import std.base64;
@ -1074,14 +1074,14 @@ struct Terminal {
}
}
void requestCopyToClipboard(string text) {
void requestCopyToClipboard(in char[] text) {
if(clipboardSupported) {
import std.base64;
writeStringRaw("\033]52;c;"~Base64.encode(cast(ubyte[])text)~"\007");
}
}
void requestCopyToPrimary(string text) {
void requestCopyToPrimary(in char[] text) {
if(clipboardSupported) {
import std.base64;
writeStringRaw("\033]52;p;"~Base64.encode(cast(ubyte[])text)~"\007");
@ -1842,11 +1842,14 @@ struct Terminal {
/// It is important to call this when you are finished writing for now if you are using the version=with_eventloop
void flush() {
version(TerminalDirectToEmulator)
if(pipeThroughStdOut) {
fflush(stdout);
fflush(stderr);
return;
}
if(windowGone)
return;
version(TerminalDirectToEmulator)
if(pipeThroughStdOut) {
fflush(stdout);
fflush(stderr);
return;
}
if(writeBuffer.length == 0)
return;
@ -5249,7 +5252,7 @@ class LineGetter {
}
cursorPosition++;
if(cursorPosition >= horizontalScrollPosition + availableLineLength())
if(cursorPosition > horizontalScrollPosition + availableLineLength())
horizontalScrollPosition++;
lineChanged = true;
@ -5384,7 +5387,7 @@ class LineGetter {
}
int availableLineLength() {
return terminal.width - startOfLineX - promptLength - 1;
return maximumDrawWidth - promptLength - 1;
}
@ -5494,6 +5497,43 @@ class LineGetter {
}
/++
If you are implementing a subclass, use this instead of `terminal.width` to see how far you can draw. Use care to remember this is a width, not a right coordinate.
History:
Added May 24, 2021
+/
final public @property int maximumDrawWidth() {
auto tw = terminal.width - startOfLineX;
if(_drawWidthMax && _drawWidthMax <= tw)
return _drawWidthMax;
return tw;
}
/++
Sets the maximum width the line getter will use. Set to 0 to disable, in which case it will use the entire width of the terminal.
History:
Added May 24, 2021
+/
final public @property void maximumDrawWidth(int newMax) {
_drawWidthMax = newMax;
}
/++
Returns the maximum vertical space available to draw.
Currently, this is always 1.
History:
Added May 24, 2021
+/
@property int maximumDrawHeight() {
return 1;
}
private int _drawWidthMax = 0;
private int lastDrawLength = 0;
void redraw() {
finalizeRedraw(coreRedraw());
@ -5503,12 +5543,12 @@ class LineGetter {
if(!cdi.populated)
return;
if(UseVtSequences) {
if(UseVtSequences && !_drawWidthMax) {
terminal.writeStringRaw("\033[K");
} else {
// FIXME: graphemes
if(cdi.written < lastDrawLength)
foreach(i; cdi.written .. lastDrawLength)
if(cdi.written + promptLength < lastDrawLength)
foreach(i; cdi.written + promptLength .. lastDrawLength)
terminal.write(" ");
lastDrawLength = cdi.written;
}
@ -5637,7 +5677,7 @@ class LineGetter {
else {
// otherwise just try to center it in the screen
horizontalScrollPosition = cursorPosition;
horizontalScrollPosition -= terminal.width / 2;
horizontalScrollPosition -= maximumDrawWidth / 2;
// align on a code point boundary
aligned(horizontalScrollPosition, -1);
if(horizontalScrollPosition < 0)
@ -5664,7 +5704,7 @@ class LineGetter {
positionCursor();
}
lastDrawLength = terminal.width - terminal.cursorX;
lastDrawLength = maximumDrawWidth;
version(Win32Console)
lastDrawLength -= 1; // I don't like this but Windows resizing is different anyway and it is liable to scroll if i go over..
@ -5907,7 +5947,7 @@ class LineGetter {
// but i do need to ensure we clear any
// stuff left on the screen from it.
lastDrawLength = terminal.width - 1;
lastDrawLength = maximumDrawWidth - 1;
supplementalGetter = null;
redraw();
}
@ -6534,7 +6574,7 @@ class HistorySearchLineGetter : LineGetter {
}
override void initializeWithSize(bool firstEver = false) {
if(terminal.width > 60)
if(maximumDrawWidth > 60)
this.prompt = "(history search): \"";
else
this.prompt = "(hs): \"";
@ -6542,7 +6582,7 @@ class HistorySearchLineGetter : LineGetter {
}
override int availableLineLength() {
return terminal.width / 2 - startOfLineX - promptLength - 1;
return maximumDrawWidth / 2 - promptLength - 1;
}
override void loadFromHistory(int howFarBack) {
@ -6589,12 +6629,12 @@ class HistorySearchLineGetter : LineGetter {
auto cri = coreRedraw();
terminal.write("\" ");
int available = terminal.width / 2 - 1;
int available = maximumDrawWidth / 2 - 1;
auto used = prompt.length + cri.written + 3 /* the write above plus a space */;
if(used < available)
available += available - used;
//terminal.moveTo(terminal.width / 2, startOfLineY);
//terminal.moveTo(maximumDrawWidth / 2, startOfLineY);
Drawer drawer = Drawer(this);
drawer.lineLength = available;
drawer.drawContent(sideDisplay, highlightBegin, highlightEnd);
@ -6713,105 +6753,225 @@ version(Windows) {
that widget here too. */
/++
The ScrollbackBuffer is a writable in-memory terminal that can be drawn to a real [Terminal]
and maintain some internal position state by handling events. It is your responsibility to
draw it (using the [drawInto] method) and dispatch events to its [handleEvent] method (if you
want to, you can also just call the methods yourself).
I originally wrote this to support my irc client and some of the features are geared toward
helping with that (for example, [name] and [demandsAttention]), but the main thrust is to
support either tabs or sub-sections of the terminal having their own output that can be displayed
and scrolled back independently while integrating with some larger application.
History:
Committed to git on August 4, 2015.
Cleaned up and documented on May 25, 2021.
+/
struct ScrollbackBuffer {
/++
A string you can set and process on your own. The library only sets it from the
constructor, then leaves it alone.
bool demandsAttention;
In my irc client, I use this as the title of a tab I draw to indicate separate
conversations.
+/
public string name;
/++
A flag you can set and process on your own. All the library does with it is
set it to false when it handles an event, otherwise you can do whatever you
want with it.
In my irc client, I use this to add a * to the tab to indicate new messages.
+/
public bool demandsAttention;
/++
The coordinates of the last [drawInto]
+/
int x, y, width, height;
private CircularBuffer!Line lines;
private bool eol; // if the last line had an eol, next append needs a new line. doing this means we won't have a spurious blank line at the end of the draw-in
/++
Property to control the current scrollback position. 0 = latest message
at bottom of screen.
See_Also: [scrollToBottom], [scrollToTop], [scrollUp], [scrollDown], [scrollTopPosition]
+/
@property int scrollbackPosition() const pure @nogc nothrow @safe {
return scrollbackPosition_;
}
/// ditto
private @property void scrollbackPosition(int p) pure @nogc nothrow @safe {
scrollbackPosition_ = p;
}
private int scrollbackPosition_;
/++
This is the color it uses to clear the screen.
History:
Added May 26, 2021
+/
public Color defaultForeground = Color.DEFAULT;
/// ditto
public Color defaultBackground = Color.DEFAULT;
private int foreground_ = Color.DEFAULT, background_ = Color.DEFAULT;
/++
The name is for your own use only. I use the name as a tab title but you could ignore it and just pass `null` too.
+/
this(string name) {
this.name = name;
}
/++
Writing into the scrollback buffer can be done with the same normal functions.
Note that you will have to call [redraw] yourself to make this actually appear on screen.
+/
void write(T...)(T t) {
import std.conv : text;
addComponent(text(t), foreground_, background_, null);
}
/// ditto
void writeln(T...)(T t) {
write(t, "\n");
}
/// ditto
void writef(T...)(string fmt, T t) {
import std.format: format;
write(format(fmt, t));
}
/// ditto
void writefln(T...)(string fmt, T t) {
writef(fmt, t, "\n");
}
void clear() {
lines.clear();
clickRegions = null;
scrollbackPosition = 0;
}
int foreground_ = Color.DEFAULT, background_ = Color.DEFAULT;
/// ditto
void color(int foreground, int background) {
this.foreground_ = foreground;
this.background_ = background;
}
/++
Clears the scrollback buffer.
+/
void clear() {
lines.clear();
clickRegions = null;
scrollbackPosition_ = 0;
}
/++
+/
void addComponent(string text, int foreground, int background, bool delegate() onclick) {
if(lines.length == 0) {
addComponent(LineComponent(text, foreground, background, onclick));
}
/++
+/
void addComponent(LineComponent component) {
if(lines.length == 0 || eol) {
addLine();
eol = false;
}
bool first = true;
import std.algorithm;
foreach(t; splitter(text, "\n")) {
if(component.text.length && component.text[$-1] == '\n') {
eol = true;
component.text = component.text[0 .. $ - 1];
}
foreach(t; splitter(component.text, "\n")) {
if(!first) addLine();
first = false;
lines[$-1].components ~= LineComponent(t, foreground, background, onclick);
auto c = component;
c.text = t;
lines[$-1].components ~= c;
}
}
/++
Adds an empty line.
+/
void addLine() {
lines ~= Line();
if(scrollbackPosition) // if the user is scrolling back, we want to keep them basically centered where they are
scrollbackPosition++;
if(scrollbackPosition_) // if the user is scrolling back, we want to keep them basically centered where they are
scrollbackPosition_++;
}
/++
This is what [writeln] actually calls.
Using this exclusively though can give you more control, especially over the trailing \n.
+/
void addLine(string line) {
lines ~= Line([LineComponent(line)]);
if(scrollbackPosition) // if the user is scrolling back, we want to keep them basically centered where they are
scrollbackPosition++;
if(scrollbackPosition_) // if the user is scrolling back, we want to keep them basically centered where they are
scrollbackPosition_++;
}
/++
Scrolling controls.
Notice that `scrollToTop` needs width and height to know how to word wrap it to determine the number of lines present to scroll back.
+/
void scrollUp(int lines = 1) {
scrollbackPosition += lines;
scrollbackPosition_ += lines;
//if(scrollbackPosition >= this.lines.length)
// scrollbackPosition = cast(int) this.lines.length - 1;
}
/// ditto
void scrollDown(int lines = 1) {
scrollbackPosition -= lines;
if(scrollbackPosition < 0)
scrollbackPosition = 0;
scrollbackPosition_ -= lines;
if(scrollbackPosition_ < 0)
scrollbackPosition_ = 0;
}
/// ditto
void scrollToBottom() {
scrollbackPosition = 0;
scrollbackPosition_ = 0;
}
// this needs width and height to know how to word wrap it
/// ditto
void scrollToTop(int width, int height) {
scrollbackPosition = scrollTopPosition(width, height);
scrollbackPosition_ = scrollTopPosition(width, height);
}
/++
You can construct these to get more control over specifics including
setting RGB colors.
But generally just using [write] and friends is easier.
+/
struct LineComponent {
string text;
bool isRgb;
union {
private string text;
private bool isRgb;
private union {
int color;
RGB colorRgb;
}
union {
private union {
int background;
RGB backgroundRgb;
}
bool delegate() onclick; // return true if you need to redraw
private bool delegate() onclick; // return true if you need to redraw
// 16 color ctor
this(string text, int color = Color.DEFAULT, int background = Color.DEFAULT, bool delegate() onclick = null) {
@ -6832,7 +6992,7 @@ struct ScrollbackBuffer {
}
}
struct Line {
private struct Line {
LineComponent[] components;
int length() {
int l = 0;
@ -6842,6 +7002,13 @@ struct ScrollbackBuffer {
}
}
/++
This is an internal helper for its scrollback buffer.
It is fairly generic and I might move it somewhere else some day.
It has a compile-time specified limit of 8192 entries.
+/
static struct CircularBuffer(T) {
T[] backing;
@ -6922,14 +7089,11 @@ struct ScrollbackBuffer {
Dollar opDollar() { return Dollar(0); }
}
CircularBuffer!Line lines;
string name;
int x, y, width, height;
int scrollbackPosition;
/++
Given a size, how far would you have to scroll back to get to the top?
Please note that this is O(n) with the length of the scrollback buffer.
+/
int scrollTopPosition(int width, int height) {
int lineCount;
@ -6957,6 +7121,11 @@ struct ScrollbackBuffer {
//return 0;
}
/++
Draws the current state into the given terminal inside the given bounding box.
Also updates its internal position and click region data which it uses for event filtering in [handleEvent].
+/
void drawInto(Terminal* terminal, in int x = 0, in int y = 0, int width = 0, int height = 0) {
if(lines.length == 0)
return;
@ -7072,7 +7241,10 @@ struct ScrollbackBuffer {
if(component.isRgb)
terminal.setTrueColor(component.colorRgb, component.backgroundRgb);
else
terminal.color(component.color, component.background);
terminal.color(
component.color == Color.DEFAULT ? defaultForeground : component.color,
component.background == Color.DEFAULT ? defaultBackground : component.background,
);
auto towrite = component.text;
again:
@ -7109,7 +7281,7 @@ struct ScrollbackBuffer {
}
if(written < width) {
terminal.color(Color.DEFAULT, Color.DEFAULT);
terminal.color(defaultForeground, defaultBackground);
foreach(i; written .. width)
terminal.write(" ");
}
@ -7121,7 +7293,7 @@ struct ScrollbackBuffer {
}
if(linePos < height) {
terminal.color(Color.DEFAULT, Color.DEFAULT);
terminal.color(defaultForeground, defaultBackground);
foreach(i; linePos .. height) {
if(i >= 0 && i < height) {
terminal.moveTo(x, y + i);
@ -7140,11 +7312,13 @@ struct ScrollbackBuffer {
}
private ClickRegion[] clickRegions;
/// Default event handling for this widget. Call this only after drawing it into a rectangle
/// and only if the event ought to be dispatched to it (which you determine however you want;
/// you could dispatch all events to it, or perhaps filter some out too)
///
/// Returns true if it should be redrawn
/++
Default event handling for this widget. Call this only after drawing it into a rectangle
and only if the event ought to be dispatched to it (which you determine however you want;
you could dispatch all events to it, or perhaps filter some out too)
Returns: true if it should be redrawn
+/
bool handleEvent(InputEvent e) {
final switch(e.type) {
case InputEvent.Type.LinkEvent:
@ -7163,10 +7337,16 @@ struct ScrollbackBuffer {
scrollDown();
return true;
case KeyboardEvent.Key.PageUp:
scrollUp(height);
if(ev.modifierState & ModifierState.control)
scrollToTop(width, height);
else
scrollUp(height);
return true;
case KeyboardEvent.Key.PageDown:
scrollDown(height);
if(ev.modifierState & ModifierState.control)
scrollToBottom();
else
scrollDown(height);
return true;
default:
// ignore