US20180060045A1

US20180060045A1 - Automatic graphical user interface programming system

Info

Publication number: US20180060045A1
Application number: US15/352,834
Authority: US
Inventors: Arnie Foxx; Frank Parsolano; Steve Kirwan
Original assignee: Individual
Current assignee: Individual
Priority date: 2016-08-25
Filing date: 2016-11-16
Publication date: 2018-03-01
Also published as: US10331423B1

Abstract

An automatic graphical user interface programming system that greatly reduces computer processor time and power usage including: a computer processor; computer readable non-transitory storage medium; a software algorithm stored on computer readable non-transitory storage medium, where the software algorithm is designed to accept graphic files representing at least a portion of a graphic user interface for a computing device application, where the software algorithm is further adapted to accept at least one of A) button descriptions for buttons to be part of the GUI, B) photographs to be included in the GUI, C) animations to be used in the GUI, D) movies to be used in the GUI, E) a story board for the path a user can follow through the GUI, F) tables for displaying information, G) a timeline for the actions and activity of the GUI, where the software algorithm further accepts information describing the intended receiving computing device that the GUI will be used on, where the software algorithm further comprises at least three templates for software code describing a GUI in the native code environment on the receiving computing device, where the software algorithm recursively compares the input information regarding the desired GUI with the at least three templates to choose the template that closest represents the features of the information input to describe the desired GUI, where the software algorithm further alters the recursively selected template to match at least one of sizing, colors, position, layout, and function of the input information describing the desired GUI, where the software algorithm compiles source code files in the code environment native to the receiving computing device, where the source code files are adapted to provide a GUI for an application on the receiving computing device, where the software code is executed by the processor, where the processor time and power usage are reduced by at least ten percent by the software algorithm compared to other traditional methods for producing GUI source code files in the native code environment of the receiving computing device.

Description

CROSS-REFERENCE TO RELATED APPLICATIONS

This application is a non-provisional continuation of U.S. Provisional Patent Application Ser. No. 62/494,916, filed 25 Aug. 2016, the priority of which is claimed by this application, and the entire contents and substance of which are hereby incorporated in total by reference.

BRIEF DESCRIPTION OF THE FIGURES

FIG. 1 is a schematic representation of the system of the first preferred embodiments, where templates are also used for specific features.
FIG. 2 is a flow chart representation of the system of the first preferred embodiments, where templates are also used for specific features, where at least two layouts are programmed for at least two different screen sizes.

DESCRIPTION OF THE PREFERRED EMBODIMENTS

The description that follows of the invention's preferred embodiments is meant to enable someone skilled in the prior art to make and use the invention, but is not meant to limit the invention to these preferred embodiments.

1. First Preferred Embodiment

