Method for integrating software components into a spreadsheet application

• US 9,582,288 B1
• Filed: 10/13/2009
• Issued: 02/28/2017
• Est. Priority Date: 04/16/2003
• Status: Active Grant

• Current Assignee: The MathWorks, Inc.
• Original Assignee: The MathWorks, Inc.
• Inventors: Stewart, James T.
• Primary Examiner(s): Do, Chat
• Assistant Examiner(s): JEON, JAE UK
• Application Number:
  US12/578,101
• Time in Patent Office: 2,695 Days
• Field of Search: 717/113, 717/110, 717/111, 717/114
• US Class Current: 1/1
• CPC Class Codes: G06F 40/18 of spreadsheets form-filling G06F40/174
• CPC Class Codes: G06F 8/34 Graphical or visual programming
• CPC Class Codes: G06F 9/44 Arrangements for executing specific programs

Abstract

A method and apparatus are provided for automatically integrating software components for use in a COM compliant application from functions developed outside of the COM compliant application environment. The method and apparatus provide a user interface and a build tool that allows the user to select desired functions and select desired locations in the COM compliant application and map those locations to inputs and outputs of the function and create the component automatically from the user'"'"'s selections. The method and apparatus provide a graphical user interface for the user to direct a build tool to generate the desired component and integrate that component with the COM compliant application.

Claims

1. An electronic device readable non-transitory storage medium storing electronic device readable instructions that, when executed, cause one or more processors to:

receive, at a graphical user interface, user input selecting a component defined within a dynamically typed programming environment, the component including functions executable by the dynamically typed programming environment, the functions including input arguments and output arguments, wherein a build tool in conjunction with the graphical user interface allows for the selection of the component defined within the dynamically typed programming environment for integration into a spreadsheet application environment;

receive a selection of two or more of the functions included in the component defined within the dynamically typed programming environment;

arrange the two or more functions into a user defined execution sequence;

receive a mapping of

first cells of the spreadsheet application environment to the input arguments of the two or more functions, and

second cells of the spreadsheet application environment to the output arguments of the two or more functions, the spreadsheet application environment being external to the dynamically typed programming environment;

automatically generate, by the one or more processors, executable program code for calling the two or more functions from the dynamically typed programming environment;

automatically integrate, by the one or more processors, the executable program code into the spreadsheet application environment;

execute, by the one or more processors, the executable program code, the executing calling the two or more functions in the dynamically typed programming environment in the user defined execution sequence,

providing data from the first cells of the spreadsheet application environment as the input arguments of the two or more functions, wherein the build tool converts the data from a format compatible with the spreadsheet application environment into an internal format that is compatible with the dynamically typed programming environment, and producing values for the output arguments of the two or more functions; and

return the values for the output arguments, from the dynamically typed programming environment, to the spreadsheet application environment, the returned values written to the second cells of the spreadsheet application environment.

2. The storage medium of claim 1, wherein the automatically generated executable program code is a COM object.

3. The storage medium of claim 1, wherein the functions include a numeric function.

4. The storage medium of claim 1, wherein the functions include a graphical function.

5. The storage medium of claim 1, further storing instructions that when executed cause the one or more processors to:

receive a selection identifying the second cells, the selection specifying a size or shape of the values for the output arguments.

6. The storage medium of claim 1, wherein one or more of the values for the output arguments is a matrix.

7. The storage medium of claim 1, wherein the values for the output arguments are a plurality of matrices.

8. The storage medium of claim 1, wherein the spreadsheet application environment is provided on a first electronic device, and the build tool is provided on a second electronic device remote from the first electronic device and connected to the first electronic device through a network.

9. The storage medium of claim 1, wherein the build tool is embedded in the spreadsheet application environment as a plug-in.

10. The storage medium of claim 1, wherein the two or more functions are executed on an electronic device remote from a user.

11. An electronic device readable non-transitory storage medium storing instructions that, when executed, cause one or more processors to:

receive, at a graphical user interface, a selection of a plurality of functions provided by and defined within a dynamically typed programming environment, wherein a build tool in conjunction with the graphical user interface allows for the selection of the plurality of functions defined within the dynamically typed programming environment for integration into a spreadsheet application environment;

arrange the plurality of functions into a user defined execution sequence;

receive an input for a first function of the plurality of functions, where;

the input is received from the spreadsheet application environment, and

the spreadsheet application environment is external to the dynamically typed programming environment;

generate executable program code for calling, from the spreadsheet application environment, the plurality of functions from the dynamically typed programming environment to execute in the user defined execution sequence;

execute the plurality of functions in the user defined execution sequence in the dynamically typed programming environment, the executing being called from the spreadsheet application environment and operating on the input to generate an output of a first type, where the output of the first type is;

compatible with the dynamically typed programming environment, and

incompatible with the spreadsheet application environment;

reformat the output into a second type, where the output of the second type is;

compatible with the spreadsheet application environment;

identify, in response to user input, a plurality of cells in the spreadsheet application environment;

