[WIP] Adding EventsFunctionsExtensions support to newIDE

Core/GDCore/Extensions/Metadata/ParameterMetadataTools.cpp

@@ -15,6 +15,7 @@ void ParameterMetadataTools::ParametersToObjectsContainer(
     gd::Project& project,
     const std::vector<gd::ParameterMetadata>& parameters,
     gd::ObjectsContainer& outputObjectsContainer) {
+  outputObjectsContainer.GetObjects().clear();
   for (std::size_t i = 0; i < parameters.size(); ++i) {
     const auto& parameter = parameters[i];
     if (parameter.GetName().empty()) continue;

newIDE/app/flow-typed/libGD.js

@@ -23,6 +23,7 @@ declare type gdObject = EmscriptenObject;
 declare type gdObjectGroup = EmscriptenObject;
 declare type gdResourcesManager = EmscriptenObject;
 declare type gdEventsList = EmscriptenObject;
+declare type gdEventsFunction = EmscriptenObject;
 
 declare type gdInstruction = EmscriptenObject;
 declare type gdInstructionMetadata = EmscriptenObject;
@@ -44,6 +45,8 @@ declare type gdDirection = EmscriptenObject;
 declare type gdAnimation = EmscriptenObject;
 declare type gdPoint = EmscriptenObject;
 
+declare type gdEventsFunctionsExtension = EmscriptenObject;
+
 declare type gdVectorEventsSearchResult = EmscriptenObject;
 declare type gdMapStringPropertyDescriptor = EmscriptenObject;
 

newIDE/app/src/Debugger/DebuggerContent.js

@@ -192,7 +192,6 @@ export default class DebuggerContent extends React.Component<Props, State> {
           second: 'profiler',
           splitPercentage: 65,
         }}
-        initialSplitPercentage={32}
       />
     );
   }

newIDE/app/src/EventsFunctionEditor/ParametersEditor.js

@@ -0,0 +1,91 @@
+// @flow
+import * as React from 'react';
+import TextField from 'material-ui/TextField';
+import { Column, Line } from '../UI/Grid';
+import SelectField from 'material-ui/SelectField';
+import MenuItem from 'material-ui/MenuItem';
+import { mapVector } from '../Utils/MapFor';
+import { FlatButton } from 'material-ui';
+const gd = global.gd;
+
+type Props = {|
+  eventsFunction: gdEventsFunction,
+  onParametersUpdated: () => void,
+|};
+
+type State = {||};
+
+const styles = {
+  list: {
+    overflowY: 'scroll',
+  },
+};
+
+export default class EventsFunctionEditor extends React.Component<
+  Props,
+  State
+> {
+  _addParameter = () => {
+    const { eventsFunction } = this.props;
+    const parameters = eventsFunction.getParameters();
+
+    const newParameter = new gd.ParameterMetadata();
+    newParameter.setType('objectList');
+    parameters.push_back(newParameter);
+    newParameter.delete();
+    this.forceUpdate();
+    this.props.onParametersUpdated();
+  };
+
+  render() {
+    const { eventsFunction } = this.props;
+
+    const parameters = eventsFunction.getParameters();
+
+    return (
+      <Column noMargin>
+        <div style={styles.list}>
+          {mapVector(parameters, (parameter: gdParameterMetadata, i: number) => {
+            return (
+              <Line noMargin expand key={i}>
+                <TextField
+                  hintText="Parameter name"
+                  value={parameter.getName()}
+                  onChange={(e, text) => {
+                    parameter.setName(text);
+                    this.forceUpdate();
+                  }}
+                  onBlur={() => {
+                    this.props.onParametersUpdated();
+                  }}
+                />
+                <SelectField
+                  hintText="Type"
+                  value={parameter.getType()}
+                  onChange={(e, i, value) => {
+                    parameter.setType(value);
+                    this.forceUpdate();
+                    this.props.onParametersUpdated();
+                  }}
+                >
+                  <MenuItem value="objectList" primaryText="Objects" />
+                  <MenuItem value="expression" primaryText="Number" />
+                  <MenuItem value="string" primaryText="String (text)" />
+                </SelectField>
+                <TextField
+                  hintText="Description"
+                  value={parameter.getDescription()}
+                  onChange={(e, text) => {
+                    parameter.setDescription(text);
+                    this.forceUpdate();
+                  }}
+                />
+              </Line>
+            );
+          })}
+          <FlatButton label="Add a parameter" onClick={this._addParameter} />
+        </div>
+      </Column>
+    );
+  }
+}

