@qooxdoo/framework 7.5.1 → 7.6.0

package/source/class/qx/tool/compiler/targets/Target.js

@@ -106,6 +106,22 @@ qx.Class.define("qx.tool.compiler.targets.Target", {
       check: "Boolean"
     },
 
+    /**
+     * Whether to prefer local fonts instead of CDNs
+     */
+    preferLocalFonts: {
+      init: false,
+      check: "Boolean"
+    },
+
+    /**
+     * Types of fonts to be included
+     */
+    fontTypes: {
+      init: ["woff"],
+      check: "Array"
+    },
+
     /**
      * Whether to add timestamps to all URLs (cache busting)
      */
@@ -442,7 +458,7 @@ qx.Class.define("qx.tool.compiler.targets.Target", {
         bootPackage.addJavascriptMeta(
           new qx.tool.compiler.targets.meta.Browserify(appMeta)
         );
-      }	
+      }
 
       /*
        * Assemble the Parts
@@ -506,12 +522,10 @@ qx.Class.define("qx.tool.compiler.targets.Target", {
       var assetUris = application.getAssetUris(t, rm, appMeta.getEnvironment()); // Save any changes that getAssets collected
       await rm.saveDatabase();
 
-      var promises = [
-        analyser.getCldr("en").then(cldr => bootPackage.addLocale("C", cldr)),
-        t._writeTranslations()
-      ];
+      let cldr = await analyser.getCldr("en");
+      await bootPackage.addLocale("C", cldr);
+      await this._writeTranslations();
 
-      var fontCntr = 0;
       var assets = {};
       rm.getAssetsForPaths(assetUris).forEach(asset => {
         bootPackage.addAsset(asset);
@@ -519,75 +533,180 @@ qx.Class.define("qx.tool.compiler.targets.Target", {
       });
 
       if (analyser.getApplicationTypes().indexOf("browser") > -1) {
-        // Get a list of all fonts to load; use the font name as a unique identifier, and
-        //  prioritise the application's library's definitions - this allows the application
-        //  the opportunity to override the font definitions.  This is important when the
-        //  library uses the open source/free versions of a font but the application
-        //  developer has purchased the commercial/full version of the font (eg FontAwesome)
-        let appLibrary = appMeta.getAppLibrary();
-        let fontsToLoad = {};
-        const addLibraryFonts = library => {
-          var fonts = library.getWebFonts();
-          if (!fonts) {
-            return;
-          }
-          fonts.forEach(font => {
-            fontsToLoad[font.getName()] = {
-              font,
-              library
-            };
-          });
-        };
-        requiredLibs.forEach(libnamespace => {
-          var library = analyser.findLibrary(libnamespace);
-          if (library != appLibrary) {
-            addLibraryFonts(library);
-          }
-        });
-        addLibraryFonts(appLibrary);
-
-        const loadFont = async (library, font) => {
-          try {
-            // check if font is asset somewhere
-            let res = font.getResources().filter(res => assets[res]);
-            if (res.length === 0) {
-              qx.tool.compiler.Console.print(
-                "qx.tool.compiler.webfonts.noResources",
-                font.toString(),
-                application.getName(),
-                font.getResources().join(",")
-              );
+        appMeta.addPreBootCode("qx.$$fontBootstrap={};\n");
+        await this.__writeDeprecatedWebFonts(application, appMeta, assets);
+        await this.__writeManifestFonts(
+          application,
+          appMeta,
+          assets,
+          bootPackage
+        );
+      }
+      await this._writeApplication();
+      this.__appMeta = null;
+    },
 
-              return;
-            }
-            font.setResources(res);
+    /**
+     * Writes the fonts defined in provides.webfonts
+     * @deprecated
+     */
+    async __writeDeprecatedWebFonts(application, appMeta, assets) {
+      let analyser = application.getAnalyser();
+      const requiredLibs = application.getRequiredLibraries();
 
-            await font.generateForTarget(t);
-            let resources = await font.generateForApplication(t, application);
-            for (var key in resources) {
-              appMeta.addResource(key, resources[key]);
-            }
-            var code = font.getBootstrapCode(t, application, fontCntr++ == 0);
-            if (code) {
-              appMeta.addPreBootCode(code);
-            }
-          } catch (ex) {
+      // Get a list of all fonts to load; use the font name as a unique identifier, and
+      //  prioritise the application's library's definitions - this allows the application
+      //  the opportunity to override the font definitions.  This is important when the
+      //  library uses the open source/free versions of a font but the application
+      //  developer has purchased the commercial/full version of the font (eg FontAwesome)
+      let appLibrary = appMeta.getAppLibrary();
+      let fontsToLoad = {};
+      const addLibraryFonts = library => {
+        var fonts = library.getWebFonts();
+        if (!fonts) {
+          return;
+        }
+        fonts.forEach(font => {
+          fontsToLoad[font.getName()] = {
+            font,
+            library
+          };
+        });
+      };
+      requiredLibs.forEach(libnamespace => {
+        var library = analyser.findLibrary(libnamespace);
+        if (library != appLibrary) {
+          addLibraryFonts(library);
+        }
+      });
+      addLibraryFonts(appLibrary);
+
+      const loadFont = async (library, font) => {
+        try {
+          // check if font is asset somewhere
+          let res = font.getResources().filter(res => assets[res]);
+          if (res.length === 0) {
             qx.tool.compiler.Console.print(
-              "qx.tool.compiler.webfonts.error",
+              "qx.tool.compiler.webfonts.noResources",
               font.toString(),
-              ex.toString()
+              application.getName(),
+              font.getResources().join(",")
             );
+
+            return;
           }
-        };
+          font.setResources(res);
 
-        Object.keys(fontsToLoad).forEach(fontName => {
-          let { font, library } = fontsToLoad[fontName];
-          promises.push(loadFont(library, font));
-        });
+          await font.generateForTarget(this);
+          let resources = await font.generateForApplication(this, application);
+          for (var key in resources) {
+            appMeta.addResource(key, resources[key]);
+          }
+          var code = font.getBootstrapCode(this, application);
+          if (code) {
+            appMeta.addPreBootCode(code);
+          }
+        } catch (ex) {
+          qx.tool.compiler.Console.print(
+            "qx.tool.compiler.webfonts.error",
+            font.toString(),
+            ex.toString()
+          );
+        }
+      };
+
+      for (let fontName of Object.keys(fontsToLoad)) {
+        let { font, library } = fontsToLoad[fontName];
+        await loadFont(library, font);
+      }
+    },
+
+    /**
+     * Writes the fonts defined in provides.fonts
+     */
+    async __writeManifestFonts(application, appMeta, assets, bootPackage) {
+      let analyser = application.getAnalyser();
+      let rm = analyser.getResourceManager();
+
+      const addResourcesToBuild = resourcePaths => {
+        for (let asset of rm.getAssetsForPaths(resourcePaths)) {
+          bootPackage.addAsset(asset);
+          assets[asset.getFilename()] = asset.toString();
+        }
+      };
+
+      let fontNames = application.getFonts();
+      for (let fontName of fontNames) {
+        let font = analyser.getFont(fontName);
+        if (!font) {
+          return;
+        }
+        let resources = font.getApplicationFontData();
+        for (var key in resources) {
+          appMeta.addResource(key, resources[key]);
+        }
+        let fontFaces = font.getFontFaces() || [];
+
+        // Break out the CSS into local resource files and URLs
+        let fontCss = font.getCss() || [];
+        let cssUrls = [];
+        let cssResources = [];
+        for (let urlOrPath of fontCss) {
+          if (urlOrPath.match(/^https?:/)) {
+            cssUrls.push(urlOrPath);
+          } else {
+            cssResources.push(urlOrPath);
+          }
+        }
+
+        // Exclude font files that we do not want to include
+        let types = this.getFontTypes();
+        let hasLocalFontResources = false;
+        let hasUrlFontResources = false;
+        if (types.length) {
+          for (let fontFace of fontFaces) {
+            fontFace.paths = fontFace.paths.filter(filename => {
+              let pos = filename.lastIndexOf(".");
+              if (pos > -1) {
+                let ext = filename.substring(pos + 1);
+                if (types.indexOf(ext) > -1) {
+                  return true;
+                }
+              }
+              if (!filename.match(/^https?:/)) {
+                hasLocalFontResources = true;
+              } else {
+                hasUrlFontResources = true;
+              }
+              return false;
+            });
+          }
+        }
+
+        // It is important to always prefer local fonts if we have them and are not instructed to prefer CDNs
+        let useLocalFonts = cssUrls.length == 0 && !hasUrlFontResources;
+        if (
+          this.isPreferLocalFonts() &&
+          (cssResources.length > 0 || hasLocalFontResources)
+        ) {
+          useLocalFonts = true;
+        }
+
+        // Make sure we add any CSS and font resource files to the target output
+        if (useLocalFonts) {
+          addResourcesToBuild(cssResources);
+
+          for (let fontFace of fontFaces) {
+            addResourcesToBuild(fontFace.paths);
+          }
+        }
+
+        var code = font.getBootstrapCode(this, application, useLocalFonts);
+
+        if (code) {
+          appMeta.addPreBootCode(code);
+        }
       }
-      await qx.Promise.all(promises);
-      await t._writeApplication();
-      this.__appMeta = null;
     },
 
     /**

package/source/class/qx/tool/migration/M7_5_6.js

@@ -0,0 +1,75 @@
+/* ************************************************************************
+
+   qooxdoo - the new era of web development
+
+   http://qooxdoo.org
+
+   Copyright:
+     2023 Zenesis Limited https://www.zenesis.com
+
+   License:
+     MIT: https://opensource.org/licenses/MIT
+     See the LICENSE file in the project's top-level directory for details.
+
+   Authors:
+     * John Spackman (@johnspackman)
+
+************************************************************************ */
+
+const process = require("process");
+const path = require("upath");
+const semver = require("semver");
+const fs = qx.tool.utils.Promisify.fs;
+
+/**
+ * Migration class for updating to v7.5.6
+ */
+qx.Class.define("qx.tool.migration.M7_5_6", {
+  extend: qx.tool.migration.BaseMigration,
+  members: {
+    async migrateManifest() {
+      let dryRun = this.getRunner().getDryRun();
+      let verbose = this.getRunner().getVerbose();
+      // Update all Manifests
+      let updateManifest = false;
+      for (const manifestModel of await qx.tool.config.Utils.getManifestModels()) {
+        manifestModel.set({ warnOnly: true });
+        await manifestModel.load();
+        let data = manifestModel.getData();
+
+        if (
+          data.provides?.webfonts !== undefined &&
+          data.provides?.fonts === undefined
+        ) {
+          if (dryRun) {
+            this.markAsPending(
+              "provides.webfonts will be replaced with provides.fonts"
+            );
+          } else {
+            this.markAsApplied();
+            let fontsData = {};
+            data.provides.webfonts.forEach(data => {
+              let fontData = (fontsData[data.name] = {});
+              ["defaultSize", "comparisonString"].forEach(name => {
+                let value = data[name];
+                if (value !== undefined) {
+                  fontData[name] = value;
+                }
+              });
+              if (data.resources !== undefined) {
+                fontData.sources = data.resources;
+              }
+            });
+            data.provides.fonts = fontsData;
+            delete data.provides.webfonts;
+          }
+        }
+
+        // save Manifest file
+        if (!dryRun) {
+          await manifestModel.save();
+        }
+      }
+    }
+  }
+});

