496 lines
12 KiB
Haxe
496 lines
12 KiB
Haxe
package;
|
|
|
|
|
|
import hxp.Path;
|
|
import haxe.Template;
|
|
#if lime
|
|
import lime.text.Font;
|
|
#end
|
|
import lime.tools.AssetHelper;
|
|
import lime.tools.AssetType;
|
|
import lime.tools.DeploymentHelper;
|
|
import lime.tools.ElectronHelper;
|
|
import hxp.System;
|
|
import lime.tools.HTML5Helper;
|
|
import lime.tools.Icon;
|
|
import lime.tools.IconHelper;
|
|
import hxp.Log;
|
|
import lime.tools.ModuleHelper;
|
|
import lime.tools.ProjectHelper;
|
|
import hxp.Path;
|
|
import lime.tools.PlatformTarget;
|
|
import hxp.System;
|
|
import lime.tools.Project;
|
|
import hxp.System;
|
|
import sys.io.File;
|
|
import sys.FileSystem;
|
|
|
|
|
|
class HTML5Platform extends PlatformTarget {
|
|
|
|
|
|
private var dependencyPath:String;
|
|
private var outputFile:String;
|
|
|
|
|
|
public function new (command:String, _project:Project, targetFlags:Map<String, String> ) {
|
|
|
|
super (command, _project, targetFlags);
|
|
|
|
initialize (command, _project);
|
|
|
|
}
|
|
|
|
|
|
public override function build ():Void {
|
|
|
|
ModuleHelper.buildModules (project, targetDirectory + "/obj", targetDirectory + "/bin");
|
|
|
|
if (project.app.main != null) {
|
|
|
|
var type = "release";
|
|
|
|
if (project.debug) {
|
|
|
|
type = "debug";
|
|
|
|
} else if (project.targetFlags.exists ("final")) {
|
|
|
|
type = "final";
|
|
|
|
}
|
|
|
|
var hxml = targetDirectory + "/haxe/" + type + ".hxml";
|
|
System.runCommand ("", "haxe", [ hxml ] );
|
|
|
|
if (noOutput) return;
|
|
|
|
HTML5Helper.encodeSourceMappingURL (targetDirectory + "/bin/" + project.app.file + ".js");
|
|
|
|
if (project.targetFlags.exists ("webgl")) {
|
|
|
|
System.copyFile (targetDirectory + "/obj/ApplicationMain.js", outputFile);
|
|
|
|
}
|
|
|
|
if (project.modules.iterator ().hasNext ()) {
|
|
|
|
ModuleHelper.patchFile (outputFile);
|
|
|
|
}
|
|
|
|
if (project.targetFlags.exists ("minify") || type == "final") {
|
|
|
|
HTML5Helper.minify (project, targetDirectory + "/bin/" + project.app.file + ".js");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
public override function clean ():Void {
|
|
|
|
if (FileSystem.exists (targetDirectory)) {
|
|
|
|
System.removeDirectory (targetDirectory);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
public override function deploy ():Void {
|
|
|
|
var name = "HTML5";
|
|
|
|
if (targetFlags.exists ("electron")) {
|
|
|
|
name = "Electron";
|
|
|
|
}
|
|
|
|
DeploymentHelper.deploy (project, targetFlags, targetDirectory, name);
|
|
|
|
}
|
|
|
|
|
|
public override function display ():Void {
|
|
|
|
Sys.println (getDisplayHXML ());
|
|
|
|
}
|
|
|
|
|
|
private function getDisplayHXML ():String {
|
|
|
|
var type = "html5";
|
|
|
|
if (targetFlags.exists ("electron")) {
|
|
|
|
type = "electron";
|
|
|
|
}
|
|
|
|
var hxml = System.findTemplate (project.templatePaths, type + "/hxml/" + buildType + ".hxml");
|
|
|
|
var context = project.templateContext;
|
|
context.OUTPUT_DIR = targetDirectory;
|
|
context.OUTPUT_FILE = outputFile;
|
|
|
|
var template = new Template (File.getContent (hxml));
|
|
|
|
return template.execute (context) + "\n-D display";
|
|
|
|
}
|
|
|
|
|
|
private function initialize (command:String, project:Project):Void {
|
|
|
|
if (targetFlags.exists ("electron")) {
|
|
|
|
targetDirectory = Path.combine (project.app.path, project.config.getString ("electron.output-directory", "electron"));
|
|
|
|
} else {
|
|
|
|
targetDirectory = Path.combine (project.app.path, project.config.getString ("html5.output-directory", "html5"));
|
|
|
|
}
|
|
|
|
dependencyPath = project.config.getString ("html5.dependency-path", "lib");
|
|
|
|
if (targetFlags.exists ("electron")) {
|
|
|
|
dependencyPath = project.config.getString ("html5.dependency-path", dependencyPath);
|
|
|
|
}
|
|
|
|
outputFile = targetDirectory + "/bin/" + project.app.file + ".js";
|
|
|
|
}
|
|
|
|
|
|
public override function run ():Void {
|
|
|
|
if (targetFlags.exists ("electron")) {
|
|
|
|
ElectronHelper.launch (project, targetDirectory + "/bin");
|
|
|
|
} else {
|
|
|
|
HTML5Helper.launch (project, targetDirectory + "/bin");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
public override function update ():Void {
|
|
|
|
AssetHelper.processLibraries (project, targetDirectory);
|
|
|
|
// project = project.clone ();
|
|
|
|
var destination = targetDirectory + "/bin/";
|
|
System.mkdir (destination);
|
|
|
|
var webfontDirectory = targetDirectory + "/obj/webfont";
|
|
var useWebfonts = true;
|
|
|
|
for (haxelib in project.haxelibs) {
|
|
|
|
if (haxelib.name == "openfl-html5-dom" || haxelib.name == "openfl-bitfive") {
|
|
|
|
useWebfonts = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
var fontPath;
|
|
|
|
for (asset in project.assets) {
|
|
|
|
if (asset.type == AssetType.FONT && asset.targetPath != null) {
|
|
|
|
if (useWebfonts) {
|
|
|
|
fontPath = Path.combine (webfontDirectory, Path.withoutDirectory (asset.targetPath));
|
|
|
|
if (!FileSystem.exists (fontPath)) {
|
|
|
|
System.mkdir (webfontDirectory);
|
|
System.copyFile (asset.sourcePath, fontPath);
|
|
|
|
var originalPath = asset.sourcePath;
|
|
asset.sourcePath = fontPath;
|
|
|
|
HTML5Helper.generateWebfonts (project, asset);
|
|
|
|
var ext = "." + Path.extension (asset.sourcePath);
|
|
var source = Path.withoutExtension (asset.sourcePath);
|
|
var extensions = [ ext, ".eot", ".woff", ".svg" ];
|
|
|
|
for (extension in extensions) {
|
|
|
|
if (!FileSystem.exists (source + extension)) {
|
|
|
|
if (extension != ".eot" && extension != ".svg") {
|
|
|
|
Log.warn ("Could not generate *" + extension + " web font for \"" + originalPath + "\"");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
asset.sourcePath = fontPath;
|
|
asset.targetPath = Path.withoutExtension (asset.targetPath);
|
|
|
|
} else {
|
|
|
|
// project.haxeflags.push (HTML5Helper.generateFontData (project, asset));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (project.targetFlags.exists ("xml")) {
|
|
|
|
project.haxeflags.push ("-xml " + targetDirectory + "/types.xml");
|
|
|
|
}
|
|
|
|
if (Log.verbose) {
|
|
|
|
project.haxedefs.set ("verbose", 1);
|
|
|
|
}
|
|
|
|
ModuleHelper.updateProject (project);
|
|
|
|
var libraryNames = new Map<String, Bool> ();
|
|
|
|
for (asset in project.assets) {
|
|
|
|
if (asset.library != null && !libraryNames.exists (asset.library)) {
|
|
|
|
libraryNames[asset.library] = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//for (library in libraryNames.keys ()) {
|
|
//
|
|
//project.haxeflags.push ("-resource " + targetDirectory + "/obj/manifest/" + library + ".json@__ASSET_MANIFEST__" + library);
|
|
//
|
|
//}
|
|
|
|
//project.haxeflags.push ("-resource " + targetDirectory + "/obj/manifest/default.json@__ASSET_MANIFEST__default");
|
|
|
|
var context = project.templateContext;
|
|
|
|
context.WIN_FLASHBACKGROUND = project.window.background != null ? StringTools.hex (project.window.background, 6) : "";
|
|
context.OUTPUT_DIR = targetDirectory;
|
|
context.OUTPUT_FILE = outputFile;
|
|
|
|
if (project.targetFlags.exists ("webgl")) {
|
|
|
|
context.CPP_DIR = targetDirectory + "/obj";
|
|
|
|
}
|
|
|
|
context.favicons = [];
|
|
|
|
var icons = project.icons;
|
|
|
|
if (icons.length == 0) {
|
|
|
|
icons = [ new Icon (System.findTemplate (project.templatePaths, "default/icon.svg")) ];
|
|
|
|
}
|
|
|
|
//if (IconHelper.createWindowsIcon (icons, Path.combine (destination, "favicon.ico"))) {
|
|
//
|
|
//context.favicons.push ({ rel: "icon", type: "image/x-icon", href: "./favicon.ico" });
|
|
//
|
|
//}
|
|
|
|
if (IconHelper.createIcon (icons, 192, 192, Path.combine (destination, "favicon.png"))) {
|
|
|
|
context.favicons.push ({ rel: "shortcut icon", type: "image/png", href: "./favicon.png" });
|
|
|
|
}
|
|
|
|
context.linkedLibraries = [];
|
|
|
|
for (dependency in project.dependencies) {
|
|
|
|
if (StringTools.endsWith (dependency.name, ".js")) {
|
|
|
|
context.linkedLibraries.push (dependency.name);
|
|
|
|
} else if (StringTools.endsWith (dependency.path, ".js") && FileSystem.exists (dependency.path)) {
|
|
|
|
var name = Path.withoutDirectory (dependency.path);
|
|
|
|
context.linkedLibraries.push ("./" + dependencyPath + "/" + name);
|
|
System.copyIfNewer (dependency.path, Path.combine (destination, Path.combine (dependencyPath, name)));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for (asset in project.assets) {
|
|
|
|
var path = Path.combine (destination, asset.targetPath);
|
|
|
|
if (asset.type != AssetType.TEMPLATE) {
|
|
|
|
if (/*asset.embed != true &&*/ asset.type != AssetType.FONT) {
|
|
|
|
System.mkdir (Path.directory (path));
|
|
AssetHelper.copyAssetIfNewer (asset, path);
|
|
|
|
} else if (asset.type == AssetType.FONT && useWebfonts) {
|
|
|
|
System.mkdir (Path.directory (path));
|
|
var ext = "." + Path.extension (asset.sourcePath);
|
|
var source = Path.withoutExtension (asset.sourcePath);
|
|
|
|
var hasFormat = [ false, false, false, false ];
|
|
var extensions = [ ext, ".eot", ".svg", ".woff" ];
|
|
var extension;
|
|
|
|
for (i in 0...extensions.length) {
|
|
|
|
extension = extensions[i];
|
|
|
|
if (FileSystem.exists (source + extension)) {
|
|
|
|
System.copyIfNewer (source + extension, path + extension);
|
|
hasFormat[i] = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
var shouldEmbedFont = false;
|
|
|
|
for (embedded in hasFormat) {
|
|
if (embedded) shouldEmbedFont = true;
|
|
}
|
|
|
|
var embeddedAssets:Array<Dynamic> = cast context.assets;
|
|
for (embeddedAsset in embeddedAssets) {
|
|
|
|
if (embeddedAsset.type == "font" && embeddedAsset.sourcePath == asset.sourcePath) {
|
|
|
|
#if lime
|
|
var font = Font.fromFile (asset.sourcePath);
|
|
|
|
embeddedAsset.ascender = font.ascender;
|
|
embeddedAsset.descender = font.descender;
|
|
embeddedAsset.height = font.height;
|
|
embeddedAsset.numGlyphs = font.numGlyphs;
|
|
embeddedAsset.underlinePosition = font.underlinePosition;
|
|
embeddedAsset.underlineThickness = font.underlineThickness;
|
|
embeddedAsset.unitsPerEM = font.unitsPerEM;
|
|
|
|
if (shouldEmbedFont) {
|
|
|
|
var urls = [];
|
|
if (hasFormat[1]) urls.push ("url('" + embeddedAsset.targetPath + ".eot?#iefix') format('embedded-opentype')");
|
|
if (hasFormat[3]) urls.push ("url('" + embeddedAsset.targetPath + ".woff') format('woff')");
|
|
urls.push ("url('" + embeddedAsset.targetPath + ext + "') format('truetype')");
|
|
if (hasFormat[2]) urls.push ("url('" + embeddedAsset.targetPath + ".svg#" + StringTools.urlEncode (embeddedAsset.fontName) + "') format('svg')");
|
|
|
|
var fontFace = "\t\t@font-face {\n";
|
|
fontFace += "\t\t\tfont-family: '" + embeddedAsset.fontName + "';\n";
|
|
// if (hasFormat[1]) fontFace += "\t\t\tsrc: url('" + embeddedAsset.targetPath + ".eot');\n";
|
|
fontFace += "\t\t\tsrc: " + urls.join (",\n\t\t\t") + ";\n";
|
|
fontFace += "\t\t\tfont-weight: normal;\n";
|
|
fontFace += "\t\t\tfont-style: normal;\n";
|
|
fontFace += "\t\t}\n";
|
|
|
|
embeddedAsset.cssFontFace = fontFace;
|
|
|
|
}
|
|
break;
|
|
#end
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ProjectHelper.recursiveSmartCopyTemplate (project, "html5/template", destination, context);
|
|
|
|
if (project.app.main != null) {
|
|
|
|
ProjectHelper.recursiveSmartCopyTemplate (project, "haxe", targetDirectory + "/haxe", context);
|
|
ProjectHelper.recursiveSmartCopyTemplate (project, "html5/haxe", targetDirectory + "/haxe", context, true, false);
|
|
ProjectHelper.recursiveSmartCopyTemplate (project, "html5/hxml", targetDirectory + "/haxe", context);
|
|
|
|
}
|
|
|
|
if (targetFlags.exists ("electron")) {
|
|
|
|
ProjectHelper.recursiveSmartCopyTemplate (project, "electron/template", destination, context);
|
|
|
|
if (project.app.main != null) {
|
|
|
|
ProjectHelper.recursiveSmartCopyTemplate (project, "electron/haxe", targetDirectory + "/haxe", context, true, false);
|
|
ProjectHelper.recursiveSmartCopyTemplate (project, "electron/hxml", targetDirectory + "/haxe", context);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for (asset in project.assets) {
|
|
|
|
var path = Path.combine (destination, asset.targetPath);
|
|
|
|
if (asset.type == AssetType.TEMPLATE) {
|
|
|
|
System.mkdir (Path.directory (path));
|
|
AssetHelper.copyAsset (asset, path, context);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
public override function watch ():Void {
|
|
|
|
// TODO: Use a custom live reload HTTP server for test/run instead
|
|
|
|
var dirs = []; // WatchHelper.processHXML (getDisplayHXML (), project.app.path);
|
|
var command = ProjectHelper.getCurrentCommand ();
|
|
System.watch (command, dirs);
|
|
|
|
}
|
|
|
|
|
|
@ignore public override function install ():Void {}
|
|
@ignore public override function rebuild ():Void {}
|
|
@ignore public override function trace ():Void {}
|
|
@ignore public override function uninstall ():Void {}
|
|
|
|
|
|
}
|