newIDE/app/src/EventsFunctionEditor/index.js

@@ -0,0 +1,140 @@
+// @flow
+import * as React from 'react';
+import EventsSheet from '../EventsSheet';
+import EditorMosaic, { MosaicWindow } from '../UI/EditorMosaic';
+import ParametersEditor from './ParametersEditor';
+import Paper from 'material-ui/Paper';
+const gd = global.gd;
+
+type Props = {|
+  project: gdProject,
+  eventsFunction: gdEventsFunction,
+|};
+
+type State = {||};
+
+const styles = {
+  container: { flex: 1, display: 'flex' },
+};
+
+export default class EventsFunctionEditor extends React.Component<
+  Props,
+  State
+> {
+  editor: ?EventsSheet;
+  _editors: ?EditorMosaic;
+  _globalObjectsContainer: ?gdObjectsContainer;
+  _objectsContainer: ?gdObjectsContainer;
+
+  componentDidMount() {
+    this._loadFrom(this.props);
+  }
+
+  UNSAFE_componentWillReceiveProps(nextProps: Props) {
+    if (
+      nextProps.eventsFunction !== this.props.eventsFunction ||
+      nextProps.project !== this.props.project
+    ) {
+      this._loadFrom(nextProps);
+    }
+  }
+
+  _loadFrom(props: Props) {
+    if (this._globalObjectsContainer) this._globalObjectsContainer.delete();
+    this._globalObjectsContainer = new gd.ObjectsContainer();
+
+    if (this._objectsContainer) this._objectsContainer.delete();
+    this._objectsContainer = new gd.ObjectsContainer();
+
+    this.updateFromParameters(props.project, props.eventsFunction);
+  }
+
+  componentWillUnmount() {
+    if (this._globalObjectsContainer) this._globalObjectsContainer.delete();
+    if (this._objectsContainer) this._objectsContainer.delete();
+  }
+
+  updateFromParameters = (
+    project: gdProject,
+    eventsFunction: gdEventsFunction
+  ) => {
+    gd.ParameterMetadataTools.parametersToObjectsContainer(
+      project,
+      eventsFunction.getParameters(),
+      this._objectsContainer
+    );
+    this.forceUpdate();
+  };
+
+  updateToolbar() {
+    if (this.editor) this.editor.updateToolbar();
+  }
+
+  render() {
+    const { project, eventsFunction } = this.props;
+
+    if (!this._globalObjectsContainer || !this._objectsContainer) return null;
+
+    return (
+      <EditorMosaic
+        ref={editors => (this._editors = editors)}
+        editors={{
+          parameters: (
+            <MosaicWindow title="Function Parameters" toolbarControls={[]}>
+              <Paper style={styles.container}>
+                <ParametersEditor
+                  eventsFunction={eventsFunction}
+                  onParametersUpdated={() =>
+                    this.updateFromParameters(project, eventsFunction)}
+                />
+              </Paper>
+            </MosaicWindow>
+          ),
+          'events-sheet': (
+            <EventsSheet
+              ref={editor => (this.editor = editor)}
+              project={project}
+              layout={null}
+              globalObjectsContainer={this._globalObjectsContainer}
+              objectsContainer={this._objectsContainer}
+              events={eventsFunction.getEvents()}
+              showPreviewButton={false}
+              onPreview={options => {
+                /*TODO*/
+              }}
+              showNetworkPreviewButton={false}
+              onOpenExternalEvents={() => {
+                /*TODO*/
+              }}
+              onOpenLayout={() => {
+                /*TODO*/
+              }}
+              resourceSources={[]}
+              onChooseResource={() => {
+                /*TODO*/
+                return Promise.reject(new Error('Unimplemented'));
+              }}
+              resourceExternalEditors={[]}
+              setToolbar={() => {
+                /*TODO*/
+              }}
+              updateToolbar={() => {
+                /*TODO*/
+              }}
+              onOpenDebugger={() => {
+                /*TODO*/
+              }}
+              onOpenSettings={() => {}}
+            />
+          ),
+        }}
+        initialNodes={{
+          direction: 'column',
+          first: 'parameters',
+          second: 'events-sheet',
+          splitPercentage: 25,
+        }}
+      />
+    );
+  }
+}