As shown in FIG. 1, the system of the preferred embodiments is an automatic graphical user interface programming system 1 that greatly reduces computer processor 2 time and power usage including: a computer processor 2; computer readable non-transitory storage medium 3; a software algorithm stored on computer readable non-transitory storage medium 3, where the software algorithm is designed to accept graphic files 4 representing at least a portion of a graphic user interface for a computing device application, where the software algorithm is further adapted to accept at least one of A) button descriptions for buttons to be part of the graphical user interface 5, B) photographs to be included in the graphical user interface 5, C) animations to be used in the graphical user interface 5, D) movies to be used in the graphical user interface 5, E) a story board for the path a user can follow through the graphical user interface 5, F) tables for displaying information 5, G) a timeline for the actions and activity of the graphical user interface 5, where the software algorithm further accepts information describing the intended receiving computing device 7 that the graphical user interface will be used on, where the software algorithm further comprises at least three templates 8 for software code describing a graphical user interface in the native code environment on the receiving computing device 7, where the software algorithm recursively compares the input information regarding the desired graphical user interface with the at least three templates 8 to choose the template that closest represents the features of the information input to describe the desired graphical user interface, where the software algorithm further alters the recursively selected template to match at least one of sizing, colors, position, layout, and function of the input information describing the desired graphical user interface, where the software algorithm compiles source code 9 files in the code environment native to the receiving computing device 7, where the source code 9 files are adapted to provide a graphical user interface for an application on the receiving computing device 7, where the software code is executed by the processor 2, where the processor 2 time and power usage are reduced by at least ten percent by the software algorithm compared to other traditional methods for producing graphical user interface source code 9 files in the native code environment of the receiving computing device 7; a receiving computing device 7 used by an end user and a method for transferring output software code to the receiving computing device 7. The automatic graphical user interface programming system 1 that greatly reduces computer processor 2 time and power usage is preferably designed to program front end graphical user interfaces for applications quickly, efficiently, and with low man-hours and significantly reduced processor 2 usage, processor 2 time, and memory usage and time compared to prior art methods and manual front end graphical user interface programming methods. The system of the preferred embodiments may, however, be used in any suitable manner.
As shown in FIG. 1, a software algorithm is at least partially stored on computer readable non-transitory medium coupled in communication with a computer processor 2, where the computer processor 2 runs the software algorithm. The software algorithm is designed to accept at least one graphic file 4 representing at least a portion of an intended graphical user interface for a computing device application. In a preferred variation, the software algorithm may accept at least one of a Photoshop file, a vector graphic file, and a similar graphic file. The software algorithm preferably parses the graphic file, in one variation including parsing separate elements of the graphic file, in another variation parsing different layers of the graphic file, in another variation parsing separate zones of the graphic file, and in another variation parsing any suitable combination of these components. The software algorithm also is designed to accept information describing the receiving computing device 7. In a preferred variation, this information includes at least one of a device manufacturer and a device model, the type and version of the operating system on the receiving computing device 7, and any other suitable information that describes the native code environment on the receiving computing device 7. The software algorithm preferably recursively selects from at least three templates 8 for software code describing at least one portion of a graphical user interface in a native code language, where the templates are preferably relevant to the native code environment on the receiving computing device 7, and where the goal of the recursion is to select the template that most closely matches the at least one graphic input file and the additional input information. This preferably allows the software algorithm to have a code structure for at least one portion of the graphical user interface in the appropriate native code environment, which can then be modified and refined to appropriately represent the at least one input graphic file 4 and the other input information and to do so in the native code environment for the receiving computing device 7. In a preferred variation, where at least one of multiple pages, multiple variations, and multiple portions of the graphical user interface are input into the software algorithm, this process may be repeated for each of the at least one of multiple pages, multiple variations, and multiple portions of the graphical user interface. The software algorithm may, however, process multiple aspects of the input information in any suitable manner. The software algorithm preferably selects a template to match at least one of sizing, colors, position, layout, and function of the information that was input into the software algorithm to describe the desired graphical user interface.
In a preferred variation of the system of the preferred embodiments, the software algorithm selects from at least two native code templates 11 related to features of a graphical user interface include code templates related to at least one of buttons, text areas, animations, photographs, movies, text entry fields, interfaces with backend application code, where the software algorithm preferably selects the appropriate feature template 11 for at least one of the features in at least one of the at least one input graphic file 4 and additional input information describing the intended graphical user interface. In an example of a preferred variation, if there is a button described by at least one of the at least one input graphic file 4 and the additional input information, the software algorithm selects from at least two button templates describing buttons in the native source code 9 environment for the receiving computing device 7, where the template most closely depicting the button from at least one of the at least one input graphic file 4 and additional input information. This can be done for any suitable feature in the at least one input graphic file 4 and additional input information. In this variation, the software algorithm preferably then modifies the code of the feature template 11 to most closely represent at least one of the input graphic and input information for that feature, as well as to ensure that feature appropriately interfaces with any required backend application information and code. This process may be repeated for all relevant features if necessary.
As shown in FIG. 2, in one preferred variation the software algorithm may include a listener in the output source code 9 to detect the screen size 10 on the receiving computing device 7, where the output graphical interface source code 9 chooses from between at least two versions of the graphical user interface based on the detected screen size 10 on the receiving computing device 7. In this preferred variation, at least two versions of layouts for at least one portion of the graphical user interface are input to the software algorithm, and the software algorithm follows the process described here for developing native source code 9 for each of the at least two layouts, generating at least two separate segments of native source code 9 for the at least two separate layouts of the graphical user interface. In this variation, when the listener in the output native source code 9 detects the screen size 10, it then selects and loads the appropriate native source code 9 segment for the layout that best suits the detected screen size 10. This preferably allows the graphical user interface to adapt to devices with different screen sizes 10.
In a preferred variation, the additional input information includes a user interface tree. In this variation, the software algorithm parses the user interface tree that is input, then recursively selects the appropriate templates for each portion of the tree, modifies those templates to create output native source code 9, then selects feature-based templates 11 for any relevant features, modifies those feature-based templates 11, and updates the overall templates with the adjusted feature-based native source code 9, leading to complete graphical user interface code in the native source code 9 appropriate for the receiving computing device 7. There may, however, be any suitable process for programming the entire graphical user interface.
In a preferred variation, at least a portion of the software algorithm may be executed on a remote computing server with at least one additional processor 2 and at least one additional computer readable non-transitory storage medium 3. In this preferred variation, the two computing devices used for executing the software algorithm collaborate to carry out the software algorithm and deliver the output native source code 9.
In a preferred variation, elements including but not limited to animations, movies, videos, audio, pictures, buttons, and text input areas are described in the input graphic files 4 and the additional input information, and the software algorithm then develops native source code 9 for each of these elements that are included in the input graphic files 4 and the additional input information. Graphic files, image files, video files, and audio files may include any of these examples and any other suitable files: AI (Adobe Illustrator) files, EPS files, JPG files, PNG files, BMP files, GIF files, MP4 files, AVI files, MOV files, MP3 files, AU files, WAV files. There may, however, be any suitable process used by the software algorithm for programming any suitable features.
In a preferred variation, the code selected and modified from the appropriate templates is then compiled and exported as native source code 9, and the native source code 9 can then be transferred to the receiving computing device 7. In a preferred variation, the native source code 9 is exported and combined with the back-end application source code 9 and the entire native source code 9 application is transferred to the receiving computing device 7.
By significantly reducing the usage time, number of computations, and processor 2 time that are required to program a graphical user interface for a receiving computing device 7 as compared to any prior art methods, including manual graphical user interface programming methods, the system of the preferred embodiments greatly reduces power usage, processor 2 time, processer usage, and the usage of the computer readable non-transitory storage medium 3, making a great improvement in at least one of power usage, programming time, power efficiency, and wear on the computer processor 2 and non-transitory computer readable storage medium 3.
As a person skilled in the art will recognize from the previous detailed description and from the figures and claims, modifications and changes can be made to the preferred embodiments of the invention without departing from the scope of this invention defined in the following claims.