package/source/class/qx/tool/utils/Http.js

@@ -0,0 +1,69 @@
+/* ************************************************************************
+
+   qooxdoo - the new era of web development
+
+   http://qooxdoo.org
+
+   Copyright:
+     2023 Zenesis Limited https://www.zenesis.com
+
+   License:
+     MIT: https://opensource.org/licenses/MIT
+     See the LICENSE file in the project's top-level directory for details.
+
+   Authors:
+     * John Spackman (@johnspackman)
+
+************************************************************************ */
+
+const fs = require("fs");
+const path = require("path");
+const tmp = require("tmp");
+const http = require("http");
+
+/**
+ * Helper methods for HTTP
+ */
+qx.Class.define("qx.tool.utils.Http", {
+  extend: qx.core.Object,
+
+  statics: {
+    /**
+     * Downloads a URL into a temporary file
+     *
+     * @param {String} url URL to download
+     * @param {RegEx?} contentTypeRegEx optional regex for the content type
+     * @return {String} temporary filename
+     */
+    async downloadToTempfile(url, contentTypeRegEx) {
+      let tmpFilename = await qx.tool.utils.Promisify.call(cb =>
+        tmp.tmpName(cb)
+      );
+
+      await new Promise((resolve, reject) => {
+        http.get(url, res => {
+          let error;
+          const { statusCode } = res;
+          const contentType = res.headers["content-type"];
+
+          if (statusCode !== 200) {
+            error = new Error(`Request Failed.\nStatus Code: ${statusCode}`);
+          } else if (contentTypeRegEx && !contentTypeRegEx.test(contentType)) {
+            error = new Error(`Invalid content-type, received ${contentType}`);
+          }
+
+          if (error) {
+            res.resume();
+            reject(error);
+            return;
+          }
+
+          let outFile = fs.createWriteStream(tmpFilename);
+          outFile.on("close", () => resolve(tmpFilename));
+          res.on("data", chunk => outFile.write(chunk));
+          res.on("end", () => outFile.end());
+        });
+      });
+    }
+  }
+});

