Merge branch 'master' into master

examples/d3d/src/d3d.d

@@ -13,8 +13,7 @@ import dlangui.graphics.scene.objimport;
 import dlangui.graphics.scene.fbximport;
 import dlangui.graphics.glsupport;
 import dlangui.graphics.gldrawbuf;
-import derelict.opengl3.gl3;
+import derelict.opengl.gl;
-import derelict.opengl3.gl;
 
 mixin APP_ENTRY_POINT;
 

examples/example1/dub.json

@@ -11,8 +11,6 @@
 
     "stringImportPaths": ["views", "views/res", "views/res/i18n", "views/res/mdpi"],
 
-    "sourceFiles-windows": ["$PACKAGE_DIR/src/win_app.def"],
-
     "versions": ["ForceLogs"],
 
     "dependencies": {
@@ -20,7 +18,7 @@
     },
     "configurations" : [
         {
-            "name" : "default",
+            "name" : "default"
         }, 
         {
             "name" : "console",

examples/example1/src/win_app.def

@@ -1,2 +0,0 @@
-EXETYPE NT
-SUBSYSTEM WINDOWS

examples/spreadsheet/src/dlangui/widgets/spreadsheet.d

@@ -43,6 +43,8 @@ class SheetEditControl : HorizontalLayout {
 }
 
 class SpreadSheetView : StringGridWidget {
+    import std.conv: to;
+
     this(string ID = null) {
         super(ID);
         layoutWidth = FILL_PARENT;

examples/spreadsheet/src/spreadsheetapp.d

@@ -130,15 +130,15 @@ class EditFrame : AppFrame {
                         window.close();
                     return true;
                 case IDEActions.HelpAbout:
-                    window.showMessageBox(UIString("About DlangUI ML Editor"d),
+                    window.showMessageBox(UIString.fromRaw("About DlangUI ML Editor"d),
-                                          UIString("DLangIDE\n(C) Vadim Lopatin, 2015\nhttp://github.com/buggins/dlangui\nSimple editor for DML code"d));
+                                          UIString.fromRaw("DLangIDE\n(C) Vadim Lopatin, 2015\nhttp://github.com/buggins/dlangui\nSimple editor for DML code"d));
                     return true;
                 case IDEActions.FileNew:
                     UIString caption;
                     caption = "Create new DML file"d;
                     FileDialog dlg = createFileDialog(caption, false);
-                    dlg.addFilter(FileFilterEntry(UIString("DML files"d), "*.dml"));
+                    dlg.addFilter(FileFilterEntry(UIString.fromRaw("DML files"d), "*.dml"));
-                    dlg.addFilter(FileFilterEntry(UIString("All files"d), "*.*"));
+                    dlg.addFilter(FileFilterEntry(UIString.fromRaw("All files"d), "*.*"));
                     dlg.dialogResult = delegate(Dialog dlg, const Action result) {
                         if (result.id == ACTION_OPEN.id) {
                             string filename = result.stringParam;
@@ -156,8 +156,8 @@ class EditFrame : AppFrame {
                     UIString caption;
                     caption = "Save DML File as"d;
                     FileDialog dlg = createFileDialog(caption, false);
-                    dlg.addFilter(FileFilterEntry(UIString("DML files"d), "*.dml"));
+                    dlg.addFilter(FileFilterEntry(UIString.fromRaw("DML files"d), "*.dml"));
-                    dlg.addFilter(FileFilterEntry(UIString("All files"d), "*.*"));
+                    dlg.addFilter(FileFilterEntry(UIString.fromRaw("All files"d), "*.*"));
                     dlg.dialogResult = delegate(Dialog dlg, const Action result) {
                         if (result.id == ACTION_OPEN.id) {
                             string filename = result.stringParam;
@@ -170,8 +170,8 @@ class EditFrame : AppFrame {
                     UIString caption;
                     caption = "Open DML File"d;
                     FileDialog dlg = createFileDialog(caption);
-                    dlg.addFilter(FileFilterEntry(UIString("DML files"d), "*.dml"));
+                    dlg.addFilter(FileFilterEntry(UIString.fromRaw("DML files"d), "*.dml"));
-                    dlg.addFilter(FileFilterEntry(UIString("All files"d), "*.*"));
+                    dlg.addFilter(FileFilterEntry(UIString.fromRaw("All files"d), "*.*"));
                     dlg.dialogResult = delegate(Dialog dlg, const Action result) {
                         if (result.id == ACTION_OPEN.id) {
                             string filename = result.stringParam;

examples/tetris/src/gui.d

@@ -3,6 +3,7 @@ module gui;
 import model;
 
 import dlangui;
+import std.algorithm;
 
 /// game action codes
 enum TetrisAction : int {
@@ -559,6 +560,7 @@ class StatusWidget : VerticalLayout {
 
     /// Measure widget according to desired width and height constraints. (Step 1 of two phase layout).
     override void measure(int parentWidth, int parentHeight) {
+        import std.algorithm: min;
         int minw = min(parentWidth, parentHeight);
         foreach(lbl; _labels) {
             lbl.fontSize = minw / 20;

src/dlangui/core/i18n.d

@@ -126,13 +126,13 @@ struct UIString {
         _value = newValue;
     }
     /** Assign raw value */
-    ref UIString opAssign(dstring rawValue) {
+    ref UIString opAssign(dstring rawValue) return {
         _value = rawValue;
         _id = null;
         return this;
     }
     /** Assign string resource id */
-    ref UIString opAssign(string ID) {
+    ref UIString opAssign(string ID) return {
         _id = ID;
         _value = null;
         return this;

src/dlangui/core/math3d.d

@@ -35,63 +35,63 @@ struct vec2 {
         vec[0] = x;
         vec[1] = y;
     }
-    ref vec2 opAssign(float[2] v) {
+    ref vec2 opAssign(float[2] v) return {
         vec = v;
         return this;
     }
-    ref vec2 opAssign(vec2 v) {
+    ref vec2 opAssign(vec2 v) return {
         vec = v.vec;
         return this;
     }
     /// fill all components of vector with specified value
-    ref vec2 clear(float v) {
+    ref vec2 clear(float v) return {
         vec[0] = vec[1] = v;
         return this;
     }
     /// add value to all components of vector
-    ref vec2 add(float v) {
+    ref vec2 add(float v) return {
         vec[0] += v;
         vec[1] += v;
         return this;
     }
     /// multiply all components of vector by value
-    ref vec2 mul(float v) {
+    ref vec2 mul(float v) return {
         vec[0] *= v;
         vec[1] *= v;
         return this;
     }
     /// subtract value from all components of vector
-    ref vec2 sub(float v) {
+    ref vec2 sub(float v) return {
         vec[0] -= v;
         vec[1] -= v;
         return this;
     }
     /// divide all components of vector by value
-    ref vec2 div(float v) {
+    ref vec2 div(float v) return {
         vec[0] /= v;
         vec[1] /= v;
         return this;
     }
     /// add components of another vector to corresponding components of this vector
-    ref vec2 add(vec2 v) {
+    ref vec2 add(vec2 v) return {
         vec[0] += v.vec[0];
         vec[1] += v.vec[1];
         return this;
     }
     /// multiply components of this vector  by corresponding components of another vector
-    ref vec2 mul(vec2 v) {
+    ref vec2 mul(vec2 v) return {
         vec[0] *= v.vec[0];
         vec[1] *= v.vec[1];
         return this;
     }
     /// subtract components of another vector from corresponding components of this vector
-    ref vec2 sub(vec2 v) {
+    ref vec2 sub(vec2 v) return {
         vec[0] -= v.vec[0];
         vec[1] -= v.vec[1];
         return this;
     }
     /// divide components of this vector  by corresponding components of another vector
-    ref vec2 div(vec2 v) {
+    ref vec2 div(vec2 v) return {
         vec[0] /= v.vec[0];
         vec[1] /= v.vec[1];
         return this;
@@ -138,26 +138,26 @@ struct vec2 {
 
 
     /// add value to all components of vector
-    ref vec2 opOpAssign(string op : "+")(float v) {
+    ref vec2 opOpAssign(string op : "+")(float v) return {
         vec[0] += v;
         vec[1] += v;
         return this;
     }
     /// multiply all components of vector by value
-    ref vec2 opOpAssign(string op : "*")(float v) {
+    ref vec2 opOpAssign(string op : "*")(float v) return {
         vec[0] *= v;
         vec[1] *= v;
         return this;
     }
     /// subtract value from all components of vector
-    ref vec2 opOpAssign(string op : "-")(float v) {
+    ref vec2 opOpAssign(string op : "-")(float v) return {
         vec[0] -= v;
         vec[1] -= v;
         vec[2] -= v;
         return this;
     }
     /// divide all components of vector by value
-    ref vec2 opOpAssign(string op : "/")(float v) {
+    ref vec2 opOpAssign(string op : "/")(float v) return {
         vec[0] /= v;
         vec[1] /= v;
         vec[2] /= v;
@@ -165,25 +165,25 @@ struct vec2 {
     }
 
     /// by component add values of corresponding components of other vector
-    ref vec2 opOpAssign(string op : "+")(const vec2 v) {
+    ref vec2 opOpAssign(string op : "+")(const vec2 v) return {
         vec[0] += v.vec[0];
         vec[1] += v.vec[1];
         return this;
     }
     /// by component multiply values of corresponding components of other vector
-    ref vec2 opOpAssign(string op : "*")(const vec2 v) {
+    ref vec2 opOpAssign(string op : "*")(const vec2 v) return {
         vec[0] *= v.vec[0];
         vec[1] *= v.vec[1];
         return this;
     }
     /// by component subtract values of corresponding components of other vector
-    ref vec2 opOpAssign(string op : "-")(const vec2 v) {
+    ref vec2 opOpAssign(string op : "-")(const vec2 v) return {
         vec[0] -= v.vec[0];
         vec[1] -= v.vec[1];
         return this;
     }
     /// by component divide values of corresponding components of other vector
-    ref vec2 opOpAssign(string op : "/")(const vec2 v) {
+    ref vec2 opOpAssign(string op : "/")(const vec2 v) return {
         vec[0] /= v.vec[0];
         vec[1] /= v.vec[1];
         return this;
@@ -292,76 +292,76 @@ struct vec3 {
         vec[1] = y;
         vec[2] = z;
     }
-    ref vec3 opAssign(float[3] v) {
+    ref vec3 opAssign(float[3] v) return {
         vec = v;
         return this;
     }
-    ref vec3 opAssign(vec3 v) {
+    ref vec3 opAssign(vec3 v) return {
         vec = v.vec;
         return this;
     }
-    ref vec3 opAssign(float x, float y, float z) {
+    ref vec3 opAssign(float x, float y, float z) return {
         vec[0] = x;
         vec[1] = y;
         vec[2] = z;
         return this;
     }
     /// fill all components of vector with specified value
-    ref vec3 clear(float v) {
+    ref vec3 clear(float v) return {
         vec[0] = vec[1] = vec[2] = v;
         return this;
     }
     /// add value to all components of vector
-    ref vec3 add(float v) {
+    ref vec3 add(float v) return {
         vec[0] += v;
         vec[1] += v;
         vec[2] += v;
         return this;
     }
     /// multiply all components of vector by value
-    ref vec3 mul(float v) {
+    ref vec3 mul(float v) return {
         vec[0] *= v;
         vec[1] *= v;
         vec[2] *= v;
         return this;
     }
     /// subtract value from all components of vector
-    ref vec3 sub(float v) {
+    ref vec3 sub(float v) return {
         vec[0] -= v;
         vec[1] -= v;
         vec[2] -= v;
         return this;
     }
     /// divide all components of vector by value
-    ref vec3 div(float v) {
+    ref vec3 div(float v) return {
         vec[0] /= v;
         vec[1] /= v;
         vec[2] /= v;
         return this;
     }
     /// add components of another vector to corresponding components of this vector
-    ref vec3 add(vec3 v) {
+    ref vec3 add(vec3 v) return {
         vec[0] += v.vec[0];
         vec[1] += v.vec[1];
         vec[2] += v.vec[2];
         return this;
     }
     /// multiply components of this vector  by corresponding components of another vector
-    ref vec3 mul(vec3 v) {
+    ref vec3 mul(vec3 v) return {
         vec[0] *= v.vec[0];
         vec[1] *= v.vec[1];
         vec[2] *= v.vec[2];
         return this;
     }
     /// subtract components of another vector from corresponding components of this vector
-    ref vec3 sub(vec3 v) {
+    ref vec3 sub(vec3 v) return {
         vec[0] -= v.vec[0];
         vec[1] -= v.vec[1];
         vec[2] -= v.vec[2];
         return this;
     }
     /// divide components of this vector  by corresponding components of another vector
-    ref vec3 div(vec3 v) {
+    ref vec3 div(vec3 v) return {
         vec[0] /= v.vec[0];
         vec[1] /= v.vec[1];
         vec[2] /= v.vec[2];
@@ -599,22 +599,22 @@ struct vec4 {
         vec[2] = v.vec[2];
         vec[3] = 1.0f;
     }
-    ref vec4 opAssign(const float[4] v) {
+    ref vec4 opAssign(const float[4] v) return {
         vec = v;
         return this;
     }
-    ref vec4 opAssign(const vec4 v) {
+    ref vec4 opAssign(const vec4 v) return {
         vec = v.vec;
         return this;
     }
-    ref vec4 opAssign(float x, float y, float z, float w) {
+    ref vec4 opAssign(float x, float y, float z, float w) return {
         vec[0] = x;
         vec[1] = y;
         vec[2] = z;
         vec[3] = w;
         return this;
     }
-    ref vec4 opAssign(const vec3 v) {
+    ref vec4 opAssign(const vec3 v) return {
         vec[0] = v.vec[0];
         vec[1] = v.vec[1];
         vec[2] = v.vec[2];
@@ -624,12 +624,12 @@ struct vec4 {
 
 
     /// fill all components of vector with specified value
-    ref vec4 clear(float v) {
+    ref vec4 clear(float v) return {
         vec[0] = vec[1] = vec[2] = vec[3] = v;
         return this;
     }
     /// add value to all components of vector
-    ref vec4 add(float v) {
+    ref vec4 add(float v) return {
         vec[0] += v;
         vec[1] += v;
         vec[2] += v;
@@ -637,7 +637,7 @@ struct vec4 {
         return this;
     }
     /// multiply all components of vector by value
-    ref vec4 mul(float v) {
+    ref vec4 mul(float v) return {
         vec[0] *= v;
         vec[1] *= v;
         vec[2] *= v;
@@ -645,7 +645,7 @@ struct vec4 {
         return this;
     }
     /// subtract value from all components of vector
-    ref vec4 sub(float v) {
+    ref vec4 sub(float v) return {
         vec[0] -= v;
         vec[1] -= v;
         vec[2] -= v;
@@ -653,7 +653,7 @@ struct vec4 {
         return this;
     }
     /// divide all components of vector by value
-    ref vec4 div(float v) {
+    ref vec4 div(float v) return {
         vec[0] /= v;
         vec[1] /= v;
         vec[2] /= v;
@@ -661,7 +661,7 @@ struct vec4 {
         return this;
     }
     /// add components of another vector to corresponding components of this vector
-    ref vec4 add(const vec4 v) {
+    ref vec4 add(const vec4 v) return {
         vec[0] += v.vec[0];
         vec[1] += v.vec[1];
         vec[2] += v.vec[2];
@@ -669,7 +669,7 @@ struct vec4 {
         return this;
     }
     /// multiply components of this vector  by corresponding components of another vector
-    ref vec4 mul(vec4 v) {
+    ref vec4 mul(vec4 v) return {
         vec[0] *= v.vec[0];
         vec[1] *= v.vec[1];
         vec[2] *= v.vec[2];
@@ -677,7 +677,7 @@ struct vec4 {
         return this;
     }
     /// subtract components of another vector from corresponding components of this vector
-    ref vec4 sub(vec4 v) {
+    ref vec4 sub(vec4 v) return {
         vec[0] -= v.vec[0];
         vec[1] -= v.vec[1];
         vec[2] -= v.vec[2];
@@ -685,7 +685,7 @@ struct vec4 {
         return this;
     }
     /// divide components of this vector  by corresponding components of another vector
-    ref vec4 div(vec4 v) {
+    ref vec4 div(vec4 v) return {
         vec[0] /= v.vec[0];
         vec[1] /= v.vec[1];
         vec[2] /= v.vec[2];
@@ -694,7 +694,7 @@ struct vec4 {
     }
 
     /// add value to all components of vector
-    vec4 opBinary(string op : "+")(float v) const {
+    vec4 opBinary(string op : "+")(float v) const return {
         vec4 res = this;
         res.vec[0] += v;
         res.vec[1] += v;
@@ -703,7 +703,7 @@ struct vec4 {
         return res;
     }
     /// multiply all components of vector by value
-    vec4 opBinary(string op : "*")(float v) const {
+    vec4 opBinary(string op : "*")(float v) const return {
         vec4 res = this;
         res.vec[0] *= v;
         res.vec[1] *= v;
@@ -712,7 +712,7 @@ struct vec4 {
         return res;
     }
     /// subtract value from all components of vector
-    vec4 opBinary(string op : "-")(float v) const {
+    vec4 opBinary(string op : "-")(float v) const return {
         vec4 res = this;
         res.vec[0] -= v;
         res.vec[1] -= v;
@@ -721,7 +721,7 @@ struct vec4 {
         return res;
     }
     /// divide all components of vector by value
-    vec4 opBinary(string op : "/")(float v) const {
+    vec4 opBinary(string op : "/")(float v) const return {
         vec4 res = this;
         res.vec[0] /= v;
         res.vec[1] /= v;
@@ -731,7 +731,7 @@ struct vec4 {
     }
 
     /// add value to all components of vector
-    ref vec4 opOpAssign(string op : "+")(float v) {
+    ref vec4 opOpAssign(string op : "+")(float v) return {
         vec[0] += v;
         vec[1] += v;
         vec[2] += v;
@@ -739,7 +739,7 @@ struct vec4 {
         return this;
     }
     /// multiply all components of vector by value
-    ref vec4 opOpAssign(string op : "*")(float v) {
+    ref vec4 opOpAssign(string op : "*")(float v) return {
         vec[0] *= v;
         vec[1] *= v;
         vec[2] *= v;
@@ -747,7 +747,7 @@ struct vec4 {
         return this;
     }
     /// subtract value from all components of vector
-    ref vec4 opOpAssign(string op : "-")(float v) {
+    ref vec4 opOpAssign(string op : "-")(float v) return {
         vec[0] -= v;
         vec[1] -= v;
         vec[2] -= v;
@@ -755,7 +755,7 @@ struct vec4 {
         return this;
     }
     /// divide all components of vector by value
-    ref vec4 opOpAssign(string op : "/")(float v) {
+    ref vec4 opOpAssign(string op : "/")(float v) return {
         vec[0] /= v;
         vec[1] /= v;
         vec[2] /= v;
@@ -764,7 +764,7 @@ struct vec4 {
     }
 
     /// by component add values of corresponding components of other vector
-    ref vec4 opOpAssign(string op : "+")(const vec4 v) {
+    ref vec4 opOpAssign(string op : "+")(const vec4 v) return {
         vec[0] += v.vec[0];
         vec[1] += v.vec[1];
         vec[2] += v.vec[2];
@@ -772,7 +772,7 @@ struct vec4 {
         return this;
     }
     /// by component multiply values of corresponding components of other vector
-    ref vec4 opOpAssign(string op : "*")(const vec4 v) {
+    ref vec4 opOpAssign(string op : "*")(const vec4 v) return {
         vec[0] *= v.vec[0];
         vec[1] *= v.vec[1];
         vec[2] *= v.vec[2];
@@ -780,7 +780,7 @@ struct vec4 {
         return this;
     }
     /// by component subtract values of corresponding components of other vector
-    ref vec4 opOpAssign(string op : "-")(const vec4 v) {
+    ref vec4 opOpAssign(string op : "-")(const vec4 v) return {
         vec[0] -= v.vec[0];
         vec[1] -= v.vec[1];
         vec[2] -= v.vec[2];
@@ -788,7 +788,7 @@ struct vec4 {
         return this;
     }
     /// by component divide values of corresponding components of other vector
-    ref vec4 opOpAssign(string op : "/")(const vec4 v) {
+    ref vec4 opOpAssign(string op : "/")(const vec4 v) return {
         vec[0] /= v.vec[0];
         vec[1] /= v.vec[1];
         vec[2] /= v.vec[2];
@@ -799,7 +799,7 @@ struct vec4 {
 
 
     /// add value to all components of vector
-    vec4 opBinary(string op : "+")(const vec4 v) const {
+    vec4 opBinary(string op : "+")(const vec4 v) const return {
         vec4 res = this;
         res.vec[0] += v.vec[0];
         res.vec[1] += v.vec[1];
@@ -808,7 +808,7 @@ struct vec4 {
         return res;
     }
     /// subtract value from all components of vector
-    vec4 opBinary(string op : "-")(const vec4 v) const {
+    vec4 opBinary(string op : "-")(const vec4 v) const return {
         vec4 res = this;
         res.vec[0] -= v.vec[0];
         res.vec[1] -= v.vec[1];
@@ -831,7 +831,7 @@ struct vec4 {
     }
 
     /// returns vector with all components which are negative of components for this vector
-    vec4 opUnary(string op : "-")() const {
+    vec4 opUnary(string op : "-")() const return {
         vec4 ret = this;
         ret[0] = -vec[0];
         ret[1] = -vec[1];
@@ -860,7 +860,7 @@ struct vec4 {
     }
 
     /// returns normalized copy of this vector
-    @property vec4 normalized() {
+    @property vec4 normalized() return {
         vec4 res = this;
         res.normalize();
         return res;
@@ -920,15 +920,15 @@ struct mat4 {
         m[0..16] = v[0..16];
     }
 
-    ref mat4 opAssign(const ref mat4 v) {
+    ref mat4 opAssign(const ref mat4 v) return {
         m[0..16] = v.m[0..16];
         return this;
     }
-    ref mat4 opAssign(const  mat4 v) {
+    ref mat4 opAssign(const  mat4 v) return {
         m[0..16] = v.m[0..16];
         return this;
     }
-    ref mat4 opAssign(const float[16] v) {
+    ref mat4 opAssign(const float[16] v) return {
         m[0..16] = v[0..16];
         return this;
     }
@@ -992,7 +992,7 @@ struct mat4 {
         m[3*4 + 3] = 0.0f;
     }
 
-    ref mat4 lookAt(const vec3 eye, const vec3 center, const vec3 up) {
+    ref mat4 lookAt(const vec3 eye, const vec3 center, const vec3 up) return {
         vec3 forward = (center - eye).normalized();
         vec3 side = vec3.crossProduct(forward, up).normalized();
         vec3 upVector = vec3.crossProduct(side, forward);
@@ -1082,13 +1082,13 @@ struct mat4 {
         return inverse;
     }
 
-    ref mat4 setLookAt(const vec3 eye, const vec3 center, const vec3 up) {
+    ref mat4 setLookAt(const vec3 eye, const vec3 center, const vec3 up) return {
         setIdentity();
         lookAt(eye, center, up);
         return this;
     }
 
-    ref mat4 translate(const vec3 v) {
+    ref mat4 translate(const vec3 v) return {
         m[3*4 + 0] += m[0*4 + 0] * v.x + m[1*4 + 0] * v.y + m[2*4 + 0] * v.z;
         m[3*4 + 1] += m[0*4 + 1] * v.x + m[1*4 + 1] * v.y + m[2*4 + 1] * v.z;
         m[3*4 + 2] += m[0*4 + 2] * v.x + m[1*4 + 2] * v.y + m[2*4 + 2] * v.z;
@@ -1096,7 +1096,7 @@ struct mat4 {
         return this;
     }
 
-    ref mat4 translate(float x, float y, float z) {
+    ref mat4 translate(float x, float y, float z) return {
         m[3*4 + 0] += m[0*4 + 0] * x + m[1*4 + 0] * y + m[2*4 + 0] * z;
         m[3*4 + 1] += m[0*4 + 1] * x + m[1*4 + 1] * y + m[2*4 + 1] * z;
         m[3*4 + 2] += m[0*4 + 2] * x + m[1*4 + 2] * y + m[2*4 + 2] * z;
@@ -1274,31 +1274,31 @@ struct mat4 {
     }
 
     /// 2d index by row, col
-    ref float opIndex(int y, int x) {
+    ref float opIndex(int y, int x) return {
         return m[y*4 + x];
     }
 
     /// 2d index by row, col
-    float opIndex(int y, int x) const {
+    float opIndex(int y, int x) const return {
         return m[y*4 + x];
     }
 
     /// scalar index by rows then (y*4 + x)
-    ref float opIndex(int index) {
+    ref float opIndex(int index) return {
         return m[index];
     }
 
     /// scalar index by rows then (y*4 + x)
-    float opIndex(int index) const {
+    float opIndex(int index) const return {
         return m[index];
     }
 
     /// set to identity: fill all items of matrix with zero except main diagonal items which will be assigned to 1.0f
-    ref mat4 setIdentity() {
+    ref mat4 setIdentity() return {
         return setDiagonal(1.0f);
     }
     /// set to diagonal: fill all items of matrix with zero except main diagonal items which will be assigned to v
-    ref mat4 setDiagonal(float v) {
+    ref mat4 setDiagonal(float v) return {
         for (int x = 0; x < 4; x++) {
             for (int y = 0; y < 4; y++) {
                 if (x == y)
@@ -1310,13 +1310,13 @@ struct mat4 {
         return this;
     }
     /// fill all items of matrix with specified value
-    ref mat4 fill(float v) {
+    ref mat4 fill(float v) return {
         foreach(ref f; m)
             f = v;
         return this;
     }
     /// fill all items of matrix with zero
-    ref mat4 setZero() {
+    ref mat4 setZero() return {
         foreach(ref f; m)
             f = 0.0f;
         return this;
@@ -1355,25 +1355,25 @@ struct mat4 {
     }
 
     /// inplace rotate around Z axis
-    ref mat4 rotatez(float angle) {
+    ref mat4 rotatez(float angle) return {
         return rotate(angle, 0, 0, 1);
     }
 
     /// inplace rotate around X axis
-    ref mat4 rotatex(float angle) {
+    ref mat4 rotatex(float angle) return {
         return rotate(angle, 1, 0, 0);
     }
 
     /// inplace rotate around Y axis
-    ref mat4 rotatey(float angle) {
+    ref mat4 rotatey(float angle) return {
         return rotate(angle, 0, 1, 0);
     }
 
-    ref mat4 rotate(float angle, const vec3 axis) {
+    ref mat4 rotate(float angle, const vec3 axis) return {
         return rotate(angle, axis.x, axis.y, axis.z);
     }
 
-    ref mat4 rotate(float angle, float x, float y, float z) {
+    ref mat4 rotate(float angle, float x, float y, float z) return {
         if (angle == 0.0f)
             return this;
         mat4 m;
@@ -1467,19 +1467,19 @@ struct mat4 {
         return this;
     }
 
-    ref mat4 rotateX(float angle) {
+    ref mat4 rotateX(float angle) return {
         return rotate(angle, 1, 0, 0);
     }
 
-    ref mat4 rotateY(float angle) {
+    ref mat4 rotateY(float angle) return {
         return rotate(angle, 0, 1, 0);
     }
 
-    ref mat4 rotateZ(float angle) {
+    ref mat4 rotateZ(float angle) return {
         return rotate(angle, 0, 0, 1);
     }
 
-    ref mat4 scale(float x, float y, float z) {
+    ref mat4 scale(float x, float y, float z) return {
         m[0*4 + 0] *= x;
         m[0*4 + 1] *= x;
         m[0*4 + 2] *= x;
@@ -1495,7 +1495,7 @@ struct mat4 {
         return this;
     }
 
-    ref mat4 scale(float v) {
+    ref mat4 scale(float v) return {
         m[0*4 + 0] *= v;
         m[0*4 + 1] *= v;
         m[0*4 + 2] *= v;
@@ -1515,7 +1515,7 @@ struct mat4 {
         return this;
     }
 
-    ref mat4 scale(const vec3 v) {
+    ref mat4 scale(const vec3 v) return {
         m[0*4 + 0] *= v.x;
         m[0*4 + 1] *= v.x;
         m[0*4 + 2] *= v.x;

src/dlangui/core/settings.d

@@ -498,7 +498,7 @@ final class Setting {
             case UINTEGER:
                 return to!string(_store.uinteger);
             case FLOAT:
-                return to!string(_store.floating);
+                return to!string(cast(double)_store.floating);
             case TRUE:
                 return "true";
             case FALSE:
@@ -510,7 +510,7 @@ final class Setting {
         }
     }
     /// read as string value
-    string strDef(string defValue) {
+    inout (string) strDef(inout (string) defValue) {
         final switch(_type) with(SettingType) {
             case STRING:
                 return _store.str;
@@ -519,7 +519,7 @@ final class Setting {
             case UINTEGER:
                 return to!string(_store.uinteger);
             case FLOAT:
-                return to!string(_store.floating);
+                return to!string(cast(double)_store.floating);
             case TRUE:
                 return "true";
             case FALSE:
@@ -2313,5 +2313,3 @@ final class Setting {
         }
     }
 }
-
-

src/dlangui/dialogs/filedlg.d

@@ -363,8 +363,18 @@ class FileDialog : Dialog, CustomGridCellAdapter {
 
     protected string formatTimestamp(ref DirEntry f) {
         import std.datetime : SysTime;
-        SysTime ts = f.timeLastModified;
+        import std.typecons : Nullable;
-        return "%04d.%02d.%02d %02d:%02d".format(ts.year, ts.month, ts.day, ts.hour, ts.minute);
+        Nullable!SysTime ts;
+        try {
+            ts = f.timeLastModified;
+        } catch (Exception e) {
+            Log.w(e.msg);
+        }
+        if (ts.isNull) {
+            return "----.--.-- --:--";
+        } else {
+            return "%04d.%02d.%02d %02d:%02d".format(ts.get.year, ts.get.month, ts.get.day, ts.get.hour, ts.get.minute);
+        }
     }
 
     protected int entriesToCells(string selectedItemPath) {

src/dlangui/graphics/fonts.d

@@ -239,6 +239,8 @@ class Font : RefCountedObject {
         bool fixed = isFixed;
         bool useKerning = allowKerning && !fixed;
         int fixedCharWidth = charWidth('M');
+        if (fixedCharWidth == 0)
+            fixedCharWidth = spaceWidth;
         int x = 0;
         int charsMeasured = 0;
         int * pwidths = widths.ptr;

src/dlangui/graphics/ftfonts.d

@@ -771,7 +771,9 @@ bool registerFontConfigFonts(FreeTypeFontManager fontMan) {
         }
         string fn = fromStringz(s).dup;
         string fn16 = toLower(fn);
-        if (!fn16.endsWith(".ttf") && !fn16.endsWith(".odf") && !fn16.endsWith(".otf") && !fn16.endsWith(".pfb") && !fn16.endsWith(".pfa")  ) {
+        if (!fn16.endsWith(".ttf") && !fn16.endsWith(".odf") && !fn16.endsWith(".otf") &&
+            !fn16.endsWith(".ttc") && !fn16.endsWith(".pfb") && !fn16.endsWith(".pfa")  )
+        {
             continue;
         }
         int weight = FC_WEIGHT_MEDIUM;
@@ -912,9 +914,6 @@ bool registerFontConfigFonts(FreeTypeFontManager fontMan) {
         }
 
         */
-        facesFound++;
-
-
     }
 
     FcFontSetDestroy(fontset);

src/dlangui/graphics/scene/objimport.d

@@ -23,7 +23,7 @@ struct ObjModelImport {
 
     MeshRef mesh;
 
-    protected float[] parseFloatList(Token[] tokens, int maxItems = 3, float padding = 0) {
+    protected float[] parseFloatList(Token[] tokens, int maxItems = 3, float padding = 0) return {
         int i = 0;
         int sgn = 1;
         foreach(t; tokens) {

src/dlangui/graphics/scene/scene3d.d

@@ -116,8 +116,8 @@ class Scene3d : Node3d {
 bool visit(Node3d node, bool delegate(Node3d node) visitor) {
     if (!node.visible)
         return false;
-    bool res = visitor(node);
+
-    if (res)
+    if (visitor(node))
         return true;
     foreach(child; node.children) {
         res = visit(child, visitor);

src/dlangui/platforms/ansi_console/dconsole.d

@@ -280,7 +280,7 @@ class Console {
                     break;
             }
             if (readBufPos > 0 && isSequenceCompleted()) {
-                string s = readBuf[0 .. readBufPos].dup;
+                string s = readBuf[0 .. readBufPos].idup;
                 readBufPos = 0;
                 return s;
             }

src/dlangui/platforms/windows/win32fonts.d

@@ -30,6 +30,7 @@ import dlangui.graphics.fonts;
 import dlangui.platforms.windows.win32drawbuf;
 import std.string;
 import std.utf;
+import std.windows.charset;
 
 /// define debug=FontResources for logging of font file resources creation/freeing
 //debug = FontResources;
@@ -446,9 +447,13 @@ class Win32Font : Font {
         if (!isNull())
             clear();
         LOGFONTA lf;
-        lf.lfCharSet = ANSI_CHARSET; //DEFAULT_CHARSET;
+        // OEM charset face name
-        lf.lfFaceName[0..def.face.length] = def.face;
+        lf.lfCharSet = DEFAULT_CHARSET; //ANSI_CHARSET;
-        lf.lfFaceName[def.face.length] = 0;
+        // lf.lfFaceName[0..def.face.length] = def.face;
+        // lf.lfFaceName[def.face.length] = 0;
+        string oemFace = fromStringz(toMBSz(def.face)).dup;
+        lf.lfFaceName[0..oemFace.length] = oemFace;
+        lf.lfFaceName[oemFace.length] = 0;
         lf.lfHeight = -size; //pixelsToPoints(size);
         lf.lfItalic = italic;
         lf.lfWeight = weight;
@@ -545,7 +550,7 @@ class Win32FontManager : FontManager {
         debug Log.i("Win32FontManager.initialize()");
         Win32ColorDrawBuf drawbuf = new Win32ColorDrawBuf(1,1);
         LOGFONTA lf;
-        lf.lfCharSet = ANSI_CHARSET; //DEFAULT_CHARSET;
+        lf.lfCharSet = DEFAULT_CHARSET; //ANSI_CHARSET;
         lf.lfFaceName[0] = 0;
         HDC dc = drawbuf.dc;
         int res =
@@ -705,7 +710,9 @@ extern(Windows) {
         {
             void * p = cast(void*)lParam;
             Win32FontManager fontman = cast(Win32FontManager)p;
-            string face = fromStringz(lf.lfFaceName.ptr).dup;
+            // OEM charset face name
+            // string face = fromStringz(lf.lfFaceName.ptr).dup;
+            string face = fromMBSz(cast(immutable)lf.lfFaceName.ptr).dup;
             FontFamily family = pitchAndFamilyToFontFamily(lf.lfPitchAndFamily);
             if (face.length < 2 || face[0] == '@')
                 return 1;

src/dlangui/widgets/editors.d

@@ -2528,7 +2528,117 @@ class EditLine : EditWidgetBase {
     }
 }
 
+// SpinCtrl
+private {
+    import std.ascii;
+}
 
+class SpinCtrl : HorizontalLayout {
+
+    TextWidget label;
+    int min, max;
+    
+    private EditLine linEdit;
+    private Button butUp, butDown;
+    
+
+    @property int value() { return linEdit.text.to!int; }
+    @property void value(int val) {
+        linEdit.text = val.to!dstring;
+    }
+    
+    override @property bool enabled() { return linEdit.enabled; }
+    alias enabled = Widget.enabled;
+    @property void enabled(bool status) {
+        linEdit.enabled = status;
+        butUp.enabled = status;
+        butDown.enabled = status;
+    }
+
+    this(int min, int max, int initialVal = 0, dstring labelText = null){
+        this.min = min;
+        this.max = max;
+
+        if(labelText !is null){
+            label = new TextWidget("label", labelText);
+            addChild(label);
+        }
+
+        linEdit = new class EditLine {
+            this(){super("linEdit", "0"d);}
+            override bool onKeyEvent(KeyEvent event) {
+                if (( KeyAction.Text == event.action && event.text[0].isDigit)
+                    || event.keyCode == KeyCode.BACK
+                    || event.keyCode == KeyCode.DEL
+                    || event.keyCode == KeyCode.LEFT
+                    || event.keyCode == KeyCode.RIGHT
+                    || event.keyCode == KeyCode.TAB
+                    ){
+                        return super.onKeyEvent(event);
+                }
+                return false;
+            }
+
+            override bool onMouseEvent(MouseEvent event) {
+                if(enabled && event.action == MouseAction.Wheel){
+                    if((event.wheelDelta == 1) && (value < max))
+                        value = value + event.wheelDelta;
+                    if((event.wheelDelta == -1) && (value > min))
+                        value = value + event.wheelDelta;
+                    return true;
+                }
+                return super.onMouseEvent(event);
+            }
+        };
+
+        linEdit.addOnFocusChangeListener((w, t){
+            if(linEdit.text == "")
+                linEdit.text = "0";
+            if(linEdit.text.to!int > max)
+                value = max;
+            if(linEdit.text.to!int < min)
+                value = min;
+            return true;
+        });
+
+        linEdit.minHeight = 35;
+        if(initialVal != 0)
+            value = initialVal;
+        addChild(linEdit);
+
+
+        auto butContainer = new VerticalLayout();
+        butContainer.maxHeight = linEdit.minHeight;
+
+        butUp = new Button("butUp", "+"d);
+        butUp.margins(Rect(1.pointsToPixels, 1.pointsToPixels, 1.pointsToPixels, 1.pointsToPixels));
+
+        butDown = new Button("butDown", "-"d);
+        butDown.margins(Rect(1.pointsToPixels, 1.pointsToPixels, 1.pointsToPixels, 1.pointsToPixels));
+
+        butContainer.addChild(butUp);
+        butContainer.addChild(butDown);
+
+        addChild(butContainer);
+
+        butUp.click = delegate(Widget w) {
+            immutable val = linEdit.text.to!int;
+            if(val < max )
+                linEdit.text = (val + 1).to!dstring;
+            return true;
+        };
+
+        butDown.click = delegate(Widget w) {
+            immutable val = linEdit.text.to!int;
+            if(val > min )
+                linEdit.text = (val - 1).to!dstring;
+            return true;
+        };
+        
+        enabled = true;
+    }
+    
+}
 
 /// multiline editor
 class EditBox : EditWidgetBase {
@@ -3446,8 +3556,9 @@ class EditBox : EditWidgetBase {
         rc.offset(0, yOffset);
         Rect[] wrappedSelection;
         wrappedSelection.length = curSpan.len;
-        foreach (size_t i, wrapLineRect; wrappedSelection)
+        foreach (size_t i_, wrapLineRect; wrappedSelection)
         {
+            int i = cast(int)i_;
             int startingDifference = rc.left - _clientRect.left;
             wrapLineRect = rc;
             wrapLineRect.offset(-1 * curSpan.accumulation(cast(int)i, LineSpan.WrapPointInfo.Width), cast(int)i * _lineHeight);
@@ -3796,9 +3907,10 @@ class EditBox : EditWidgetBase {
                             wrappedLine = _span[i].wrappedContent;
                     int accumulativeLength;
                     CustomCharProps[] wrapProps;
-                    foreach (size_t q, curWrap; wrappedLine)
+                    foreach (size_t q_, curWrap; wrappedLine)
                     {
-                        int lineOffset = cast(int)q + i + wrapsUpTo(i + _firstVisibleLine);
+                        int q = cast(int)q_;
+                        auto lineOffset = q + i + wrapsUpTo(i + _firstVisibleLine);
                         if (highlight)
                         {
                             wrapProps = highlight[accumulativeLength .. $];