Resurrecting BuildSettings UI

Script/AtomicEditor/ui/frames/menus/MainFrameMenu.ts

@@ -145,8 +145,16 @@ class MainFrameMenu extends Atomic.ScriptObject {
                 buildNotification.show("Build Notification", "Building is currently unavailable in this development snapshot.", Atomic.UI_MESSAGEWINDOW_SETTINGS_OK, true, 300, 140);
 
                 return true;
+
+            } else if (refid == "build settings") {
+
+              EditorUI.getModelOps().showBuildSettings();
+
+              return true;
+
             }
 
+
         }
 
     }
@@ -196,8 +204,8 @@ var toolsItems = {
 
 var buildItems = {
 
-    "Build": ["build build"]
-
+    "Build": ["build build", StringID.ShortcutBuild],
+    "Build Settings": ["build settings", StringID.ShortcutBuildSettings]
 }
 
 

Script/AtomicEditor/ui/modal/ModalOps.ts

@@ -10,6 +10,8 @@ import ActivationSuccessWindow = require("./license/ActivationSuccessWindow");
 import ManageLicense = require("./license/ManageLicense");
 import ProWindow = require("./license/ProWindow");
 
+import BuildSettingsWindow = require("./build/BuildSettingsWindow");
+
 import ResourceSelection = require("./ResourceSelection");
 
 import UIResourceOps = require("./UIResourceOps");
@@ -164,6 +166,15 @@ class ModalOps extends Atomic.ScriptObject {
 
     }
 
+    showBuildSettings() {
+
+        if (this.show()) {
+
+            this.opWindow = new BuildSettingsWindow();
+
+        }
+
+    }
 
     showActivationSuccessWindow() {
 

Script/AtomicEditor/ui/modal/build/AndroidSettingsWidget.ts

@@ -0,0 +1,15 @@
+
+
+class AndroidSettingsWidget extends Atomic.UIWidget {
+
+  constructor() {
+
+      super();
+
+      this.load("AtomicEditor/editor/ui/buildsettings_android.tb.txt");
+
+    }
+
+}
+
+export = AndroidSettingsWidget;

Script/AtomicEditor/ui/modal/build/BuildSettingsWindow.ts

@@ -0,0 +1,127 @@
+
+import EditorEvents = require("editor/EditorEvents");
+import EditorUI = require("ui/EditorUI");
+import ModalWindow = require("../ModalWindow");
+import ProgressModal = require("../ProgressModal");
+
+import WindowsSettingsWidget = require("./WindowsSettingsWidget");
+import MacSettingsWidget = require("./MacSettingsWidget");
+import AndroidSettingsWidget = require("./AndroidSettingsWidget");
+import IOSSettingsWidget = require("./IOSSettingsWidget");
+import WebSettingsWidget = require("./WebSettingsWidget");
+
+class BuildSettingsWindow extends ModalWindow {
+
+    constructor() {
+
+        super();
+
+        this.init("Build Settings", "AtomicEditor/editor/ui/buildsettings.tb.txt");
+
+        this.settingsContainer = <Atomic.UILayout>this.getWidget("settingscontainer");
+        var platformcontainer = <Atomic.UILayout>this.getWidget("platformcontainer");
+        this.platformIndicator = <Atomic.UISkinImage>this.getWidget("current_platform_indicator");
+
+        var platformSelect = this.platformSelect = new Atomic.UISelectList();
+
+        var platformSource = new Atomic.UISelectItemSource();
+
+        platformSource.addItem(new Atomic.UISelectItem("Windows", "WindowsBuildSettings", "LogoWindows"));
+        platformSource.addItem(new Atomic.UISelectItem("Mac", "MacBuildSettings", "LogoMac"));
+        platformSource.addItem(new Atomic.UISelectItem("Android", "AndroidBuildSettings", "LogoAndroid"));
+        platformSource.addItem(new Atomic.UISelectItem("iOS", "iOSBuildSettings", "LogoIOS"));
+        platformSource.addItem(new Atomic.UISelectItem("WebGL", "WebGLBuildSettings", "LogoHTML5"));
+
+        platformSelect.setSource(platformSource);
+
+        var lp = new Atomic.UILayoutParams();
+
+        lp.minWidth = 160;
+        lp.minHeight = 370;
+        lp.maxHeight = 370;
+
+        platformSelect.layoutParams = lp;
+        platformSelect.gravity = Atomic.UI_GRAVITY_ALL;
+
+        platformcontainer.addChild(platformSelect);
+
+        this.addPlatformWidget("WINDOWS", new WindowsSettingsWidget(), 0);
+        this.addPlatformWidget("MAC", new MacSettingsWidget(), 1);
+        this.addPlatformWidget("ANDROID", new AndroidSettingsWidget(), 2);
+        this.addPlatformWidget("IOS", new IOSSettingsWidget(), 3);
+        this.addPlatformWidget("WEB", new WebSettingsWidget(), 4);
+
+        this.setDisplayPlatform(ToolCore.toolSystem.currentPlatform);
+
+        this.resizeToFitContent();
+        this.center();
+
+        this.subscribeToEvent(this, "WidgetEvent", (ev) => this.handleWidgetEvent(ev));
+    }
+
+    handleWidgetEvent(ev: Atomic.UIWidgetEvent): boolean {
+
+
+        if (ev.type == Atomic.UI_EVENT_TYPE_CLICK) {
+
+            if (ev.refid == "WindowsBuildSettings") {
+                this.setDisplayPlatform(ToolCore.toolSystem.getPlatformByName("WINDOWS"));
+                return true;
+            }
+            if (ev.refid == "MacBuildSettings") {
+                this.setDisplayPlatform(ToolCore.toolSystem.getPlatformByName("MAC"));
+                return true;
+            }
+            if (ev.refid == "AndroidBuildSettings") {
+                this.setDisplayPlatform(ToolCore.toolSystem.getPlatformByName("ANDROID"));
+                return true;
+            }
+            if (ev.refid == "iOSBuildSettings") {
+                this.setDisplayPlatform(ToolCore.toolSystem.getPlatformByName("IOS"));
+                return true;
+            }
+            if (ev.refid == "WebGLBuildSettings") {
+                this.setDisplayPlatform(ToolCore.toolSystem.getPlatformByName("WEB"));
+                return true;
+            }
+
+        }
+
+        return false;
+
+
+    }
+
+    addPlatformWidget(name: string, widget: Atomic.UIWidget, index: number) {
+
+        this.allPlatformWidgets[name] = { widget: widget, index: index };
+        this.settingsContainer.addChild(widget);
+
+    }
+
+    setDisplayPlatform(platform: ToolCore.Platform) {
+
+        for (var name in this.allPlatformWidgets) {
+
+            this.allPlatformWidgets[name].widget.visibility = Atomic.UI_WIDGET_VISIBILITY_GONE;
+
+        }
+
+        if (!platform) return;
+
+        var info: { widget: Atomic.UIWidget, index: number } = this.allPlatformWidgets[platform.name];
+        info.widget.visibility = Atomic.UI_WIDGET_VISIBILITY_VISIBLE;
+        if (this.platformSelect.value != info.index)
+            this.platformSelect.value = info.index;
+
+    }
+
+    allPlatformWidgets: {} = {};
+
+    settingsContainer: Atomic.UILayout;
+    platformSelect: Atomic.UISelectList;
+    platformIndicator: Atomic.UISkinImage;
+
+}
+
+export = BuildSettingsWindow;

Script/AtomicEditor/ui/modal/build/IOSSettingsWidget.ts

@@ -0,0 +1,15 @@
+
+
+class IOSSettingsWidget extends Atomic.UIWidget {
+
+  constructor() {
+
+      super();
+
+      this.load("AtomicEditor/editor/ui/buildsettings_ios.tb.txt");
+
+    }
+
+}
+
+export = IOSSettingsWidget;

Script/AtomicEditor/ui/modal/build/MacSettingsWidget.ts

@@ -0,0 +1,15 @@
+
+
+class MacSettingsWidget extends Atomic.UIWidget {
+
+  constructor() {
+
+      super();
+
+      this.load("AtomicEditor/editor/ui/buildsettings_mac.tb.txt");
+
+    }
+
+}
+
+export = MacSettingsWidget;

Script/AtomicEditor/ui/modal/build/WebSettingsWidget.ts

@@ -0,0 +1,15 @@
+
+
+class WebSettingsWidget extends Atomic.UIWidget {
+
+  constructor() {
+
+      super();
+
+      this.load("AtomicEditor/editor/ui/buildsettings_html5.tb.txt");
+
+    }
+
+}
+
+export = WebSettingsWidget;

Script/AtomicEditor/ui/modal/build/WindowsSettingsWidget.ts

@@ -0,0 +1,15 @@
+
+
+class WindowsSettingsWidget extends Atomic.UIWidget {
+
+  constructor() {
+
+      super();
+
+      this.load("AtomicEditor/editor/ui/buildsettings_windows.tb.txt");
+
+    }
+
+}
+
+export = WindowsSettingsWidget;

Script/Packages/ToolCore/ToolCore.json

@@ -3,9 +3,10 @@
 	"sources" : ["Source/ToolCore", "Source/ToolCore/Project", "Source/ToolCore/Platform", "Source/ToolCore/Command",
 							 "Source/ToolCore/Import", "Source/ToolCore/Assets", "Source/ToolCore/License"],
 	"classes" : ["ToolEnvironment", "ToolSystem", "Project", "ProjectFile", "Platform", "PlatformMac", "PlatformWeb",
-							 "PlatformWindows", "Command", "PlayCmd", "OpenAssetImporter",
+							 "PlatformWindows", "PlatformAndroid", "PlatformIOS", "Command", "PlayCmd", "OpenAssetImporter",
 							 "Asset", "AssetDatabase", "AssetImporter", "AudioImporter", "ModelImporter", "MaterialImporter", "AnimationImportInfo",
-							 "PrefabImporter", "JavascriptImporter", "TextureImporter", "SpriterImporter", "PEXImporter", "LicenseSystem"],
+							 "PrefabImporter", "JavascriptImporter", "TextureImporter", "SpriterImporter", "PEXImporter", "LicenseSystem",
+						 	 "ProjectUserPrefs", "ProjectBuildSettings"],
 	"typescript_decl" : {
 
 		"AssetDatabase" : [

Script/TypeScript/AtomicWork.d.ts

@@ -230,6 +230,13 @@ declare module ToolCore {
 
     }
 
+    export interface PlatformChangedEvent {
+
+        platform:ToolCore.Platform;
+
+    }
+
+
     export var toolEnvironment: ToolEnvironment;
     export var toolSystem: ToolSystem;
     export var assetDatabase: AssetDatabase;

Source/Atomic/UI/UISelectList.cpp

@@ -111,7 +111,7 @@ void UISelectList::SetSource(UISelectItemSource* source)
 
 bool UISelectList::OnEvent(const tb::TBWidgetEvent &ev)
 {
-    return false;
+    return UIWidget::OnEvent(ev);
 }
 
 }

Source/ToolCore/Platform/PlatformAndroid.cpp

@@ -0,0 +1,25 @@
+
+
+#include "../Build/BuildWeb.h"
+#include "PlatformAndroid.h"
+
+namespace ToolCore
+{
+
+PlatformAndroid::PlatformAndroid(Context* context) : Platform(context)
+{
+
+}
+
+PlatformAndroid::~PlatformAndroid()
+{
+
+}
+
+BuildBase* PlatformAndroid::NewBuild(Project *project)
+{
+    return 0;
+}
+
+
+}

Source/ToolCore/Platform/PlatformAndroid.h

@@ -0,0 +1,25 @@
+
+#pragma once
+
+#include "Platform.h"
+
+namespace ToolCore
+{
+
+class PlatformAndroid : public Platform
+{
+    OBJECT(PlatformAndroid);
+
+public:
+
+    PlatformAndroid(Context* context);
+    virtual ~PlatformAndroid();
+
+    String GetName() { return "ANDROID"; }
+    PlatformID GetPlatformID() { return PLATFORMID_ANDROID; }
+
+    BuildBase* NewBuild(Project* project);
+
+};
+
+}

Source/ToolCore/Platform/PlatformIOS.cpp

@@ -0,0 +1,25 @@
+
+
+#include "../Build/BuildWeb.h"
+#include "PlatformIOS.h"
+
+namespace ToolCore
+{
+
+PlatformIOS::PlatformIOS(Context* context) : Platform(context)
+{
+
+}
+
+PlatformIOS::~PlatformIOS()
+{
+
+}
+
+BuildBase* PlatformIOS::NewBuild(Project *project)
+{
+    return 0;
+}
+
+
+}

Source/ToolCore/Platform/PlatformIOS.h

@@ -0,0 +1,25 @@
+
+#pragma once
+
+#include "Platform.h"
+
+namespace ToolCore
+{
+
+class PlatformIOS : public Platform
+{
+    OBJECT(PlatformIOS);
+
+public:
+
+    PlatformIOS(Context* context);
+    virtual ~PlatformIOS();
+
+    String GetName() { return "IOS"; }
+    PlatformID GetPlatformID() { return PLATFORMID_IOS; }
+
+    BuildBase* NewBuild(Project* project);
+
+};
+
+}

Source/ToolCore/Project/ProjectFile.cpp

@@ -87,31 +87,45 @@ bool ProjectFile::Load(Project* project)
     String fullpath = project->GetProjectFilePath();
 
     SharedPtr<File> file(new File(context_, fullpath, FILE_READ));
-    SharedPtr<JSONFile> jsonFile(new JSONFile(context_));
 
-    if (!jsonFile->BeginLoad(*file))
-        return false;
+    if (file->GetSize() != 0)
+    {
 
-    JSONValue root = jsonFile->GetRoot();
+        SharedPtr<JSONFile> jsonFile(new JSONFile(context_));
 
-    int version = root.GetInt("version");
+        if (!jsonFile->BeginLoad(*file))
+            return false;
 
-    if (version != PROJECTFILE_VERSION)
-        return false;
+        JSONValue root = jsonFile->GetRoot();
 
-    // project object
-    JSONValue jproject = root.GetChild("project");
+        int version = root.GetInt("version");
 
-    if (jproject.IsObject())
-    {
-        String pversion = jproject.GetString("version");
-        project_->SetVersion(pversion);
+        if (version != PROJECTFILE_VERSION)
+            return false;
+
+        // project object
+        JSONValue jproject = root.GetChild("project");
+
+        if (jproject.IsObject())
+        {
+            String pversion = jproject.GetString("version");
+            project_->SetVersion(pversion);
+        }
+
+        JSONValue platforms = root.GetChild("platforms");
+        if (!platforms.IsArray())
+            return false;
     }
 
-    JSONValue platforms = root.GetChild("platforms");
-    if (!platforms.IsArray())
-        return false;
+    // for now, every project gets all platforms
+
+    project_->AddPlatform(PLATFORMID_WINDOWS);
+    project_->AddPlatform(PLATFORMID_MAC);
+    project_->AddPlatform(PLATFORMID_ANDROID);
+    project_->AddPlatform(PLATFORMID_IOS);
+    project_->AddPlatform(PLATFORMID_WEB);
 
+    /*
     for (unsigned i = 0; i < platforms.GetSize(); i++)
     {
         String jplatform = platforms.GetString(i);
@@ -119,6 +133,7 @@ bool ProjectFile::Load(Project* project)
         if (platform)
             project_->AddPlatform(platform->GetPlatformID());
     }
+    */
 
     return true;
 

Source/ToolCore/Project/ProjectUserPrefs.cpp

@@ -6,7 +6,11 @@ namespace ToolCore
 
 ProjectUserPrefs::ProjectUserPrefs(Context* context) : Object(context)
 {
-    defaultPlatform_ = PLATFORMID_UNDEFINED;
+#ifdef ATOMIC_PLATFORM_OSX
+    defaultPlatform_ = PLATFORMID_MAC;
+#else
+    defaultPlatform_ = PLATFORMID_WINDOWS;
+#endif
 }
 
 ProjectUserPrefs::~ProjectUserPrefs()

Source/ToolCore/Project/ProjectUserPrefs.h

@@ -21,7 +21,7 @@ public:
     virtual ~ProjectUserPrefs();
 
     // platform used when not specified
-    PlatformID GetDefaultPlatform();
+    PlatformID GetDefaultPlatform() const { return defaultPlatform_; }
 
     const String& GetLastBuildPath() { return lastBuildPath_; }
     void SetLastBuildPath(const String& path) { lastBuildPath_ = path; }

Source/ToolCore/ToolEvents.h

@@ -17,5 +17,10 @@ EVENT(E_PROJECTUNLOADED, ProjectUnloaded)
 {
 }
 
+EVENT(E_PLATFORMCHANGED, PlatformChanged)
+{
+    PARAM(P_PLATFORM, Platform);    // Platform Ptr
+}
+
 
 }

Source/ToolCore/ToolSystem.cpp

@@ -6,6 +6,9 @@
 #include "Platform/PlatformWeb.h"
 #include "Platform/PlatformMac.h"
 #include "Platform/PlatformWindows.h"
+#include "Platform/PlatformAndroid.h"
+#include "Platform/PlatformIOS.h"
+
 #include "Assets/AssetDatabase.h"
 #include "Net/CurlManager.h"
 #include "License/LicenseSystem.h"
@@ -17,7 +20,7 @@
 #include "ToolEvents.h"
 
 #include "Project/Project.h"
-
+#include "Project/ProjectUserPrefs.h"
 
 namespace ToolCore
 {
@@ -34,6 +37,8 @@ ToolSystem::ToolSystem(Context* context) : Object(context),
     RegisterPlatform(new PlatformMac(context));
     RegisterPlatform(new PlatformWeb(context));
     RegisterPlatform(new PlatformWindows(context));
+    RegisterPlatform(new PlatformIOS(context));
+    RegisterPlatform(new PlatformAndroid(context));
 }
 
 ToolSystem::~ToolSystem()
@@ -69,7 +74,15 @@ bool ToolSystem::LoadProject(const String& fullpath)
     project_ = new Project(context_);
     project_->SetResourcePath(resourcePath);
 
-    return project_->Load(fullpath);
+    bool result = project_->Load(fullpath);
+
+    if (result)
+    {
+        // TODO: persistent platform setting
+        SetCurrentPlatform(project_->GetUserPrefs()->GetDefaultPlatform());
+    }
+
+    return result;
 }
 
 void ToolSystem::CloseProject()
@@ -95,9 +108,13 @@ void ToolSystem::CloseProject()
 
 void ToolSystem::SetCurrentPlatform(PlatformID platform)
 {
+    VariantMap eventData;
+
     if (platform == PLATFORMID_UNDEFINED)
     {
         currentPlatform_ = NULL;
+        eventData[PlatformChanged::P_PLATFORM] = (Platform*) 0;
+        SendEvent(E_PLATFORMCHANGED, eventData);
         return;
     }
 
@@ -105,6 +122,8 @@ void ToolSystem::SetCurrentPlatform(PlatformID platform)
         return;
 
     currentPlatform_ = platforms_[(unsigned)platform];
+    eventData[PlatformChanged::P_PLATFORM] = currentPlatform_;
+    SendEvent(E_PLATFORMCHANGED, eventData);
 
 }