newIDE/app/src/EventsFunctionsExtensionsLoader/LocalEventsFunctionsExtensionsLoader.js

@@ -0,0 +1,16 @@
+// @flow
+import { generateEventsFunctionExtension } from ".";
+const gd = global.gd;
+
+export const loadProjectEventsFunctionExtensions = (project: gdProject) => {
+
+    //TODO
+    // const extension = generateEventsFunctionExtension(eventsFunctionsExtension, {
+    //     project,
+    //     getIncludeFileFor: () => "TODO.js", //TODO
+    //     onFunctionGeneratedCode: () => {},
+    // });
+    // gd.JsPlatform.get().addNewExtension(extension);
+    // extension.delete();
+}
+

newIDE/app/src/EventsFunctionsExtensionsLoader/index.js

@@ -0,0 +1,70 @@
+// @flow
+import { mapVector } from '../Utils/MapFor';
+
+const gd = global.gd;
+
+export type EventsFunctionExtensionContext = {|
+   project: gdProject,
+   getIncludeFileFor: (functionName: string) => string,
+   onFunctionGeneratedCode: (functionName: string, code: string) => void,
+|};
+
+export const generateEventsFunctionExtension = (
+  eventsFunctionsExtension: gdEventsFunctionsExtension,
+  context: EventsFunctionExtensionContext
+) => {
+  const extension = new gd.PlatformExtension();
+
+  extension.setExtensionInformation(
+    eventsFunctionsExtension.getName(),
+    eventsFunctionsExtension.getFullName(),
+    eventsFunctionsExtension.getDescription(),
+    '',
+    '' //TODO
+  );
+
+  mapVector(
+    extension.getEventsFunctions(),
+    (eventsFunction: gdEventsFunction) => {
+      const isCondition = false; //TODO
+      const instruction = extension.addAction(
+        eventsFunction.getName(),
+        eventsFunction.getFullName(),
+        eventsFunction.getDescription(),
+        'TODO: Sentence',
+        eventsFunction.getName(),
+        'res/function.png',
+        'res/function24.png'
+      );
+
+      mapVector(
+        eventsFunction.getParameters(),
+        (parameter: gdParameterMetadata) => {
+          instruction.addParameter(
+            parameter.getType(),
+            parameter.getDescription(),
+            parameter.getExtraInfo(),
+            parameter.isOptional()
+          );
+        }
+      );
+
+
+      const code = gd.EventsCodeGenerator.generateEventsFunctionCode(
+        context.project,
+        eventsFunction.getParameters(),
+        eventsFunction.getEvents(),
+        true //TODO
+      );
+      context.onFunctionGeneratedCode(instruction.getName(), code);
+
+      //TODO: code generation
+      instruction
+        .getCodeExtraInformation()
+        .setIncludeFile(context.getIncludeFileFor(instruction.getName()))
+        .setFunctionName('todoFunction'); //TODO: get namespace function
+    }
+  );
+
+  return extension;
+};

newIDE/app/src/MainFrame/index.js

@@ -994,6 +994,7 @@ export default class MainFrame extends React.Component<Props, State> {
           <Drawer
             open={projectManagerOpen}
             containerStyle={styles.drawerContent}
+            width={320}
           >
             <EditorBar
               title={currentProject ? currentProject.getName() : 'No project'}