Claims

We Claim:

1) An automatic graphical user interface programming system that greatly reduces computer processor time and power usage comprising: a computer processor; computer readable non-transitory storage medium coupled in communication with the computer processor; a software algorithm stored on computer readable non-transitory storage medium, wherein the software algorithm is adapted to accept graphic files representing at least a portion of a graphic user interface for a computing device application, wherein the software algorithm is further adapted to accept at least one of A) button descriptions for buttons to be part of the graphical user interface, B) photographs to be included in the graphical user interface, C) animations to be used in the graphical user interface, D) movies to be used in the graphical user interface, E) a story board for the path a user can follow through the graphical user interface, F) tables for displaying information, G) a timeline for the actions and activity of the graphical user interface, wherein the software algorithm further accepts information describing the intended receiving computing device that the graphical user interface will be used on, wherein the software algorithm further comprises at least three templates for software code describing a graphical user interface in the native code environment on the receiving computing device, wherein the software algorithm recursively compares the input information regarding the desired graphical user interface with the at least three templates to choose the template that closest represents the features of the information input to describe the desired graphical user interface, wherein the software algorithm further alters the recursively selected template to match at least one of sizing, colors, position, layout, and function of the input information describing the desired graphical user interface, wherein the software algorithm compiles source code files in the code environment native to the receiving computing device, wherein the source code files are adapted to provide a graphical user interface for an application on the receiving computing device, wherein the software code is executed by the processor, wherein the processor time and power usage are reduced by at least ten percent by the software algorithm compared to other traditional methods for producing graphical user interface source code files in the native code environment of the receiving computing device; a receiving computing device used by an end user and a method for transferring output software code to the receiving computing device.

2) The automatic graphical user interface programming system that greatly reduces computer processor time and power usage of claim 1 wherein the software algorithm further codes the native code source files to detect the screen size of the receiving computing device and change the layout of the graphical user interface to one of at least two different layouts based on screen size of the receiving computing device.

3) The automatic graphical user interface programming system that greatly reduces computer processor time and power usage of claim 1 wherein the software algorithm detects at least one feature from the input information regarding the desired graphical user interface, then recursively selects the native code template from at least two native code templates that describe graphical user interface features similar to the feature from the input information regarding the desired graphical user interface.

4) The automatic graphical user interface programming system that greatly reduces computer processor time and power usage of claim 3, wherein the at least two native code templates related to features of a graphical user interface include code templates related to at least one of buttons, text areas, animations, photographs, movies, text entry fields, interfaces with backend application code.

5) The automatic graphical user interface programming system that greatly reduces computer processor time and power usage of claim 2 wherein the software algorithm detects at least one feature from the input information regarding the desired graphical user interface, then recursively selects the native code template from at least two native code templates that describe graphical user interface features similar to the feature from the input information regarding the desired graphical user interface.

6) The automatic graphical user interface programming system that greatly reduces computer processor time and power usage of claim 5, wherein the at least two native code templates related to features of a graphical user interface include code templates related to at least one of buttons, text areas, animations, photographs, movies, text entry fields, interfaces with backend application code.

7) The automatic graphical user interface programming system that greatly reduces computer processor time and power usage of claim 2, wherein at least two separate native code source files are output by the source algorithm for separate receiving computing device screen sizes, wherein the native code source files include a listener that detects screen size usage and then uses the appropriate native code source file for the screen size.

8) The automatic graphical user interface programming system that greatly reduces computer processor time and power usage of claim 2, wherein at least two segments of native code are output by the source algorithm into the at least one native code source files, wherein each of the at least two segments of native code is adapted to properly display for separate receiving computing device screen sizes, wherein the native code source files include a listener that detects screen size usage and then uses the appropriate native code source file for the screen size.

8) The automatic graphical user interface programming system that greatly reduces computer processor time and power usage of claim 5, wherein at least two separate native code source files are output by the source algorithm for separate receiving computing device screen sizes, wherein the native code source files include a listener that detects screen size usage and then uses the appropriate native code source file for the screen size.

9) The automatic graphical user interface programming system that greatly reduces computer processor time and power usage of claim 6, wherein at least two segments of native code are output by the source algorithm into the at least one native code source files, wherein each of the at least two segments of native code is adapted to properly display for separate receiving computing device screen sizes, wherein the native code source files include a listener that detects screen size usage and then uses the appropriate native code source file for the screen size.