package/source/class/qx/ui/basic/Label.js

@@ -318,15 +318,23 @@ qx.Class.define("qx.ui.basic.Label", {
       // Apply
       var styles;
       if (value) {
-        this.__font = qx.theme.manager.Font.getInstance().resolve(value);
-        if (this.__font instanceof qx.bom.webfonts.WebFont) {
-          if (!this.__font.isValid()) {
-            this.__webfontListenerId = this.__font.addListener(
-              "changeStatus",
-              this._onWebFontStatusChange,
-              this
-            );
-          }
+        if (qx.lang.Type.isString(value)) {
+          value = qx.theme.manager.Font.getInstance().resolve(value);
+        }
+        this.__font = value;
+        if (
+          this.__font instanceof qx.bom.webfonts.WebFont &&
+          !this.__font.isValid()
+        ) {
+          this.__webfontListenerId = this.__font.addListener(
+            "changeStatus",
+            evt => {
+              if (evt.getData().valid) {
+                this.__invalidContentSize = true;
+                qx.ui.core.queue.Layout.add(this);
+              }
+            }
+          );
         }
         styles = this.__font.getStyles();
       } else {
@@ -462,10 +470,10 @@ qx.Class.define("qx.ui.basic.Label", {
 
     // property apply
     _applyBreakWithinWords(value, old) {
-        this.getContentElement().setStyle(
-          "wordBreak",
+      this.getContentElement().setStyle(
+        "wordBreak",
         this.isRich() && value ? "break-all" : "normal"
-        );
+      );
     },
 
     /**
@@ -485,32 +493,6 @@ qx.Class.define("qx.ui.basic.Label", {
       false: null
     }),
 
-    /**
-     * Triggers layout recalculation after a web font was loaded
-     *
-     * @param ev {qx.event.type.Data} "changeStatus" event
-     */
-    _onWebFontStatusChange(ev) {
-      if (ev.getData().valid === true) {
-        // safari has trouble resizing, adding it again fixed the issue [BUG #8786]
-        if (
-          qx.core.Environment.get("browser.name") == "safari" &&
-          parseFloat(qx.core.Environment.get("browser.version")) >= 8
-        ) {
-          window.setTimeout(
-            function () {
-              this.__invalidContentSize = true;
-              qx.ui.core.queue.Layout.add(this);
-            }.bind(this),
-            0
-          );
-        }
-
-        this.__invalidContentSize = true;
-        qx.ui.core.queue.Layout.add(this);
-      }
-    },
-
     // property apply
     _applyValue: qx.core.Environment.select("qx.dynlocale", {
       true(value, old) {

package/source/class/qx/ui/form/AbstractField.js

@@ -462,8 +462,14 @@ qx.Class.define("qx.ui.form.AbstractField", {
       // Apply
       var styles;
       if (value) {
-        this.__font = qx.theme.manager.Font.getInstance().resolve(value);
-        if (this.__font instanceof qx.bom.webfonts.WebFont) {
+        if (qx.lang.Type.isString(value)) {
+          value = qx.theme.manager.Font.getInstance().resolve(value);
+        }
+        this.__font = value;
+        if (
+          this.__font instanceof qx.bom.webfonts.WebFont &&
+          !this.__font.isValid()
+        ) {
           this.__webfontListenerId = this.__font.addListener(
             "changeStatus",
             this._onWebFontStatusChange,

package/source/class/qx/ui/form/FileSelectorButton.js

@@ -139,6 +139,11 @@ qx.Class.define("qx.ui.form.FileSelectorButton", {
       this.__inputObject.setAttribute(attr, value);
     },
 
+    setEnabled(value){
+      this.__inputObject.setEnabled(value);
+      super.setEnabled(value);
+    },
+
     _createContentElement() {
       let id = "qxFileSelector_" + (++qx.ui.form.FileSelectorButton._fileInputElementIdCounter);
       let input = (this.__inputObject = new qx.html.Input(

package/source/class/qx/ui/table/pane/FocusIndicator.js

@@ -124,8 +124,9 @@ qx.Class.define("qx.ui.table.pane.FocusIndicator", {
               wl = deco.getWidthLeft();
             }
           }
-          var userHeight = rowHeight + (wl + wr - 2);
-          var userTop = (row - firstRow) * rowHeight - (wr - 1);
+          var userHeight = rowHeight + (wt + wb - 2);
+          var renderedRowHeight = this.__scroller.getTablePane().getRenderedRowHeight();
+          var userTop = Math.floor((row - firstRow) * renderedRowHeight) - (wt - 1);
           if (
             editing &&
             this.__scroller.getMinCellEditHeight() &&
@@ -139,9 +140,9 @@ qx.Class.define("qx.ui.table.pane.FocusIndicator", {
           }
 
           this.setUserBounds(
-            paneModel.getColumnLeft(col) - (wt - 1),
+            paneModel.getColumnLeft(col) - (wl - 1),
             userTop,
-            columnModel.getColumnWidth(col) + (wt + wb - 3),
+            columnModel.getColumnWidth(col) + (wl + wr - 3),
             userHeight
           );
 

package/source/class/qx/ui/table/pane/Pane.js

@@ -710,6 +710,20 @@ qx.Class.define("qx.ui.table.pane.Pane", {
       this.__lastColCount = colCount;
       this.__lastRowCount = rowCount;
       this.fireEvent("paneUpdated");
+    },
+
+    getRenderedRowHeight() {
+      var rowHeight = this.getTable().getRowHeight();
+
+      var elem = this.getContentElement().getDomElement();
+      if (elem && elem.firstChild) {
+        // pane has been rendered
+        var tableBody = elem.firstChild;
+        if (tableBody.childNodes && tableBody.childNodes.length > 0) {
+          rowHeight = tableBody.childNodes[0].getBoundingClientRect().height;
+        }
+      }
+      return rowHeight;
     }
   },
 

package/source/class/qx/ui/table/pane/Scroller.js

@@ -833,7 +833,7 @@ qx.Class.define("qx.ui.table.pane.Scroller", {
       }
       var scrollbar = this.__verScrollBar;
       this.__inOnScrollY = true;
-      // calculate delta so that one row is scrolled at an minimum
+      // calculate delta so that one row is scrolled at a minimum
       var rowHeight = this.getTable().getRowHeight();
       var delta = e.getData() - e.getOldData();
       if (Math.abs(delta) > 1 && Math.abs(delta) < rowHeight) {
@@ -2037,12 +2037,12 @@ qx.Class.define("qx.ui.table.pane.Scroller", {
 
       if (pageY >= panePos.top && pageY <= panePos.bottom) {
         // This event is in the pane -> Get the row
-        var rowHeight = this.getTable().getRowHeight();
+        var rowHeight = this.__tablePane.getRenderedRowHeight()
 
         var scrollY = this.__verScrollBar.getPosition();
 
         if (this.getTable().getKeepFirstVisibleRowComplete()) {
-          scrollY = Math.floor(scrollY / rowHeight) * rowHeight;
+          scrollY = Math.floor(scrollY / this.getTable().getRowHeight()) * rowHeight;
         }
 
         var tableY = scrollY + pageY - panePos.top;

package/source/class/qx/ui/virtual/core/Scroller.js

@@ -145,12 +145,18 @@ qx.Class.define("qx.ui.virtual.core.Scroller", {
 
     // overridden
     _onScrollBarX(e) {
-      this.__pane.setScrollX(e.getData());
+      // Use Math.round to convert possible decimal values to 
+      // integer values if a zoom level not equal to 100 is 
+      // set in the browser
+      this.__pane.setScrollX(Math.round(e.getData()));
     },
 
     // overridden
     _onScrollBarY(e) {
-      this.__pane.setScrollY(e.getData());
+      // Use Math.round to convert possible decimal values to 
+      // integer values if a zoom level not equal to 100 is 
+      // set in the browser
+      this.__pane.setScrollY(Math.round(e.getData()));
     }
   },
 

package/source/class/qx/ui/window/Window.js

@@ -639,16 +639,17 @@ qx.Class.define("qx.ui.window.Window", {
         return;
       }
 
-      if (
-        this.fireNonBubblingEvent("beforeClose", qx.event.type.Event, [
-          false,
-          true
-        ])
-      ) {
-        this.hide();
-        this.fireEvent("close");
+      if (! this.fireNonBubblingEvent(
+              "beforeClose",
+              qx.event.type.Event,
+              [ false, true ])) {
+        // preventDefault() was called
+        return;
       }
 
+      this.hide();
+      this.fireEvent("close");
+
       // If automatically destroying the window upon close was requested, do
       // so now. (Note that we explicitly re-obtain the autoDestroy property
       // value, allowing the user's close handler to enable/disable it before