programmatically map, in the dynamically typed programming environment, the output of the second type to the plurality of cells in the spreadsheet application environment identified in response to user input; and

return the output to the identified plurality of cells.

12. The storage medium of claim 11, wherein the output is an array.

13. The storage medium of claim 11, further storing instructions for providing the graphical user interface for allowing a user to specify a type for the input.

14. The storage medium of claim 13, further storing instructions for coercing the input to the specified type.

15. An electronic device readable non-transitory storage medium storing electronic device readable instructions that, when executed, cause one or more processors to:

receive, at a graphical user interface, user input selecting a component developed and defined within a dynamically typed programming environment, wherein a build tool in conjunction with the graphical user interface allows for the selection of the component defined within the dynamically typed programming environment for integration into a spreadsheet application environment, where;

the spreadsheet application environment is external to the dynamically typed programming environment, and

the component provides a plurality of functions;

receive, at the dynamically typed programming environment, an input for a first function of the plurality of functions from the spreadsheet application environment;

generate executable program code for calling, from the spreadsheet application environment, the plurality of functions from the dynamically typed programming environment to execute in the user defined execution sequence;

execute the plurality of functions at the dynamically typed programming environment in a user defined execution sequence, the executing operating on the input to generate an output of the first function, the output comprising of one or more values;

identify a plurality of cells in the spreadsheet application environment, the plurality of cells identified in response to user input;

programmatically map, at the dynamically typed programming environment, the one or more values of the output generated during execution of the plurality of functions at the dynamically typed programming environment to the plurality of cells in the external spreadsheet application environment identified in response to user input; and

return the output to the spreadsheet application environment, the returned output to be written to the identified plurality of cells, wherein the output is converted, by the build tool, from a format compatible with the dynamically typed programming environment to a spreadsheet application format compatible with the spreadsheet application environment.

16. A method comprising:

receiving, at a graphical user interface, user input selecting a plurality of functions provided at and defined within a dynamically typed programming environment, wherein a build tool in conjunction with the graphical user interface allows for the selection of the component defined within the dynamically typed programming environment for integration into a spreadsheet application environment;

arranging the plurality of functions into a user defined execution sequence;

receiving an input for a first function of the plurality of functions, where;

the input is received from the spreadsheet application environment, and

the spreadsheet application environment is external to the dynamically typed programming environment;

generating executable program code for calling, from the spreadsheet application environment, the plurality of functions from the dynamically typed programming environment to execute in the user defined execution sequence;

executing the plurality of functions in the user defined execution sequence in the dynamically typed programming environment, the executing operating on the input to generate an output of the first function, the output comprising values;

identifying a plurality of cells in the spreadsheet application environment, the plurality of cells identified in response to user input;

programmatically mapping, at the dynamically typed programming environment, the values of the output generated during execution of the first function to the plurality of cells identified in response to user input; and

returning the output to the spreadsheet application environment, the returned output to be written to the identified plurality of cells, wherein the output is converted, by the build tool, from a format compatible with the dynamically typed programming environment to a spreadsheet application format compatible with the spreadsheet application environment.

17. The method of claim 16, wherein the plurality of functions are provided in a component in the dynamically typed programming environment.

18. The method of claim 16, wherein the component is a COM object.

19. The method of claim 16, wherein the first function is a numeric function.

20. The method of claim 16, wherein the first function is a graphical function.

21. The method of claim 16, wherein the output is a matrix.

22. The method of claim 16, wherein the output is a plurality of matrices.

23. A method comprising:

receiving, at a graphical user interface, user input selecting a plurality of functions defined within a dynamically typed programming application, the plurality of functions including one or more input arguments and one or more output arguments, wherein a build tool in coniunction with the graphical user interface allows for the selection of the plurality of functions defined within the dynamically typed programming environment for integration into a spreadsheet application;

arranging the plurality of functions into a user defined order of execution;

mapping first cells of the spreadsheet application to the one or more input arguments of the plurality of functions;

mapping second cells of the spreadsheet application to the one or more output arguments of the plurality of functions;

programmatically generating, by a processor, an executable program configured to

execute the plurality of functions by the dynamically typed programming application in the user defined order of execution based on one or more calls in the spreadsheet application,

utilize values from the first cells of the spreadsheet application as the one or more input arguments of the plurality of functions, and

load computed values for the one or more output arguments of the plurality of functions into the second cells of the spreadsheet application, wherein the computed values are converted, by the build tool, from a format compatible with the dynamically typed programming environment to a spreadsheet application format compatible with the spreadsheet application; and

placing the executable program in the spreadsheet application.

24. The method of claim 23 further comprising:

presenting the graphical user interface, where the mapping first cells and the mapping second cells is in response to user input at the graphical user interface.

25. The method of claim 23 further comprising:

generating a top level function that calls the plurality of functions in the user defined order of execution.

26. The method of claim 23 wherein a first function of the plurality of functions includes a first input argument, the method further comprising:

mapping a value to the first input argument of the first function.