US20150113503A1 - Selectively enabling runtime editing of an application - Google Patents
Selectively enabling runtime editing of an application Download PDFInfo
- Publication number
- US20150113503A1 US20150113503A1 US14/528,341 US201414528341A US2015113503A1 US 20150113503 A1 US20150113503 A1 US 20150113503A1 US 201414528341 A US201414528341 A US 201414528341A US 2015113503 A1 US2015113503 A1 US 2015113503A1
- Authority
- US
- United States
- Prior art keywords
- application
- credentials
- user
- editing
- edit
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Abandoned
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/38—Creation or generation of source code for implementing user interfaces
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F21/00—Security arrangements for protecting computers, components thereof, programs or data against unauthorised activity
- G06F21/60—Protecting data
- G06F21/62—Protecting access to data via a platform, e.g. using keys or access control rules
- G06F21/6209—Protecting access to data via a platform, e.g. using keys or access control rules to a single file or object, e.g. in a secure envelope, encrypted and accessed using a key, or with access control rules appended to the object itself
Definitions
- the software application may generate graphic elements during runtime. When developing such applications, it may be difficult to visualize how incremental changes to the source code will change the graphic elements.
- Some development environments may use a “split view” to simultaneously display source code and graphics. For example, half of a development interface may display source code while the other half of the interface previews the runtime interface (e.g., displays a preview of a web page of a web application).
- the preview may not accurately reflect the interface.
- a software developer may need to context switch between the development environment and a browser to see what the application (e.g., web application) will look like.
- placeholder images that attempt to simulate the appearance of web pages.
- an online form designer may use placeholder images.
- the form designer may not actually add a text field capable of text input into the form. Instead, the form designer may add an image that is representative of a text field into the form.
- the accuracy of this approach may depend on the complexity of the web application. For example, as long as the developer uses conventional items for which the form designer has accurate placeholder images, the preview may be sufficiently accurate. However, if the developer attempts to use customized CSS or specialized widgets, the preview may no longer be accurate or useful.
- the user may be forced to context switch between a design-time tool, such as the form designer, and a runtime tool, such as a browser.
- a method includes receiving credentials at a computing device.
- the credentials are evaluated to determine whether a user associated with the credentials is authorized to edit an application while the application is being executed.
- an editing control is enabled.
- the editing control is associated with a graphical user interface (GUI) element of the application and is operable to update the GUI element during execution of the application.
- GUI graphical user interface
- FIG. 1 is a diagram to illustrate a particular embodiment of a system operable to selectively enable runtime editing of an application
- FIG. 2 is a diagram to illustrate a particular embodiment of an application that supports runtime editing
- FIG. 3 is a diagram to illustrate a particular embodiment of a method of selectively enabling runtime editing of an application
- FIG. 4 is a block diagram of a computing environment including a computing device operable to support embodiments of computer-implemented methods, computer program products, and system components as illustrated in FIGS. 1-3 .
- a web application may include an edit mode runtime extension layered over the application runtime.
- the edit mode runtime extension may be enabled or disabled for a user based on credentials provided by the user.
- the application may display editing controls for various graphical user interface (GUI) elements.
- GUI graphical user interface
- the user may edit the GUI elements via the editing controls.
- Runtime edits may automatically be reflected in the application without the user having to recompile or restart the application.
- the runtime edits may cause modification of underlying application files (e.g., HTML files and CSS files).
- a computer-implemented method includes receiving credentials during execution of an application at a computing device.
- the method also includes evaluating the credentials to determine whether a user associated with the credentials is authorized to edit the application while the application is being executed.
- the method further includes, upon determining that the user is authorized, enabling an editing control during the execution of the application.
- the editing control is associated with a graphical user interface (GUI) element of the application and is operable to update the GUI element during execution of the application.
- GUI graphical user interface
- a non-transitory computer-readable storage medium includes instructions that, when executed by a computer, cause the computer to receive credentials during execution of an application.
- the instructions are also executable to evaluate the credentials to determine whether a user associated with the credentials is authorized to edit the application while the application is being executed.
- the instructions are further executable to enable an editing control associated with a GUI element of the application upon determining that the user is authorized.
- the instructions are executable to modify one or more files of the application based on the input and to update the GUI element during the execution of the application to reflect the input.
- a computer system in another particular embodiment, includes a processor and a memory storing instructions executable by the processor to receive credentials during execution of an application.
- the instructions are also executable to evaluate the credentials to determine whether a user associated with the credentials is authorized to edit the application while the application is being executed.
- the instructions are further executable to, upon determining that the user is authorized, enable an editing control associated with a GUI element of the application.
- the instructions are executable to receive input via the editing control and to modify one or more files of the application based on the editing input.
- the instructions are also executable to update the GUI element during the execution of the application to reflect the input.
- FIG. 1 is a diagram to illustrate a particular embodiment of a system 100 operable to selectively enable runtime editing of an application.
- the application may include an application runtime 104 and an edit mode runtime extension 106 .
- the application may also be associated with one or more application files 102 .
- the application is a web application and the computer system 100 is a personal computing device executing the web application (e.g., via a browser) or a computer server (e.g., a web server or an application server).
- the application files 102 may include files that are used to build and execute the application.
- the application files 102 may include hypertext markup language (HTML) files, cascading style sheets (CSS) files, extensible markup language (XML) files, source code files, data files, or any combination thereof.
- HTML hypertext markup language
- CSS cascading style sheets
- XML extensible markup language
- the system 100 may selectively enable and disable editing controls at the application. For example, whether or not a particular editing control is enabled and displayed may depend on the identity of the user executing the application. To illustrate, editing controls may be selectively enabled and disabled for three users 111 , 112 , and 113 . Each user 111 - 113 may be associated with different credentials (e.g., a user name, a password, or a certificate), and the system 100 may selectively enable and disable editing controls based on the credentials.
- credentials e.g., a user name, a password, or a certificate
- the first user 111 may be associated with read-only credentials 121 .
- the first user 111 may have a read-only permission level with respect to the application and may not be authorized to edit any part of the application while the application is executing.
- all editing controls at the application may be disabled.
- the first user 111 may provide the read-only credentials 121 to the system 100 (e.g., via an input device such as a keyboard or a mouse).
- the system 100 may evaluate the read-only credentials 121 and determine that the first user 111 is not authorized to edit the application while the application is executing.
- the system 100 may disable the edit mode runtime extension 106 and provide a first GUI 131 to the first user 111 (e.g., by transmitting the first GUI 131 to a display device associated with the first user 111 ).
- the first GUI 131 may be a form that includes a plurality of GUI elements, including four text fields and two buttons.
- the first GUI may not include any editing controls for the GUI elements, since the first user 111 is not authorized to make runtime edits to the application.
- the second user 112 may be associated with read-write data credentials 122 .
- the second user 112 may have a read-write data permission level that authorizes the second user 112 to edit data of the application (but not to edit functionality of the application).
- a user with read-write data permission executes the application, a subset of editing controls at the application may be enabled.
- the second user 112 may provide the read-write data credentials 122 to the system 100 (e.g., via an input device such as a keyboard or a mouse).
- the system 100 may evaluate the read-write data credentials 122 and determine that the second user 112 is authorized to edit data portions of the application while the application is executing.
- the system 100 may enable the edit mode runtime extension 106 and provide a second GUI 132 to the second user 112 .
- an editing control 141 (depicted as a pencil) may be enabled and displayed for data elements of the form, such as the four text fields.
- the second user 112 may use the editing control 141 for a text field to provide input that modifies the properties of the text field, such as layout properties (e.g., corresponding to CSS files) or behavior properties (e.g., corresponding to HTML files and web script code).
- layout properties for a GUI element may include a background color, a foreground color, a font, a font size, and a location of the GUI element.
- Behavior properties for a GUI element may include a data type, a minimum value, a maximum value, or a data validation rule.
- the second user 112 may change any or all of the layout properties and behavior properties of the text fields of the second GUI 132 .
- the third user 113 may be associated with read-write application credentials 123 .
- the third user 113 may be authorized to edit any aspect of the application while the application is executing, including data and functionality of the application.
- all editing controls at the application may be enabled.
- the third user 113 may provide the read-write application credentials 123 to the system 100 (e.g., via an input device such as a keyboard or a mouse).
- the system 100 may evaluate the read-write application credentials 123 and determine that the third user 113 is authorized to edit any part of the application while the application is executing.
- the system 100 may enable the edit mode runtime extension 106 and provide a third GUI 133 to the third user 113 .
- editing controls may be enabled and displayed for the text fields of the third GUI 133 .
- Editing controls may also be displayed for the form itself, such as an editing control 142 to modify the form and a delete control 143 to delete the form.
- the editing control 142 may enable the third user 113 to change layout properties (e.g., colors and fonts) of the form and behavior properties (e.g., data validation rules) of the form.
- the system 100 may automatically modify the underlying application files 102 based on input received via the editing controls 141 - 143 .
- source code may automatically be generated to implement the modifications.
- the system 100 may also automatically update the GUI elements corresponding to the editing controls 141 - 143 .
- the editing controls 141 - 143 may be operable to update the form, the text fields, and the application files 102 associated with the form and the text fields.
- system 100 of FIG. 1 may selectively enable runtime editing of an application and may enable runtime edits to be made and accurately reflected via a single mode (e.g., a run mode). Therefore, a developer may use the system 100 of FIG. 1 to edit a web application in run mode while the web application is executing, without context switching between the run mode and a separate edit mode.
- the system 100 of FIG. 1 may advantageously transform an application's runtime into an editing and development environment, and developers may create and update application features from within the runtime.
- FIG. 1 is described with reference to a web application and a form, this is for illustrative purposes only.
- the runtime editing techniques disclosed herein may be used with any type of application.
- the disclosed systems and methods may also be used in a database application.
- Read-only users such as consumers or testers may not be authorized to edit any part of the application or the underlying database tables.
- Read-write data users may be able to edit the database tables that are used by the application.
- Read-write application users may be able to edit both the application as well as the underlying database tables.
- FIG. 2 is a diagram to illustrate a particular embodiment of an application 200 that supports runtime editing.
- the application 200 may include an application runtime 210 and an edit mode runtime extension 220 .
- the application runtime 210 may be the application runtime 104 of FIG. 1 and the edit mode runtime extension 220 may be the edit mode runtime extension 106 of FIG. 1 .
- the application runtime 210 includes one or more layers that include runtime code and data.
- the application runtime 210 may include a CSS layer 211 , an HTML layer, and a run mode layer 213 .
- the edit mode runtime extension 220 may be considered as a layer that may be applied on top of the application runtime 210 .
- the edit mode runtime extension 220 may selectively be enabled and disabled.
- the application 200 may execute the edit mode runtime extension 220 in conjunction with the run mode layer 213 .
- the functionality of the edit mode runtime extension 220 e.g., editing controls
- the application 200 of FIG. 2 may separate CSS, HTML, runtime code, and edit mode code into distinct layers.
- editing controls e.g., resize handles, selection boxes, properties, and menus
- pseudo namespace e.g., a pseudo namespace
- the code for the editing controls may be fully encapsulated so that changes to the editing controls do not affect the runtime, though changes made via the editing controls do affect the runtime.
- the editing controls may have a unique prefix or class name that enables the editing controls to be enabled and disabled without modifying any other aspect of the application.
- the application 200 of FIG. 2 may thus be preferable to existing “split-view” environments that combine runtime code and edit mode code.
- FIG. 3 is a diagram to illustrate a particular embodiment of a method 300 of selectively enabling runtime editing of an application.
- the method 300 may be performed at the system 100 of FIG. 1 .
- the method 300 may include receiving credentials during execution of an application, at 302 .
- the read-only credentials 121 the read-write data credentials 122 , or the read-write application credentials 123 may be received.
- the method 300 may also include evaluating the credentials, at 304 , to determine whether a user associated with the credentials is authorized to edit the application while the application is being executed, at 306 .
- the credentials 121 , 122 , or 123 may be evaluated.
- the method 300 may disable editing controls at the application, at 308 .
- the edit mode runtime extension 106 may be disabled and the first GUI 131 may be provided to the first user 111 .
- the method 300 may include enabling an editing control associated with a GUI element of the application, at 310 .
- the edit mode runtime extension 106 may be enabled and the second GUI 132 or the third GUI 133 may be provided to the second user 112 or the third user 113 , respectively, where at least one of the editing controls 141 - 143 is enabled.
- the method 300 may further include receiving input via the editing control, at 312 .
- input may be received via the text field editing control 141 .
- the method 300 may include modifying one or more files of the application based on the input, at 314 .
- the files may include HTML files, CSS files, XML files, source code files, data files, or any combination thereof.
- the application files 102 may be modified.
- a CSS file may define a background of a text field to be white. The user may use the editing control to change the background of the text field to blue, and, in response, the definition in the CSS file may be modified.
- the method 300 may also include updating the GUI element during the execution of the application to reflect the input, at 316 .
- Updating the GUI element may include updating a data type, a minimum value, a maximum value, a data validation rule, or a layout of the GUI element.
- the text field associated with the editing control 141 may be updated to reflect the input.
- the background of the text field may change from white to blue in the executing application.
- FIG. 4 shows a block diagram of a computing environment 400 including a computing device 410 operable to support embodiments of computer-implemented methods, computer program products, and system components according to the present disclosure.
- the computing device 410 or components thereof may include, implement, or be included as a component of the system 100 of FIG. 1 .
- the computing device 410 includes at least one processor 420 and a system memory 430 .
- the computing device 410 may be a desktop computer, a laptop computer, a tablet computer, a mobile phone, a server, or any other fixed or mobile computing device.
- the system memory 430 may be volatile (such as random access memory or “RAM”), non-volatile (such as read-only memory or “ROM,” flash memory, and similar memory devices that maintain stored data even when power is not provided), non-transitory, some combination of the three, or some other memory.
- the system memory 430 may include an operating system 432 , one or more application platforms 434 , one or more applications, and program data 438 .
- the system memory 430 may include portions of an executing application, such as an edit mode runtime extension 435 and an application runtime 436 .
- the system memory 430 may also include one or more application files 437 associated with the application.
- the edit mode runtime extension 435 , the application runtime 436 , and the application files 437 correspond to the edit mode runtime extension 106 , the application runtime 104 , and the application files 102 of FIG. 1 , respectively.
- the computing device 410 may also have additional features or functionality.
- the computing device 410 may also include removable and/or non-removable additional data storage devices such as magnetic disks, optical disks, tape, and standard-sized or flash memory cards.
- additional storage is illustrated in FIG. 4 by removable storage 440 and non-removable storage 450 .
- Computer storage media may include volatile and/or non-volatile storage and removable and/or non-removable media implemented in any technology for storage of information such as computer-readable instructions, data structures, program components or other data.
- the system memory 430 , the removable storage 440 , and the non-removable storage 450 are all examples of computer storage media.
- the computer storage media includes, but is not limited to, RAM, ROM, electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technology, compact disks (CD), digital versatile disks (DVD) or other optical storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other medium that can be used to store information and that can be accessed by the computing device 410 . Any such computer storage media may be part of the computing device 410 .
- the computing device 410 may also have input device(s) 460 , such as a keyboard, mouse, pen, voice input device, touch input device, etc. connected via one or more input interfaces.
- Output device(s) 470 such as a display, speakers, printer, etc. may also be included and connected via one or more output interfaces.
- the input device(s) 460 and the output device(s) 470 may enable a user 492 to interact with applications executing at the computing device 410 .
- the output device(s) 470 may include a monitor connected to the computing device 410 via an output interface, where the output interface is configured to transmit GUI elements generated by the application runtime 436 to the monitor.
- the computing device 410 also contains one or more communication connections 480 that allow the computing device 410 to communicate with other computing devices 490 over a wired or a wireless network.
- the one or more communication connections 480 may represent an interface that communicates with the other computing devices 490 via a network.
- removable storage 440 may be optional.
- a software module may reside in computer readable media, such as random access memory (RAM), flash memory, read only memory (ROM), registers, a hard disk, a removable disk, a CD-ROM, or any other form of storage medium known in the art.
- An exemplary storage medium is coupled to a processor such that the processor can read information from, and write information to, the storage medium.
- the storage medium may be integral to the processor or the processor and the storage medium may reside as discrete components in a computing device or computer system.
Abstract
A method includes receiving credentials at a computing device. The credentials are evaluated to determine whether a user associated with the credentials is authorized to edit an application while the application is being executed. Upon determining that the user is authorized, an editing control is enabled. The editing control is associated with a graphical user interface (GUI) element of the application and is operable to update the GUI element during execution of the application.
Description
- The present application claims priority from and is a continuation application of U.S. patent application Ser. No. 12/975,398, filed on Dec. 22, 2010 and entitled “SELECTIVELY ENABLING RUNTIME EDITING OF AN APPLICATION,” the contents of which are expressly incorporated herein by reference in their entirety.
- Although the source code for a software application may be text-based, the software application may generate graphic elements during runtime. When developing such applications, it may be difficult to visualize how incremental changes to the source code will change the graphic elements. Some development environments may use a “split view” to simultaneously display source code and graphics. For example, half of a development interface may display source code while the other half of the interface previews the runtime interface (e.g., displays a preview of a web page of a web application). However, as design elements such as cascading style sheets (CSS) become complicated, the preview may not accurately reflect the interface. Moreover, since the preview may not be completely accurate, a software developer may need to context switch between the development environment and a browser to see what the application (e.g., web application) will look like.
- Another approach is to use placeholder images that attempt to simulate the appearance of web pages. For example, an online form designer may use placeholder images. When a developer adds a text field into the form, the form designer may not actually add a text field capable of text input into the form. Instead, the form designer may add an image that is representative of a text field into the form. The accuracy of this approach may depend on the complexity of the web application. For example, as long as the developer uses conventional items for which the form designer has accurate placeholder images, the preview may be sufficiently accurate. However, if the developer attempts to use customized CSS or specialized widgets, the preview may no longer be accurate or useful. Thus, the user may be forced to context switch between a design-time tool, such as the form designer, and a runtime tool, such as a browser.
- Systems and methods of selectively enabling an ability to edit applications during runtime are disclosed. As an example, a method includes receiving credentials at a computing device. The credentials are evaluated to determine whether a user associated with the credentials is authorized to edit an application while the application is being executed. Upon determining that the user is authorized, an editing control is enabled. The editing control is associated with a graphical user interface (GUI) element of the application and is operable to update the GUI element during execution of the application.
- This Summary is provided to introduce a selection of concepts in a simplified form that are further described below in the Detailed Description. This Summary is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to be used to limit the scope of the claimed subject matter.
-
FIG. 1 is a diagram to illustrate a particular embodiment of a system operable to selectively enable runtime editing of an application; -
FIG. 2 is a diagram to illustrate a particular embodiment of an application that supports runtime editing; -
FIG. 3 is a diagram to illustrate a particular embodiment of a method of selectively enabling runtime editing of an application; and -
FIG. 4 is a block diagram of a computing environment including a computing device operable to support embodiments of computer-implemented methods, computer program products, and system components as illustrated inFIGS. 1-3 . - The disclosed techniques may enable selective editing of an application while the application is being executed. For example, a web application may include an edit mode runtime extension layered over the application runtime. The edit mode runtime extension may be enabled or disabled for a user based on credentials provided by the user. When the user is authorized to make runtime edits to the application, the application may display editing controls for various graphical user interface (GUI) elements. The user may edit the GUI elements via the editing controls. Runtime edits may automatically be reflected in the application without the user having to recompile or restart the application. In addition, the runtime edits may cause modification of underlying application files (e.g., HTML files and CSS files).
- In a particular embodiment, a computer-implemented method includes receiving credentials during execution of an application at a computing device. The method also includes evaluating the credentials to determine whether a user associated with the credentials is authorized to edit the application while the application is being executed. The method further includes, upon determining that the user is authorized, enabling an editing control during the execution of the application. The editing control is associated with a graphical user interface (GUI) element of the application and is operable to update the GUI element during execution of the application.
- In another particular embodiment, a non-transitory computer-readable storage medium includes instructions that, when executed by a computer, cause the computer to receive credentials during execution of an application. The instructions are also executable to evaluate the credentials to determine whether a user associated with the credentials is authorized to edit the application while the application is being executed. The instructions are further executable to enable an editing control associated with a GUI element of the application upon determining that the user is authorized. The instructions are executable to modify one or more files of the application based on the input and to update the GUI element during the execution of the application to reflect the input.
- In another particular embodiment, a computer system includes a processor and a memory storing instructions executable by the processor to receive credentials during execution of an application. The instructions are also executable to evaluate the credentials to determine whether a user associated with the credentials is authorized to edit the application while the application is being executed. The instructions are further executable to, upon determining that the user is authorized, enable an editing control associated with a GUI element of the application. The instructions are executable to receive input via the editing control and to modify one or more files of the application based on the editing input. The instructions are also executable to update the GUI element during the execution of the application to reflect the input.
-
FIG. 1 is a diagram to illustrate a particular embodiment of asystem 100 operable to selectively enable runtime editing of an application. The application may include anapplication runtime 104 and an editmode runtime extension 106. The application may also be associated with one ormore application files 102. In a particular embodiment, the application is a web application and thecomputer system 100 is a personal computing device executing the web application (e.g., via a browser) or a computer server (e.g., a web server or an application server). - The
application files 102 may include files that are used to build and execute the application. For example, theapplication files 102 may include hypertext markup language (HTML) files, cascading style sheets (CSS) files, extensible markup language (XML) files, source code files, data files, or any combination thereof. - The
system 100 may selectively enable and disable editing controls at the application. For example, whether or not a particular editing control is enabled and displayed may depend on the identity of the user executing the application. To illustrate, editing controls may be selectively enabled and disabled for threeusers system 100 may selectively enable and disable editing controls based on the credentials. - For example, the
first user 111 may be associated with read-only credentials 121. Thus, thefirst user 111 may have a read-only permission level with respect to the application and may not be authorized to edit any part of the application while the application is executing. When a user with read-only permission executes the application, all editing controls at the application may be disabled. To illustrate, thefirst user 111 may provide the read-only credentials 121 to the system 100 (e.g., via an input device such as a keyboard or a mouse). Thesystem 100 may evaluate the read-only credentials 121 and determine that thefirst user 111 is not authorized to edit the application while the application is executing. In response, thesystem 100 may disable the editmode runtime extension 106 and provide afirst GUI 131 to the first user 111 (e.g., by transmitting thefirst GUI 131 to a display device associated with the first user 111). For example, as illustrated inFIG. 1 , thefirst GUI 131 may be a form that includes a plurality of GUI elements, including four text fields and two buttons. The first GUI may not include any editing controls for the GUI elements, since thefirst user 111 is not authorized to make runtime edits to the application. - As another example, the
second user 112 may be associated with read-write data credentials 122. Thus, thesecond user 112 may have a read-write data permission level that authorizes thesecond user 112 to edit data of the application (but not to edit functionality of the application). When a user with read-write data permission executes the application, a subset of editing controls at the application may be enabled. To illustrate, thesecond user 112 may provide the read-write data credentials 122 to the system 100 (e.g., via an input device such as a keyboard or a mouse). Thesystem 100 may evaluate the read-write data credentials 122 and determine that thesecond user 112 is authorized to edit data portions of the application while the application is executing. In response, thesystem 100 may enable the editmode runtime extension 106 and provide asecond GUI 132 to thesecond user 112. For example, as illustrated inFIG. 1 , an editing control 141 (depicted as a pencil) may be enabled and displayed for data elements of the form, such as the four text fields. Thesecond user 112 may use theediting control 141 for a text field to provide input that modifies the properties of the text field, such as layout properties (e.g., corresponding to CSS files) or behavior properties (e.g., corresponding to HTML files and web script code). For example, the layout properties for a GUI element may include a background color, a foreground color, a font, a font size, and a location of the GUI element. Behavior properties for a GUI element may include a data type, a minimum value, a maximum value, or a data validation rule. Thesecond user 112 may change any or all of the layout properties and behavior properties of the text fields of thesecond GUI 132. - As yet another example, the
third user 113 may be associated with read-write application credentials 123. Thus, thethird user 113 may be authorized to edit any aspect of the application while the application is executing, including data and functionality of the application. When a user with read-write application permission executes the application, all editing controls at the application may be enabled. To illustrate, thethird user 113 may provide the read-write application credentials 123 to the system 100 (e.g., via an input device such as a keyboard or a mouse). Thesystem 100 may evaluate the read-write application credentials 123 and determine that thethird user 113 is authorized to edit any part of the application while the application is executing. In response, thesystem 100 may enable the editmode runtime extension 106 and provide athird GUI 133 to thethird user 113. For example, as illustrated inFIG. 1 , editing controls may be enabled and displayed for the text fields of thethird GUI 133. Editing controls may also be displayed for the form itself, such as anediting control 142 to modify the form and adelete control 143 to delete the form. For example, theediting control 142 may enable thethird user 113 to change layout properties (e.g., colors and fonts) of the form and behavior properties (e.g., data validation rules) of the form. - In a particular embodiment, the
system 100 may automatically modify the underlying application files 102 based on input received via the editing controls 141-143. For example, source code may automatically be generated to implement the modifications. Thesystem 100 may also automatically update the GUI elements corresponding to the editing controls 141-143. For example, the editing controls 141-143 may be operable to update the form, the text fields, and the application files 102 associated with the form and the text fields. - It will be appreciated that the
system 100 ofFIG. 1 may selectively enable runtime editing of an application and may enable runtime edits to be made and accurately reflected via a single mode (e.g., a run mode). Therefore, a developer may use thesystem 100 ofFIG. 1 to edit a web application in run mode while the web application is executing, without context switching between the run mode and a separate edit mode. Thesystem 100 ofFIG. 1 may advantageously transform an application's runtime into an editing and development environment, and developers may create and update application features from within the runtime. - It should be noted that although the embodiment of
FIG. 1 is described with reference to a web application and a form, this is for illustrative purposes only. The runtime editing techniques disclosed herein may be used with any type of application. For example, the disclosed systems and methods may also be used in a database application. Read-only users such as consumers or testers may not be authorized to edit any part of the application or the underlying database tables. Read-write data users may be able to edit the database tables that are used by the application. Read-write application users may be able to edit both the application as well as the underlying database tables. -
FIG. 2 is a diagram to illustrate a particular embodiment of an application 200 that supports runtime editing. The application 200 may include anapplication runtime 210 and an editmode runtime extension 220. In an illustrative embodiment, theapplication runtime 210 may be theapplication runtime 104 ofFIG. 1 and the editmode runtime extension 220 may be the editmode runtime extension 106 ofFIG. 1 . - In a particular embodiment, the
application runtime 210 includes one or more layers that include runtime code and data. For example, theapplication runtime 210 may include aCSS layer 211, an HTML layer, and arun mode layer 213. The editmode runtime extension 220 may be considered as a layer that may be applied on top of theapplication runtime 210. As described with reference to the editmode runtime extension 106 ofFIG. 1 , the editmode runtime extension 220 may selectively be enabled and disabled. When the editmode runtime extension 220 is enabled, the application 200 may execute the editmode runtime extension 220 in conjunction with therun mode layer 213. The functionality of the edit mode runtime extension 220 (e.g., editing controls) may be available to users via therun mode layer 213 without context switching between therun mode layer 213 and a different mode (e.g., a developer edit mode). - It will be appreciated that the application 200 of
FIG. 2 may separate CSS, HTML, runtime code, and edit mode code into distinct layers. For example, at the CSS level, editing controls (e.g., resize handles, selection boxes, properties, and menus) may be separated by a pseudo namespace. At the HTML level, the code for the editing controls may be fully encapsulated so that changes to the editing controls do not affect the runtime, though changes made via the editing controls do affect the runtime. For example, the editing controls may have a unique prefix or class name that enables the editing controls to be enabled and disabled without modifying any other aspect of the application. The application 200 ofFIG. 2 may thus be preferable to existing “split-view” environments that combine runtime code and edit mode code. -
FIG. 3 is a diagram to illustrate a particular embodiment of a method 300 of selectively enabling runtime editing of an application. In an illustrative embodiment, the method 300 may be performed at thesystem 100 ofFIG. 1 . - The method 300 may include receiving credentials during execution of an application, at 302. For example, in
FIG. 1 , the read-only credentials 121, the read-write data credentials 122, or the read-write application credentials 123 may be received. - The method 300 may also include evaluating the credentials, at 304, to determine whether a user associated with the credentials is authorized to edit the application while the application is being executed, at 306. For example, in
FIG. 1 , thecredentials - When the user is not authorized to edit the application while the application is executing, the method 300 may disable editing controls at the application, at 308. For example, in
FIG. 1 , the editmode runtime extension 106 may be disabled and thefirst GUI 131 may be provided to thefirst user 111. - When the user is authorized to edit the application while the application is executing, the method 300 may include enabling an editing control associated with a GUI element of the application, at 310. For example, in
FIG. 1 , the editmode runtime extension 106 may be enabled and thesecond GUI 132 or thethird GUI 133 may be provided to thesecond user 112 or thethird user 113, respectively, where at least one of the editing controls 141-143 is enabled. - The method 300 may further include receiving input via the editing control, at 312. For example, in
FIG. 1 , input may be received via the textfield editing control 141. The method 300 may include modifying one or more files of the application based on the input, at 314. The files may include HTML files, CSS files, XML files, source code files, data files, or any combination thereof. For example, inFIG. 1 , the application files 102 may be modified. To illustrate, a CSS file may define a background of a text field to be white. The user may use the editing control to change the background of the text field to blue, and, in response, the definition in the CSS file may be modified. - The method 300 may also include updating the GUI element during the execution of the application to reflect the input, at 316. Updating the GUI element may include updating a data type, a minimum value, a maximum value, a data validation rule, or a layout of the GUI element. For example, in
FIG. 1 , the text field associated with theediting control 141 may be updated to reflect the input. To illustrate, the background of the text field may change from white to blue in the executing application. -
FIG. 4 shows a block diagram of a computing environment 400 including acomputing device 410 operable to support embodiments of computer-implemented methods, computer program products, and system components according to the present disclosure. For example, thecomputing device 410 or components thereof may include, implement, or be included as a component of thesystem 100 ofFIG. 1 . - The
computing device 410 includes at least oneprocessor 420 and asystem memory 430. For example, thecomputing device 410 may be a desktop computer, a laptop computer, a tablet computer, a mobile phone, a server, or any other fixed or mobile computing device. Depending on the configuration and type of computing device, thesystem memory 430 may be volatile (such as random access memory or “RAM”), non-volatile (such as read-only memory or “ROM,” flash memory, and similar memory devices that maintain stored data even when power is not provided), non-transitory, some combination of the three, or some other memory. Thesystem memory 430 may include anoperating system 432, one ormore application platforms 434, one or more applications, andprogram data 438. For example, thesystem memory 430 may include portions of an executing application, such as an editmode runtime extension 435 and anapplication runtime 436. Thesystem memory 430 may also include one or more application files 437 associated with the application. In an illustrative embodiment, the editmode runtime extension 435, theapplication runtime 436, and the application files 437 correspond to the editmode runtime extension 106, theapplication runtime 104, and the application files 102 ofFIG. 1 , respectively. - The
computing device 410 may also have additional features or functionality. For example, thecomputing device 410 may also include removable and/or non-removable additional data storage devices such as magnetic disks, optical disks, tape, and standard-sized or flash memory cards. Such additional storage is illustrated inFIG. 4 byremovable storage 440 andnon-removable storage 450. Computer storage media may include volatile and/or non-volatile storage and removable and/or non-removable media implemented in any technology for storage of information such as computer-readable instructions, data structures, program components or other data. Thesystem memory 430, theremovable storage 440, and thenon-removable storage 450 are all examples of computer storage media. The computer storage media includes, but is not limited to, RAM, ROM, electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technology, compact disks (CD), digital versatile disks (DVD) or other optical storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other medium that can be used to store information and that can be accessed by thecomputing device 410. Any such computer storage media may be part of thecomputing device 410. - The
computing device 410 may also have input device(s) 460, such as a keyboard, mouse, pen, voice input device, touch input device, etc. connected via one or more input interfaces. Output device(s) 470, such as a display, speakers, printer, etc. may also be included and connected via one or more output interfaces. The input device(s) 460 and the output device(s) 470 may enable auser 492 to interact with applications executing at thecomputing device 410. For example, the output device(s) 470 may include a monitor connected to thecomputing device 410 via an output interface, where the output interface is configured to transmit GUI elements generated by theapplication runtime 436 to the monitor. - The
computing device 410 also contains one ormore communication connections 480 that allow thecomputing device 410 to communicate withother computing devices 490 over a wired or a wireless network. For example, the one ormore communication connections 480 may represent an interface that communicates with theother computing devices 490 via a network. - It will be appreciated that not all of the components or devices illustrated in
FIG. 4 or otherwise described in the previous paragraphs are necessary to support embodiments as herein described. For example, theremovable storage 440 may be optional. - The illustrations of the embodiments described herein are intended to provide a general understanding of the structure of the various embodiments. The illustrations are not intended to serve as a complete description of all of the elements and features of apparatus and systems that utilize the structures or methods described herein. Many other embodiments may be apparent to those of skill in the art upon reviewing the disclosure. Other embodiments may be utilized and derived from the disclosure, such that structural and logical substitutions and changes may be made without departing from the scope of the disclosure. Accordingly, the disclosure and the figures are to be regarded as illustrative rather than restrictive.
- Those of skill would further appreciate that the various illustrative logical blocks, configurations, modules, and process steps or instructions described in connection with the embodiments disclosed herein may be implemented as electronic hardware or computer software. Various illustrative components, blocks, configurations, modules, or steps have been described generally in terms of their functionality. Whether such functionality is implemented as hardware or software depends upon the particular application and design constraints imposed on the overall system. Skilled artisans may implement the described functionality in varying ways for each particular application, but such implementation decisions should not be interpreted as causing a departure from the scope of the present disclosure.
- The steps of a method described in connection with the embodiments disclosed herein may be embodied directly in hardware, in a software module executed by a processor, or in a combination of the two. A software module may reside in computer readable media, such as random access memory (RAM), flash memory, read only memory (ROM), registers, a hard disk, a removable disk, a CD-ROM, or any other form of storage medium known in the art. An exemplary storage medium is coupled to a processor such that the processor can read information from, and write information to, the storage medium. In the alternative, the storage medium may be integral to the processor or the processor and the storage medium may reside as discrete components in a computing device or computer system.
- Although specific embodiments have been illustrated and described herein, it should be appreciated that any subsequent arrangement designed to achieve the same or similar purpose may be substituted for the specific embodiments shown. This disclosure is intended to cover any and all subsequent adaptations or variations of various embodiments.
- The Abstract is provided with the understanding that it will not be used to interpret or limit the scope or meaning of the claims. In addition, in the foregoing Detailed Description, various features may be grouped together or described in a single embodiment for the purpose of streamlining the disclosure. This disclosure is not to be interpreted as reflecting an intention that the claimed embodiments require more features than are expressly recited in each claim. Rather, as the following claims reflect, inventive subject matter may be directed to less than all of the features of any of the disclosed embodiments.
- The previous description of the embodiments is provided to enable a person skilled in the art to make or use the embodiments. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the generic principles defined herein may be applied to other embodiments without departing from the scope of the disclosure. Thus, the present disclosure is not intended to be limited to the embodiments shown herein but is to be accorded the widest scope possible consistent with the principles and novel features as defined by the following claims.
Claims (20)
1. A method comprising:
receiving credentials at a computing device;
evaluating the credentials to determine whether a user associated with the credentials is authorized to edit an application while the application is being executed; and
upon determining that the user is authorized, enabling an editing control, wherein the editing control is associated with a graphical user interface (GUI) element of the application, and wherein the editing control is operable to update the GUI element during execution of the application.
2. The method of claim 1 , further comprising receiving input via the editing control.
3. The method of claim 2 , further comprising automatically modifying one or more files of the application based on the input.
4. The method of claim 3 , wherein the one or more files of the application include a hypertext markup language (HTML) file, a cascading style sheets (CSS) file, an extensible markup language (XML) file, a source code file, a data file, or any combination thereof.
5. The method of claim 2 , further comprising automatically updating the GUI element during the execution of the application to reflect the input.
6. The method of claim 5 , wherein automatically updating the GUI element comprises updating a layout of the GUI element.
7. The method of claim 5 wherein automatically updating the GUI element comprises updating a data type associated with the field, updating a minimum value associated with the field, updating a maximum value associated with the field, updating one or more data validation rules associated with the field, or any combination thereof.
8. The method of claim 1 , wherein the credentials are associated with a read-only permission level, a read-write data permission level, or a read-write application permission level.
9. A computer-readable storage device comprising instructions that, when executed by a computer, cause the computer to:
receive credentials;
evaluate the credentials to determine whether a user associated with the credentials is authorized to edit an application while the application is being executed; and
upon determining that the user is authorized, enable an editing control associated with a graphical user interface (GUI) element of the application, the editing control configured to update the GUI element during the execution of the application.
10. The computer-readable storage device of claim 9 , wherein the credentials comprise a user name, a password, a certificate, or any combination thereof.
11. The computer-readable storage device of claim 9 , wherein the application comprises a web application.
12. The computer-readable storage device of claim 11 , wherein the web application includes a form, and wherein the GUI element is a field of the form.
13. The method of claim 9 , wherein the application includes a runtime layer and an edit mode runtime extension.
14. The method of claim 13 , wherein the runtime layer comprises a hypertext markup language (HTML) layer, a cascading style sheets (CSS) layer, or a run mode layer.
15. The method of claim 14 , wherein the application is operable to execute the edit mode runtime extension in conjunction with execution of the run mode layer without context switching between the run mode layer and a different mode.
16. A computer system, comprising:
a processor; and
a memory storing instructions executable by the processor to:
receive credentials;
evaluate the credentials to determine whether a user associated with the credentials is authorized to edit an application while the application is being executed; and
upon determining that the user is authorized, enable an editing control associated with a graphical user interface (GUI) element of the application, the editing control configured to update the GUI element during the execution of the application.
17. The computer system of claim 16 , further comprising an output interface configured to transmit the GUI element of the application to a display device.
18. The computer system of claim 16 , wherein the instructions are executable by the processor to disable the editing control when the user is not authorized to edit the application while the application is being executed.
19. The computer system of claim 18 , wherein disabling the editing control comprises disabling an edit mode runtime extension.
20. The computer system of claim 16 , wherein the processor:
disables all editing controls at the application upon determining that the credentials are associated with a read-only permission level;
enables a subset of editing controls at the application upon determining that the credentials are associated with a read-write data permission level; and
enables all editing controls at the application upon determining that the credentials are associated with a read-write application permission level.
Priority Applications (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US14/528,341 US20150113503A1 (en) | 2010-12-22 | 2014-10-30 | Selectively enabling runtime editing of an application |
Applications Claiming Priority (2)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US12/975,398 US8893081B2 (en) | 2010-12-22 | 2010-12-22 | Selectively enabling runtime editing of an application |
US14/528,341 US20150113503A1 (en) | 2010-12-22 | 2014-10-30 | Selectively enabling runtime editing of an application |
Related Parent Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US12/975,398 Continuation US8893081B2 (en) | 2010-12-22 | 2010-12-22 | Selectively enabling runtime editing of an application |
Publications (1)
Publication Number | Publication Date |
---|---|
US20150113503A1 true US20150113503A1 (en) | 2015-04-23 |
Family
ID=46318617
Family Applications (2)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US12/975,398 Active 2032-04-28 US8893081B2 (en) | 2010-12-22 | 2010-12-22 | Selectively enabling runtime editing of an application |
US14/528,341 Abandoned US20150113503A1 (en) | 2010-12-22 | 2014-10-30 | Selectively enabling runtime editing of an application |
Family Applications Before (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US12/975,398 Active 2032-04-28 US8893081B2 (en) | 2010-12-22 | 2010-12-22 | Selectively enabling runtime editing of an application |
Country Status (3)
Country | Link |
---|---|
US (2) | US8893081B2 (en) |
CN (1) | CN102591643B (en) |
HK (1) | HK1172418A1 (en) |
Families Citing this family (12)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
EP2606457A1 (en) * | 2010-08-19 | 2013-06-26 | Koninklijke Philips Electronics N.V. | Extendable decision support system |
US9823917B2 (en) * | 2011-10-20 | 2017-11-21 | Facebook, Inc. | Update application user interfaces on client devices |
CN103617037B (en) * | 2013-11-27 | 2017-12-08 | 邵寻 | Development approach and web development system for web development system |
US9914220B2 (en) * | 2014-02-07 | 2018-03-13 | Abb Schweiz Ag | Web browser access to robot cell devices |
US10073604B2 (en) * | 2014-05-15 | 2018-09-11 | Oracle International Corporation | UI-driven model extensibility in multi-tier applications |
US10963539B2 (en) | 2014-09-10 | 2021-03-30 | Mk Systems Usa Inc. | Interactive web application editor |
US9432734B2 (en) | 2014-09-10 | 2016-08-30 | Telefonaktiebolaget L M Ericsson (Publ) | Multi-person and multi-device content personalization |
US10365789B2 (en) * | 2015-02-16 | 2019-07-30 | Vmware, Inc. | Common run-time design-time environment |
US10824403B2 (en) | 2015-10-23 | 2020-11-03 | Oracle International Corporation | Application builder with automated data objects creation |
US10691474B2 (en) * | 2017-01-03 | 2020-06-23 | International Business Machines Corporation | Text resources processing in an application |
CN107766117A (en) * | 2017-11-16 | 2018-03-06 | 山东浪潮通软信息科技有限公司 | A kind of method and device of showing interface |
US11514232B2 (en) * | 2018-10-04 | 2022-11-29 | Oracle International Corporation | Multi dimensional rules-based dynamic layouts |
Citations (4)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20030061311A1 (en) * | 2001-09-24 | 2003-03-27 | George Lo | Method for providing engineering tool services |
US7490319B2 (en) * | 2003-11-04 | 2009-02-10 | Kimberly-Clark Worldwide, Inc. | Testing tool comprising an automated multidimensional traceability matrix for implementing and validating complex software systems |
US20110107088A1 (en) * | 2009-11-02 | 2011-05-05 | Chi Eng | System and method for virtual team collaboration in a secure environment |
US8387006B1 (en) * | 2007-12-05 | 2013-02-26 | Adobe Systems Incorporated | System and method for authoring a web page to be run-time editable |
Family Cites Families (9)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US7043529B1 (en) * | 1999-04-23 | 2006-05-09 | The United States Of America As Represented By The Secretary Of The Navy | Collaborative development network for widely dispersed users and methods therefor |
US6947991B1 (en) * | 1999-09-13 | 2005-09-20 | Novell, Inc. | Method and apparatus for exposing network administration stored in a directory using HTTP/WebDAV protocol |
US20060174199A1 (en) | 2000-11-16 | 2006-08-03 | Soltis Warren B | Web-based design system |
US20040215719A1 (en) | 2003-04-09 | 2004-10-28 | Altshuler Dennis Wayne | Method and system for designing, editing and publishing web page content in a live internet session |
US8239882B2 (en) | 2005-08-30 | 2012-08-07 | Microsoft Corporation | Markup based extensibility for user interfaces |
US20080178122A1 (en) | 2006-02-03 | 2008-07-24 | Crown Partners,Llc | System and method for website configuration and management |
US8176417B2 (en) | 2008-10-22 | 2012-05-08 | Platformic, Inc. | Constructing and maintaining web sites |
US20100153866A1 (en) | 2008-12-11 | 2010-06-17 | Accenture Global Services Gmbh | Method and system for modifying the execution of a native application running on a portable electronic device |
US8302014B2 (en) | 2010-06-11 | 2012-10-30 | Microsoft Corporation | Merging modifications to user interface components while preserving user customizations |
-
2010
- 2010-12-22 US US12/975,398 patent/US8893081B2/en active Active
-
2011
- 2011-12-21 CN CN201110433669.6A patent/CN102591643B/en active Active
-
2012
- 2012-12-20 HK HK12113200.5A patent/HK1172418A1/en unknown
-
2014
- 2014-10-30 US US14/528,341 patent/US20150113503A1/en not_active Abandoned
Patent Citations (4)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20030061311A1 (en) * | 2001-09-24 | 2003-03-27 | George Lo | Method for providing engineering tool services |
US7490319B2 (en) * | 2003-11-04 | 2009-02-10 | Kimberly-Clark Worldwide, Inc. | Testing tool comprising an automated multidimensional traceability matrix for implementing and validating complex software systems |
US8387006B1 (en) * | 2007-12-05 | 2013-02-26 | Adobe Systems Incorporated | System and method for authoring a web page to be run-time editable |
US20110107088A1 (en) * | 2009-11-02 | 2011-05-05 | Chi Eng | System and method for virtual team collaboration in a secure environment |
Also Published As
Publication number | Publication date |
---|---|
US8893081B2 (en) | 2014-11-18 |
HK1172418A1 (en) | 2013-04-19 |
CN102591643B (en) | 2016-01-20 |
US20120167041A1 (en) | 2012-06-28 |
CN102591643A (en) | 2012-07-18 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US8893081B2 (en) | Selectively enabling runtime editing of an application | |
US11514033B2 (en) | System for providing dynamic linked panels in user interface | |
CN108292231B (en) | Method and system for generating applications from data | |
US8074167B2 (en) | Cross domain presence of web user interface and logic | |
JP2016224923A (en) | Method and system for automated generation of user form interface | |
Spaanjaars | Beginning asp. net 4: in c# and vb | |
JP2009506461A (en) | Markup-based extensibility for user interface | |
US20140047409A1 (en) | Enterprise application development tool | |
US9684526B2 (en) | Techniques for configuring a generic program using controls | |
CN107408105B (en) | Conditionally controlled additive pattern | |
Anderson et al. | Pro business applications with silverlight 4 | |
MacIntyre et al. | Pro PHP programming | |
Aquino et al. | Front-end web development: The big nerd ranch guide | |
Harris | HTML5 and CSS3 All-in-one for Dummies | |
US8510343B2 (en) | Cogeneration of database applications and their databases | |
Frain | Sass and Compass for designers | |
Scott et al. | Expert Oracle Application Express | |
Chang et al. | W-Revised: An amazing tool for creating customized websites | |
Wesley | Pro JQuery in Oracle Application Express | |
Powers | The essential guide to Dreamweaver CS4 With CSS, Ajax, and PHP | |
Freeman | Using Data Bindings | |
Obert et al. | Elementary: Fundamental Library Styles | |
Akinshin | Getting Started with Knockout. js for. NET Developers | |
Libby et al. | Creating Components | |
Northwood et al. | Front End |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
AS | Assignment |
Owner name: MICROSOFT CORPORATION, WASHINGTON Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:PAYZER, GERSHOM;FALK, JASON W.;LOVERING, BRADFORD H.;SIGNING DATES FROM 20101201 TO 20101217;REEL/FRAME:034072/0401 |
|
AS | Assignment |
Owner name: MICROSOFT TECHNOLOGY LICENSING, LLC, WASHINGTON Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:MICROSOFT CORPORATION;REEL/FRAME:034819/0001 Effective date: 20150123 |
|
STCB | Information on status: application discontinuation |
Free format text: ABANDONED -- FAILURE TO RESPOND TO AN OFFICE ACTION |