US20070106928A1 - Graphical user interface engine for embedded systems - Google Patents
Graphical user interface engine for embedded systems Download PDFInfo
- Publication number
- US20070106928A1 US20070106928A1 US11/502,071 US50207106A US2007106928A1 US 20070106928 A1 US20070106928 A1 US 20070106928A1 US 50207106 A US50207106 A US 50207106A US 2007106928 A1 US2007106928 A1 US 2007106928A1
- Authority
- US
- United States
- Prior art keywords
- controller
- gui
- document
- gui object
- memory
- 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
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/451—Execution arrangements for user interfaces
Abstract
In an embedded system, for instance in a household appliance, in addition to the usual embedded microprocessor/microcontroller there is provided another processor which actually executes a user interface HTML document for accepting user input, for instance from a keypad and controlling the display device, for instance an LCD. The embedded microprocessor hosts the user interface document, responds to requests from the other processor, keeps track of changes in variables shared with the other processor, and executes the control device functionality. The other processor renders the graphical user interface to the display and interacts with the user by executing local functions to operate on the memory and i/o resources of the embedded processor as described by the user interface document served to it.
Description
- This application is a continuation of U.S. patent application Ser. No. 09/692,997, filed Oct. 20, 2000, which is a continuation of application Ser. No. 09/263,148, filed Mar. 5, 1999, now abandoned.
- This invention relates to computer systems and more specifically to embedded systems, i.e. other than general purpose programmable computers.
- Embedded systems are well known; this refers to microprocessors and microcontrollers (hereinafter generically referred to as microprocessors) used in devices other than general purpose computers. For instance many household appliances (such as microwave ovens) have embedded microprocessors which control operation of the appliance. The microprocessor typically accepts user input, for instance from the keypad of the microwave oven, and controls operation of the microwave oven, for instance the level of heating and duration of cooking. The embedded microprocessor also controls the device display which in a microwave oven is a small LCD (liquid crystal display). That is, the intelligence of such appliances resides in the embedded microprocessor, which interfaces to the human user. Typically this is done through firmware, i.e. computer software executed by the embedded microprocessor and stored in a memory associated with, or a part of, the microprocessor. In addition to executing the software to interact with the controlled device, the embedded microprocessor also accepts and decodes input from the human user, for instance via the keypad, as well as provides visual feedback on the display by providing text and/or graphic information to a display controller which in turn drives the LCD panel.
- As shown in the block diagram of
FIG. 1 , the embedded microprocessor 10 (in the drawing designated by the alternative terminology “microcontroller”) is a commercially available device, for instance an 8 or 16-bit microcontroller of the type available from a number of vendors. This embedded microprocessor conventionally includes, in addition to its logic circuitry, storage such as ROM (read only memory) which holds what is calledfirmware 12, which is a type of computer software, and also conventional RAM (random access memory) which is not shown.Firmware 12 performs the indicated functions of application flow, device control (of the controlled device of which the embedded microprocessor is a part) reaction to user input, and the capability to draw pixels to thedisplay controller 24frame buffer 30. - As shown, the
microprocessor 10 is coupled to auser input device 14, e.g. a keypad, an infrared remote controller such as used on television sets, or a touch screen input device. The associated controlled device (not shown) is, for instance, an appliance such as a microwave oven, washing machine, or automobile system, or a scientific instrument, or a machine tool, and is connected conventionally tomicroprocessor 10. It is to be appreciated that the lines connecting the blocks inFIG. 1 represent buses, that is, parallel multiline connections. The embeddedmicroprocessor 10 supplies input (commands) from the human user via theuser input device 14 to control the controlled device and gives user indications on thedisplay 20.Display 20 is driven via conventional pixel drivers/video circuitry 22. Theuser input device 14, of course, does not directly affect the controlled device, nor does it directly control thedisplay processor 20. Instead, the embeddedmicroprocessor 10 accepts and decodes the user input from theuser input device 14, then controls the controlled device and provides information to the user ondisplay 20. Similarly, thedisplay device 20 does not directly display information from theuser input device 14, nor the controlled device; instead it only displays information provided to it by the embeddedmicroprocessor 10. This display takes place via thedisplay controller 24, which is often a separate, commercially available, integrated circuit.Display controller 24 includes several well known elements which are the microcontroller (microprocessor)bus interface 28, which drives theframe buffer 30 and the associated LCD/video interface 34. As shown, the display device is for instance an LCD (liquid crystal display), VFD (vacuum fluorescent display), CRT (cathode ray tube), etc. - The
FIG. 1 system is well known and has been in use for many years. It is generally suitable for high volume production products such as household appliances where manufacturing (parts) cost is important and nonrecurring engineering charges for developing software are relatively less important. The reason for this is that the firmware executed by themicroprocessor 10 must be customized for each class of controlled device, as well as for theuser input device 14 and thedisplay 20. This requires a substantial amount of software engineering effort. However, this approach is less well adapted for non-mass-produced products such as industrial control systems, or limited production products where the software engineering costs are relatively more important than the costs of the integrated circuits. Also, even for mass produced products that are subject to frequent changes in the firmware to be executed by the embeddedmicroprocessor 10, the costs of changing the firmware are high and theFIG. 1 approach is relatively expensive and inefficient. Hence, this approach has significant drawbacks in terms of development time and engineering cost. - In accordance with this invention, a control system, for instance an embedded control system for controlling a device, operates such that the burden of accepting human user (or machine) input and providing information (output) to a human user or a machine via, e.g., a display is shifted from the embedded microprocessor to a second processor. The second processor, designated here a “hypertext” processor, is e.g. a microprocessor, microcontroller, or similar structure capable of processing a hypertext markup language document, as explained below. The embedded control system controls and/or monitors the controlled device and is application specific, unlike for instance a personal computer which can run any application program. The display controller of
FIG. 1 is effectively eliminated and its functions instead associated with the hypertext processor. Both the user (or machine) input device and the display (or other output device) are coupled to the hypertext processor and not to the embedded microprocessor. The hypertext processor is a second, e.g., microprocessor which may be on a chip separate from the embedded microprocessor. - The hypertext processor determines what operations to take upon receipt of, e.g., user input, for instance from a connected keypad. The hypertext processor performs actions described in the hypertext markup language document and commands the embedded microprocessor to act on the controlled device and to update its internal shared variables. The hypertext processor also updates the display as a function of the shared variables internal to the embedded microprocessor. The user interface software (code) is not resident in the hypertext processor, nor is it executed/interpreted by the embedded microprocessor. Instead, a (hypertext) document describing the user interface is external to the hypertext processor, and resident in the memory space of the embedded microcontroller or in a serial memory device (i.e. serial EEPROM, FLASH ROM, smart card, etc.). This hypertext document describing the user interface is provided (“served”) to the hypertext processor at the request of the hypertext processor. Thus the user interface is actually executed by the hypertext processor even though it does not permanently reside there.
- In one embodiment, the user interface document is encoded in a particular hypertext markup language (HTML) called here μGHTML. The generic name “Hypertext Markup Language” refers to: Hypertext—A method for providing links within and between documents; popularized by multimedia authoring systems which used the hypertext concept to link the content of a text document to other documents encoded in certain multimedia formats. Markup Language—A method for embedding special control codes (TAGS) that describe the structure as well as the behavior of a document.
- Like conventional HTML, PHTML files (“documents”) contain both control information (markup tags) and content (ASCII text), which together describe the appearance and content of a user interface. In addition, both markup languages provide capability to reference resources external to the document. Compared to conventional HTML, μHTML is smaller, easier to interpret, and defines a special library of GUI (graphical user interface) objects, data processing objects suitable for pipelining, and other system utilities common to embedded systems software. One key feature of μHTML is its ability to describe the interface to resources distributed among networked embedded subsystems and to link the data of these resources to the functions of a host processor.
- In order to make μHTML easy to parse, it is headed by a directory of pointers to each tag. To make it compact, each tag is represented by a single byte (hereinafter referred to as an opcode). Following each opcode is a unique set of binary properties data, such as X-Y coordinate information, pointers to other resources, and other properties. There is a unique opcode for each object in the GUI object library. These objects are, e.g., push buttons, pop-up lists, and other sorts of visual (or aural) indicators. There are also opcodes for objects that contain methods to process or redirect data to and from other objects or external resources, e.g., an object referencing a variable from “
external resource 0” may sample the variable data every 100 mS, and route the results to another object referencing a variable from “external resource 1”. Each library object opcode is followed immediately by a data structure unique to the object. The data contained in the data structure is specific to the instance of the library object. In this way, the memory allocated for each instance of all used objects is statically allocated in the memory buffering the μHTML document. When external resources are referenced, a data structure is provided to describe the format of the messages required to provide access to the external resource. For instance, to read a variable associated with an external device, the data structure describes a “Get” command and a “Return” response. Typically the Get command contains an identification to some external device and an index into a lookup table on the external device that provides references to variables, functions or files. In addition to the external device identification and lookup table index, the Return response also contains the data requested. - In one embodiment this user interface hypertext document is developed using conventional internet web page development tools of the type commercially available; this is not limiting. User interface objects are simulated in one embodiment with JAVA applets that correspond to objects in the GUI object library. The simulated GUI objects are referenced from within the conventional HTML document by using the same standard tags used to reference any conventional JAVA applet. Standard HTML tags are also used to format the display content and to point to resources resident to devices external to the hypertext processor.
- The user interface document can then be viewed on a conventional web browser, for system development purposes. (Of course this has little to do with the actual user operation of the controlled device but is part of its user interface design and development.) This HTML/JAVA web page can then be converted (pre-compiled) to a more compact μHTML format by a compiler designed specifically to: (1) remove the conventional HTML tags and replace them with a corresponding μHTML opcode; (2) convert the attributes strings of the HTML tags to a binary structure appropriate for the μHTML opcode; (3) replace references to all JAVA applets and parameters with a corresponding opcode and object data; (4) reformat and add additional data to simplify parsing and execution by the hypertext processor, and (5) resolve references to resources external to the hypertext processor (i.e. executable code or variable data resident to an external embedded microprocessor, storage in an external serial memory device, I/O functions of an external serial I/O device, etc.). This is only illustrative of development of a system in accordance with this invention.
- Moreover, the present invention is directed to more than a user interface processor. It is additionally directed to use of a hypertext markup language to provide program flow and structure while linking together resources distributed among embedded subsystems, even if the subsystems do not have user interfaces. That is, the invention more broadly contemplates a dedicated processor programmed with a hypertext markup language rather than with conventional application code.
-
FIG. 1 shows a prior art embedded control system for a controlled device. -
FIG. 2 shows an embedded control system in accordance with this invention. -
FIG. 3 shows a more detailed diagram of the markup language processor ofFIG. 2 . -
FIG. 4 shows an HTML file and associated request handler in accordance with the invention. -
FIG. 5 shows the relationship between the HTML source file ofFIG. 4 and a version compiled to μHTML. -
FIG. 2 shows a block diagram of a control system for a controlled device in accordance with this invention. Blocks similar to those ofFIG. 1 have identical reference numbers. InFIG. 2 , thedisplay controller 24 ofFIG. 1 is replaced by asecond hypertext processor 40 which may be (not necessarily) a single integrated circuit and which is an intelligent device, unlike thedisplay controller 24. Thus in theFIG. 2 structure there are two intelligent devices (processors), one of which is thehypertext processor 40 and the second of which is, e.g., the embedded microprocessor (or other device) of which several are shown labeled 42 a etc. Thehypertext processor 40 interfaces both to theuser input device 14 and to thedisplay elements markup language processor 40. Any networked I/O device such as 42 a, 42 b, or 42 d that acts upon a controlled or monitoreddevice 29 may have resources that are referenced by the user interface document(s). “Networked” here refers to device connectivity using standard protocols. It includes both “intra-product” networking (connecting several devices within one enclosure) and “inter-product” networking (connecting devices each in its own enclosure.) -
FIG. 2 shows different types of devices optionally connected by aconventional network 46 tomarkup processor 40. These connected devices include embeddedmicrocontroller 42 a, serial I/O (input/output)device 42 b, μHTML storage device 42 c, and embeddedmicrocontroller GUI server 42 d including its own μHTML storage. Of course other connection arrangements are possible with any number or combination of devices or networks connected to themarkup language processor 40 as long as there is at least one device, e.g., 42 c capable of storing the μHTML document(s). Also, because a single μHTML document may contain links to the resources of different devices on the network, it is not necessary for every device onnetwork 46 to contain storage for μHTML documents. - Although
FIG. 2 shows only one controlleddevice 29 connected to a plurality of devices, there may be one or more such controlled devices that may be controlled (or monitored) by one or more of the networked I/O devices 42 a, etc. In addition, the networked I/O 42 a, etc. devices may or may not be located in the same physical enclosure. For example, the components of a microwave oven may be networked in the same physical enclosure. However, the components of a home entertainment system (e.g., surround sound receiver/amplifier, VCR, CD/DVD player) may all be networked to a hypertext processor, e.g. in a television set, but each housed in its own physical enclosures. - Also, while the
various blocks FIG. 2 in one embodiment are separate integrated circuits, the partitioning amongst the various integrated circuits may be otherwise, for instance, all of theFIG. 2 system may be on a single integrated circuit with the possible exception of theuser input device 14, controlleddevice 29, anddisplay 20. The partitioning of the depicted blocks amongst various integrated circuits is not critical to this invention. - The following describes each functional block of the
hypertext processor 40 ofFIG. 2 : -
Network controller 58 formats and transmits all bytes of data queued by theμHTML processor 60 via thenetwork 46. It also decodes any data received from thenetwork 46 and places it in a queue to be processed by theμHTML processor 60. -
User input decoder 62 detects and decodes input fromuser input device 14 which is, e.g., a keypad, touch screen, voice command decoder or IR (infrared) remote device.Decoder 62 places data describing a user input event into a queue to be processed by theμHTML processor 60. -
μHTML processor 60 operates on data stored inμHTML buffer 64 to reflect events queued from theuser input decoder 62 andnetwork controller 58.Processor 60 is also responsible for generating and queuing events for thenetwork controller 58 in response to system or user events that are linked to such events by the data in theμHTML buffer 64. -
μHTML buffer 64 is RAM (random access memory) storage for a complete μHTML document describing all objects to be rendered to thedisplay device 20. Each object contained in the μHTML document may also contain references to other network resources.Buffer 64 is only written to and modified by theμHTML processor 60 in response to user input events, system events or events generated in response to network messages. It is read by both therendering engine 52 and theμHTML processor 60.μHTML buffer 64 is a section ofRAM 72 accessible only by the microprocessor 68 (seeFIG. 3 ). - The
rendering engine 52 only reads the graphic information for each UI object as required to properly draw the user interface to theframe buffer 30. TheμHTML processor 60 reads the information required to generate system or network events in response to other events related to each UI object. -
Rendering engine 52 draws all displayable user interface objects to theframe buffer 30 as described by the data stored in theμHTML buffer 64. It refreshes each UI object when marked as “dirty” in theμHTML buffer 64 by theμHTML processor 60.Rendering engine 52 is firmware executed bymicroprocessor 68 and stored in ROM 70 (seeFIG. 3 ). Each μHTML object contains code to render all views of the object. -
Frame buffer 30 is RAM storage that contains the data for each pixel of the entire displayed page. It is written to by therendering engine 52 as it draws the user interface ondisplay 20. It is read from by thepixel serializer 36 as it converts the pixel information to signals appropriate to drive thephysical display 20.Frame buffer 30 ofFIG. 2 is a section of RAM 72 (seeFIG. 3 ) accessible by microprocessor 68 (seeFIG. 3 ) and thepixel serializer 36. -
Pixel serializer 36 generates a continuous pixel stream in a format compatible with a specific commercially availablephysical display 20. As an example, when interfacing to an LCD panel (display 20), the pixel serializer collects and formats each line of pixel data from theframe buffer 30 and synchronizes it with the conventional display driver pixel clock, frame pulse and line pulse signals. The pixel clock signal clocks the pixel data into the display drivers' internal shift register. The line pulse signal indicates the end of a display line while the frame pulse signal marks the first line of the displayed page. - The
FIG. 2 structure advantageously allows use of commercially available internet web page authoring tools (such as HTML) to use “drag and drop” graphic user interface authoring for development of microprocessor based embedded systems. Also, it allows a simple and consistent serial interface vianetwork controller 58 todevices display 20. In other words, the intelligence for control of thedisplay 20 is provided in theprocessor 40 and need not be coded in the embeddedmicroprocessor 42 a software. - This eliminates the conventional programming, for example in assembler or C, required to implement graphical user interface objects that are linked to the variables and functions of the embedded
microprocessor 10 such as is required in the prior art system ofFIG. 1 . It also allows development of the program flow by the non-software engineers who typically specify the application for the controlleddevice 29 ofFIG. 2 and thereby understand the application and user interaction, but not perhaps firmware programming. This allows quicker and more accurate program development while freeing up the experienced firmware developers to concentrate on the technical program and also yielding better partitioning of a development project into smaller more manageable chunks that may be developed in parallel. -
FIG. 3 shows a “hardware” oriented block diagram of thehypertext processor 40 ofFIG. 2 .Processor 40 connects to one of the embeddeddevices 42 a etc. In this case, theprotocol engine 58 ofFIG. 2 is shown as queuedserial interface 58′ which is, for instance, a UART/SPI/I2C interface. These are examples of industry standard interfaces suitable for the “intra-product” networking described above. SPI (Serial Peripheral Interface) is a popular synchronous serial communication scheme for networking of integrated circuits contained in embedded systems. It was designed by Motorola and popularized by MAXIM, Harris, SanDisk, and others. It is supported by many microcontrollers and serial I/O devices such as A/D and D/A converters, solenoid drivers, digital potentiometers, real time clocks, EEPROM, FLASH ROM, among many others. I2C-Bus (Inter-IC Bus) is another popular synchronous serial network architecture popularized by Philips and is simpler, but slower than SPI. Like SPI, many serial I/O and storage functions are available. However, many more consumer product functions are available, i.e. television and stereo building blocks. Examples of suitable interfaces forprotocol engine 58′ for “inter-product” networks are IEEE-1394, USB, or Ethernet. In conjunction with appropriate firmware executed by themicroprocessor 68 and stored inROM 70protocol engine 58 services interrupts generated by the connected devices and manages queues. - The
user input decoder 62 is shown inFIG. 3 as akeypad scan decoder 62′ which connects to akeypad 14. In conjunction with appropriate firmware executed by themicroprocessor 68 and stored in ROM (read only memory) 70,decoder 62 services interrupts generated by the connected devices and manages queues. The remaining blocks inFIG. 3 support the other functions ofmarkup language processor 40 ofFIG. 2 . This is accomplished in terms of circuitry by microprocessor “core” (this is the microprocessor without the supporting memory, etc.) 68 which in turn is connected to astandard bus 76 which interfaces as shown to the other blocks withinprocessor 40. Typically, theentire processor 40 ofFIG. 3 would be a single integrated circuit. -
μHTML Processor 60 ofFIG. 2 inFIG. 3 is firmware executed bymicroprocessor 68 and stored inROM 70. In addition to routines to service interrupts, handle events and manageRAM 72 basedqueues 78 and buffers, this also contains a library of routines that operate on and according to the specific data structures of each μHTML object. These objects may contain, but are not limited to, user interface objects, data processing objects and operating system objects. The data for each instance of an object is contained in the μHTML document buffered in theRAM 72 area called theμHTML buffer 64. Each μHTML object in thelibrary 84 inROM 70 contains code to (1) access and modify the data defining the instance of the object (from μHTML buffer 64), (2) render all views of the object to RAMframe buffer 30, (3) respond to events related to the object and (4) queue messages to be sent to other network resources. - The structures in
FIG. 3 include (in ROM 70)main program storage 88 andevent handlers 90 and (in RAM 72)stack 96 andheap 98.Pixel serializer 36 ofFIG. 2 is depicted as hardware (circuitry) inFIG. 3 . - The block diagrams of
FIGS. 2 and 3 are descriptive of a range of structures which may be implemented in various combinations of dedicated hardware (circuitry) and software (computer code) executed by various types of processors. The particular partitioning between hardware and software disclosed herein is not intended to be limiting. -
FIG. 4 illustrates an example of an application used in accordance with this invention. Specifically, the central portion ofFIG. 4 , which is thetext 86, is an HTML file, that is a hypertext markup language document which links display items of an LCD display 88A to resources of an embedded microprocessor. The various lines of text in 86 contain either: (1) text to be displayed such as “Two Variables” or “LED 0”, or (2) markup tags (enclosed between<and>) to reference GUI object library components and link them to resources external to the HTML document and markup language processor. In this example, the embedded microprocessor resources are accessed through the embeddedmicroprocessor software program 92. - The embedded microprocessor resident resources accessed by
program 92 are: two variables in this case containing thevalues - Likewise the functions referenced by the <PARAM Name=“Send” . . . > are invoked when the user activates the buttons rendered by the FunctBtn objects.
- Associated with this
document 86 is embeddedrequest handler 92, shown in the right hand portion ofFIG. 4 with lines relating it to the markup indocument 86. Thishandler 92 is resident in an embedded microprocessor such as, with reference toFIGS. 2, 42 a or 42 d to provide access to the resources requested via the network. This code in 92 may be implemented in hardware for example in serial memory devices such as, with reference toFIGS. 2, 42 c or in serial I/O devices such as 42 b. The “client” in thecode 92 is a reference to themarkup language processor 40. Thus, while the data described bydocument 86 is actually interpreted by themarkup language processor 40, thecode 92 is actually executed by the embeddedmicroprocessor 42 a in conjunction therewith. -
FIG. 5 shows a repetition of the HTML source file (left side) 86 ofFIG. 4 with a compiled μHTML version of same (right side). This compiled μHTML version is much more compact; the lines relate the source file code to its compiled version. In addition, the μHTML is easier to interpret at runtime, because things such as string lengths, tag offsets, X-Y coordinates are computed by the compiler and built into the structure of the document. Of course there is no requirement to use HTML or μHTML or to compile same, however, this provides efficiencies in carrying out one embodiment of the present invention. - Alternatives to use of the μHTML disclosed here are other forms of text documents with control codes used to access resources located elsewhere. Examples of other markup languages are compact HTML, and HDML. Even the old UNIX “troff” is a markup language which was originally designed for page layout.
- Memory devices (such as 42 c) (
FIG. 2 ) external to theprocessor 40 are thereby responsible for “hosting” the μHTML and other files. Whether the external device is anothermicroprocessor 42 d, or simply a serial memory device 42 c, it reacts to requests from theprocessor 40 to read or write files. Inaddition devices 42 a etc. connected to theprocessor 40 may also support requests to read/write variables, invoke functions and provide state information while performing the normal I/O device functionality. - The embedded memory device 42 c is thereby responsible for “hosting” the μHTML and other files. It responds to requests from the hypertext processor and keeps track of changes to variables in use by the hypertext processor and executes the controlled device functionality. The hypertext processor is responsible for rendering the graphical user interface to the display. The hypertext processor is also responsible for responding to user input from the user input device by updating display graphics and communicating with external devices to request changes to the values of external variables and to invoke external functions as described by the μHTML document. The hypertext processor is also responsible for responding to changes in the embedded microprocessor variables by updating the display device graphics. Typical requests to the embedded microprocessor by the hypertext processor are: open connection; get file (for instance a μHTML file, an image graphic file or a script); call up functions; get a value of the variable; send value of the variables and obtain status of the embedded microprocessor. “Script” refers here to files that contain code to be executed by the microprocessor portion of the hypertext processor.
- This disclosure is illustrative and not limiting; further modifications will be apparent to one skilled in the art in light of this disclosure and are intended to fall within the scope of the appended claims.
Claims (33)
1-17. (canceled)
18: A method for programming a graphic user interface (“GUI”) implemented by a first controller for a device independently from a second controller that monitors and controls the device, the method comprising:
creating a HTML page defining an appearance of the GUI, said creating comprising:
selecting an applet code of a GUI object and arranging the applet code on the HTML page;
setting a source or a destination of a parameter of the GUI object;
compiling the HTML page, comprising
replacing the applet code with an operation code (“opcode”) identifying the GUI object;
setting an operand identifying the source or the destination of the parameter of the GUI object;
loading the compiled HTML page into at least one memory in the device, wherein in response to the opcode and the operand, the GUI controller executes executable codes in at least one memory to communicate the parameter with the source or the destination and to render the GUI object in response to the parameter.
19: The method of claim 18 , wherein said communicating the parameter with the source comprises receiving a status of the device from the second controller.
20: The method of claim 18 , wherein said communicating the parameter with the destination comprises sending a user command to the second controller.
21: The method of claim 20 , further comprising executing the executable codes to receive the user command from an input device.
22: A first controller providing a graphical user interface (“GUI”) for a device independently from a second controller that monitors and controls the device, the first controller comprising:
at least one memory comprising:
a document buffer storing a document, the document comprising an operation code (“opcode”) identifying a GUI object in the GUI and an operand identifying a parameter of the GUI object, the GUI object being a graphical presentation of the parameter, the parameter being from the second controller;
a frame buffer for storing at least one complete frame of the GUI including the GUI object;
a GUI object library storing executable codes defining an appearance and a functionality of the GUI object, the executable codes comprising instructions for receiving non-graphical data of the parameter from the second controller and rendering the GUI object in response to any change to the parameter;
a processor coupled to the second controller and the at least one memory, wherein the processor (1) reads the opcode and the operand, (2) reads the executable codes, (3) executes the executable codes to (a) receive the non-graphical data of the parameter from the second controller and (b) render the GUI object in response to any change to the parameter independently from the second controller, and (4) saves the rendered GUI object in the frame buffer.
23: The first controller of claim 22 , further comprising an output device coupled to the frame buffer to receive the GUI, the output device displaying the GUI to the user.
24: The first controller of claim 23 , wherein the output device is a liquid crystal display (“LCD”).
25: The first controller of claim 24 , further comprising a pixel serializer coupled between the frame buffer and the LCD, the pixel serializer outputting each line of the GUI in the frame buffer to the LCD.
26: The first controller of claim 22 , wherein the parameter is a status of the device from the second controller to the user.
27: The first controller of claim 26 , wherein the GUI object is a text field.
28: The first controller of claim 22 , further comprising another memory coupled to the processor, the another memory storing the document, the processor loading the document from the another memory to the at least one memory.
29: The first controller of claim 22 , wherein the second controller further comprises another memory storing the document, the second controller reading the document from the another memory and sending the document to the first controller, the first controller loading the document in the at least one memory.
30: A method for a first controller to generate a graphic user interface (“GUI”) for a device independently from a second controller that monitors and controls the device, the method comprising:
loading a document into a document buffer in at least one memory, the document defining an appearance of the GUI, the document comprising an operation code (“opcode”) identifying a GUI object and an operand identifying a parameter of the GUI object, the GUI object being a graphical presentation of the parameter, the parameter being from the second controller;
in response to the opcode and the operand, retrieving executable codes of the GUI object from a GUI object library stored in the at least one memory, the executable codes defining an appearance and a functionality of the GUI object, the executive code comprising instructions for receiving non-graphical data of the parameter from the second controller and rendering the GUI object in response to any change to the parameter;
independently from the second controller, executing the instructions to receive the non-graphical data of the parameter from the second controller and to render the GUI object in response to any change to the parameter;
writing the rendered GUI object in a frame buffer in the at least one memory; and
sending the rendered GUI object from the frame buffer to an output device, wherein the output device displays the GUI to a user.
31: The method of claim 30 , wherein the output device is a liquid crystal display (“LCD”).
32: The method of claim 30 , wherein the parameter is a status of the device from the second controller to the user.
33: The method of claim 32 , wherein said rendering the GUI object comprises drawing a text field.
34: The method of claim 30 , further comprising reading the document from another memory prior to said loading the document into the at least one memory.
35: The method of claim 30 , further comprising receiving the document from the second controller prior to said loading the document into the at least one memory.
36: A first controller providing a graphical user interface (“GUI”) for a device independently from a second controller that monitors and controls the device, the first controller comprising:
at least one memory comprising:
a document buffer storing a document, the document comprising:
an operation code (“opcode”) identifying a GUI object in the GUI, the GUI object being a graphical presentation of a user input, the user input being from an input device; and
an operand identifying a destination of the user input, the destination being the second controller;
a frame buffer for storing at least one complete frame of the GUI including the GUI object;
a GUI object library storing executable codes defining an appearance and a functionality of the GUI object, the executable codes comprising instructions for (1) receiving the user input from the input device, (2) rendering the GUI object in response to any change to the user input, and (3) sending non-graphical data of the user input to the second controller;
a processor coupled to the input device, the second controller, and the at least one memory, wherein the processor (1) reads the opcode and the operand, (2) reads the executable codes, (3) executes the executable codes to (a) receive the user input from the input device, (b) render the GUI object in response to any change to the user input independently from the second controller, and (c) send the non-graphical data of the user input to the second controller, and (4) saves the rendered GUI object in the frame buffer.
37: The first controller of claim 36 , further comprising an output device coupled to the frame buffer to receive the GUI, the output device displaying the GUI to the user.
38: The first controller of claim 37 , wherein the output device is a liquid crystal display (“LCD”).
39: The first controller of claim 38 , further comprising a pixel serializer coupled between the frame buffer and the LCD, the pixel serializer outputting each line of the GUI in the frame buffer to the LCD.
40: The first controller of claim 36 , wherein the input device is one of a touch screen, a key pad, an infrared remote, and a voice decoder.
41: The first controller of claim 40 , wherein the GUI object is one of a button and a list.
42: The first controller of claim 36 , further comprising another memory coupled to the processor, the another memory storing the document, the processor loading the document from the another memory to the at least one memory.
43: The first controller of claim 36 , wherein the second controller further comprises another memory storing the document, the second controller reading the document from the another memory and sending the document to the first controller, the first controller loading the document in the at least one memory.
44: A method for a first controller to generate a graphic user interface (“GUI”) for a device independently from a second controller that monitors and controls the device, the method comprising:
loading a document in a document buffer in at least one memory, the document defining an appearance of the GUI, the document comprising:
an operation code (“opcode”) identifying a GUI object in the GUI, the GUI object being a graphical presentation of a user input, the user input being from an input device; and
an operand identifying a destination of the user input, the destination being the second controller;
in response to the opcode and the operand, retrieving executable codes of the GUI object from a GUI object library stored in the at least one memory, the executable codes defining an appearance and a functionality of the GUI object, the executable codes comprising instructions for (1) receiving the user input from the input device, (2) rendering the GUI object in response to any change to the user input, and (3) sending non-graphical data of the user input to the second controller;
independently from the second controller, executing the instructions to (1) receive the user input from the input device, (2) render the GUI object in response to any change to the user input, and (3) send the non-graphical data of the user input to the second controller;
writing the rendered GUI object in a frame buffer in the at least one memory; and
sending the rendered GUI object from the frame buffer to an output device, wherein the output device displays the GUI to a user.
45: The method of claim 44 , wherein the output device is a liquid crystal display (“LCD”).
46: The method of claim 44 , wherein the input device is one of a touch screen, a key pad, an infrared remote, and a voice decoder.
47: The method of claim 46 , wherein said rendering the GUI object comprises drawing one of a button and a list.
48: The method of claim 44 , further comprising reading the document from another memory and loading the document in the at least one memory.
49: The method of claim 44 , further comprising receiving the document from the second controller and loading the document in the at least one memory.
Priority Applications (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US11/502,071 US20070106928A1 (en) | 1999-03-05 | 2006-08-09 | Graphical user interface engine for embedded systems |
Applications Claiming Priority (3)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US26314899A | 1999-03-05 | 1999-03-05 | |
US09/692,997 US7100118B1 (en) | 1999-03-05 | 2000-10-20 | Graphical user interface engine for embedded systems |
US11/502,071 US20070106928A1 (en) | 1999-03-05 | 2006-08-09 | Graphical user interface engine for embedded systems |
Related Parent Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US09/692,997 Continuation US7100118B1 (en) | 1999-03-05 | 2000-10-20 | Graphical user interface engine for embedded systems |
Publications (1)
Publication Number | Publication Date |
---|---|
US20070106928A1 true US20070106928A1 (en) | 2007-05-10 |
Family
ID=23000576
Family Applications (2)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US09/692,997 Expired - Lifetime US7100118B1 (en) | 1999-03-05 | 2000-10-20 | Graphical user interface engine for embedded systems |
US11/502,071 Abandoned US20070106928A1 (en) | 1999-03-05 | 2006-08-09 | Graphical user interface engine for embedded systems |
Family Applications Before (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US09/692,997 Expired - Lifetime US7100118B1 (en) | 1999-03-05 | 2000-10-20 | Graphical user interface engine for embedded systems |
Country Status (5)
Country | Link |
---|---|
US (2) | US7100118B1 (en) |
EP (1) | EP1090344B1 (en) |
CA (1) | CA2334233C (en) |
DE (1) | DE60007252T2 (en) |
WO (1) | WO2000052564A2 (en) |
Cited By (6)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20080210475A1 (en) * | 2003-08-21 | 2008-09-04 | Microsoft Corporation | Ink Editing Architecture |
US20100149189A1 (en) * | 2008-12-15 | 2010-06-17 | Personal Web Systems, Inc. | Media Action Script Acceleration Apparatus |
US20100149215A1 (en) * | 2008-12-15 | 2010-06-17 | Personal Web Systems, Inc. | Media Action Script Acceleration Apparatus, System and Method |
US20100149091A1 (en) * | 2008-12-15 | 2010-06-17 | Personal Web Systems, Inc. | Media Action Script Acceleration Method |
US20100149192A1 (en) * | 2008-12-15 | 2010-06-17 | Personal Web Systems, Inc. | Media Action Script Acceleration System |
US20100153692A1 (en) * | 2008-12-15 | 2010-06-17 | Personal Web Systems, Inc. | Media Action Script Acceleration Apparatus |
Families Citing this family (39)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US7013424B2 (en) * | 2001-05-04 | 2006-03-14 | International Business Machines Corporation | Dedicated processor for efficient processing of documents encoded in a markup language |
CN1232322C (en) * | 2001-05-11 | 2005-12-21 | 皇家菲利浦电子有限公司 | Operation of a set of devices |
GB2375851A (en) * | 2001-05-24 | 2002-11-27 | 3G Lab Ltd | Data processing device with generated graphic user interface |
EP1280053B1 (en) | 2001-07-27 | 2010-02-24 | Sap Ag | Method and computer system for providing and processing a human interface description |
EP1280055B1 (en) * | 2001-07-27 | 2010-04-14 | Sap Ag | Method and computer system for creating and processing a browser compliant human interface description |
EP1280054A1 (en) | 2001-07-27 | 2003-01-29 | Sap Ag | Method and computer system for separating and processing layout information and data of a document |
KR20050111045A (en) * | 2004-05-20 | 2005-11-24 | 엘지전자 주식회사 | Washing machine for internet and its operating method |
US20050268291A1 (en) * | 2004-05-27 | 2005-12-01 | International Business Machines Corporation | Specifying user interface interactions for controls in a data driven system |
US8875040B2 (en) * | 2005-06-07 | 2014-10-28 | Rockwell Automation Technologies, Inc. | Universal web-based reprogramming method and system |
BRPI0622274A2 (en) * | 2005-06-09 | 2011-08-09 | Whirlpool Co | device configured to perform a duty cycle to complete a physical operation on an item and device network |
US8005780B2 (en) * | 2005-06-09 | 2011-08-23 | Whirlpool Corporation | Taxonomy engine and dataset for operating an appliance |
US20070118862A1 (en) * | 2005-06-30 | 2007-05-24 | Lg Electronics Inc. | Home appliance with MP3 player |
JP4932369B2 (en) * | 2006-07-27 | 2012-05-16 | ローム株式会社 | Audio signal amplifier circuit, audio apparatus using the same, and volume switching method |
US8555180B2 (en) * | 2007-03-27 | 2013-10-08 | Amulet Technologies, Llc | Smart peripheral architecture for portable media players |
WO2009034170A2 (en) * | 2007-09-14 | 2009-03-19 | Beijer Electronics Products Ab | Display device |
KR101842209B1 (en) * | 2008-06-18 | 2018-03-26 | 톰슨 라이센싱 | Mobile device for preparation of a digital document for the display of said document and the navigation within said document |
US8406388B2 (en) | 2011-07-18 | 2013-03-26 | Zvi Or-Bach | Systems and methods for visual presentation and selection of IVR menu |
US8537989B1 (en) | 2010-02-03 | 2013-09-17 | Tal Lavian | Device and method for providing enhanced telephony |
US8572303B2 (en) | 2010-02-03 | 2013-10-29 | Tal Lavian | Portable universal communication device |
US8687777B1 (en) | 2010-02-03 | 2014-04-01 | Tal Lavian | Systems and methods for visual presentation and selection of IVR menu |
US8879698B1 (en) | 2010-02-03 | 2014-11-04 | Tal Lavian | Device and method for providing enhanced telephony |
US8903073B2 (en) | 2011-07-20 | 2014-12-02 | Zvi Or-Bach | Systems and methods for visual presentation and selection of IVR menu |
US8548131B1 (en) | 2010-02-03 | 2013-10-01 | Tal Lavian | Systems and methods for communicating with an interactive voice response system |
US8594280B1 (en) | 2010-02-03 | 2013-11-26 | Zvi Or-Bach | Systems and methods for visual presentation and selection of IVR menu |
US8681951B1 (en) | 2010-02-03 | 2014-03-25 | Tal Lavian | Systems and methods for visual presentation and selection of IVR menu |
US8625756B1 (en) | 2010-02-03 | 2014-01-07 | Tal Lavian | Systems and methods for visual presentation and selection of IVR menu |
US8553859B1 (en) | 2010-02-03 | 2013-10-08 | Tal Lavian | Device and method for providing enhanced telephony |
US9001819B1 (en) | 2010-02-18 | 2015-04-07 | Zvi Or-Bach | Systems and methods for visual presentation and selection of IVR menu |
US8548135B1 (en) | 2010-02-03 | 2013-10-01 | Tal Lavian | Systems and methods for visual presentation and selection of IVR menu |
US8458605B2 (en) | 2010-02-26 | 2013-06-04 | Amulet Technologies, Llc | Image file as container for widgets in GUI authoring tool |
US9026253B2 (en) | 2011-11-22 | 2015-05-05 | Honeywell International Inc. | Building controller with operating system interaction through an integrated display |
US8867708B1 (en) | 2012-03-02 | 2014-10-21 | Tal Lavian | Systems and methods for visual presentation and selection of IVR menu |
US8731148B1 (en) | 2012-03-02 | 2014-05-20 | Tal Lavian | Systems and methods for visual presentation and selection of IVR menu |
US9521729B2 (en) | 2013-05-23 | 2016-12-13 | Ramin Soheili | Systems and methods for programming embedded devices using graphical user interface |
EP3099081B1 (en) * | 2015-05-28 | 2020-04-29 | Samsung Electronics Co., Ltd. | Display apparatus and control method thereof |
US10120661B2 (en) * | 2015-07-16 | 2018-11-06 | Sugarcrm Inc. | Multi-flavored software execution from a singular code base |
US10838699B2 (en) | 2017-01-18 | 2020-11-17 | Oracle International Corporation | Generating data mappings for user interface screens and screen components for an application |
US10733754B2 (en) | 2017-01-18 | 2020-08-04 | Oracle International Corporation | Generating a graphical user interface model from an image |
US10489126B2 (en) * | 2018-02-12 | 2019-11-26 | Oracle International Corporation | Automated code generation |
Citations (6)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5727159A (en) * | 1996-04-10 | 1998-03-10 | Kikinis; Dan | System in which a Proxy-Server translates information received from the Internet into a form/format readily usable by low power portable computers |
US5815165A (en) * | 1990-01-10 | 1998-09-29 | Blixt; Stefan | Graphics processor |
US5842013A (en) * | 1993-08-09 | 1998-11-24 | Kopp; Martin | Architecture for modular computer system in which one of the modules is dedicated to user-interface task |
US5959640A (en) * | 1996-01-23 | 1999-09-28 | Hewlett-Packard Company | Display controllers |
US6061701A (en) * | 1996-03-22 | 2000-05-09 | Sharp Kabushiki Kaisha | Hypertext document processing apparatus with display means displaying input data and additional display means displaying translated data |
US6714172B2 (en) * | 1997-07-14 | 2004-03-30 | Canon Kabushiki Kaisha | Display control system and its control method, switching device, connection device, peripheral device, peripheral device system, and their control method, and computer readable memory |
Family Cites Families (12)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5253340A (en) * | 1990-01-19 | 1993-10-12 | Canon Kabushiki Kaisha | Data processing apparatus having a graphics device with priority scheduling of drawing requests |
US5838334A (en) * | 1994-11-16 | 1998-11-17 | Dye; Thomas A. | Memory and graphics controller which performs pointer-based display list video refresh operations |
US5805442A (en) | 1996-05-30 | 1998-09-08 | Control Technology Corporation | Distributed interface architecture for programmable industrial control systems |
US5815167A (en) * | 1996-06-27 | 1998-09-29 | Intel Corporation | Method and apparatus for providing concurrent access by a plurality of agents to a shared memory |
EP0853788A1 (en) | 1996-08-08 | 1998-07-22 | Agranat Systems, Inc. | Embedded web server |
US5982445A (en) * | 1996-10-21 | 1999-11-09 | General Instrument Corporation | Hypertext markup language protocol for television display and control |
US5956487A (en) | 1996-10-25 | 1999-09-21 | Hewlett-Packard Company | Embedding web access mechanism in an appliance for user interface functions including a web server and web browser |
CA2278709A1 (en) * | 1997-01-27 | 1998-08-13 | Benjamin Slotznick | System for delivering and displaying primary and secondary information |
US5991795A (en) * | 1997-04-18 | 1999-11-23 | Emware, Inc. | Communication system and methods using dynamic expansion for computer networks |
US6118462A (en) * | 1997-07-01 | 2000-09-12 | Memtrax Llc | Computer system controller having internal memory and external memory control |
US6089453A (en) * | 1997-10-10 | 2000-07-18 | Display Edge Technology, Ltd. | Article-information display system using electronically controlled tags |
US6914605B2 (en) * | 2000-03-21 | 2005-07-05 | Matsushita Electric Industrial Co., Ltd. | Graphic processor and graphic processing system |
-
2000
- 2000-03-03 EP EP00916025A patent/EP1090344B1/en not_active Expired - Lifetime
- 2000-03-03 WO PCT/US2000/005571 patent/WO2000052564A2/en active IP Right Grant
- 2000-03-03 DE DE60007252T patent/DE60007252T2/en not_active Expired - Lifetime
- 2000-03-03 CA CA2334233A patent/CA2334233C/en not_active Expired - Lifetime
- 2000-10-20 US US09/692,997 patent/US7100118B1/en not_active Expired - Lifetime
-
2006
- 2006-08-09 US US11/502,071 patent/US20070106928A1/en not_active Abandoned
Patent Citations (6)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5815165A (en) * | 1990-01-10 | 1998-09-29 | Blixt; Stefan | Graphics processor |
US5842013A (en) * | 1993-08-09 | 1998-11-24 | Kopp; Martin | Architecture for modular computer system in which one of the modules is dedicated to user-interface task |
US5959640A (en) * | 1996-01-23 | 1999-09-28 | Hewlett-Packard Company | Display controllers |
US6061701A (en) * | 1996-03-22 | 2000-05-09 | Sharp Kabushiki Kaisha | Hypertext document processing apparatus with display means displaying input data and additional display means displaying translated data |
US5727159A (en) * | 1996-04-10 | 1998-03-10 | Kikinis; Dan | System in which a Proxy-Server translates information received from the Internet into a form/format readily usable by low power portable computers |
US6714172B2 (en) * | 1997-07-14 | 2004-03-30 | Canon Kabushiki Kaisha | Display control system and its control method, switching device, connection device, peripheral device, peripheral device system, and their control method, and computer readable memory |
Cited By (13)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20080210475A1 (en) * | 2003-08-21 | 2008-09-04 | Microsoft Corporation | Ink Editing Architecture |
US8072433B2 (en) * | 2003-08-21 | 2011-12-06 | Microsoft Corporation | Ink editing architecture |
US20100149091A1 (en) * | 2008-12-15 | 2010-06-17 | Personal Web Systems, Inc. | Media Action Script Acceleration Method |
US20100149215A1 (en) * | 2008-12-15 | 2010-06-17 | Personal Web Systems, Inc. | Media Action Script Acceleration Apparatus, System and Method |
US20100149192A1 (en) * | 2008-12-15 | 2010-06-17 | Personal Web Systems, Inc. | Media Action Script Acceleration System |
US20100153692A1 (en) * | 2008-12-15 | 2010-06-17 | Personal Web Systems, Inc. | Media Action Script Acceleration Apparatus |
US20100149189A1 (en) * | 2008-12-15 | 2010-06-17 | Personal Web Systems, Inc. | Media Action Script Acceleration Apparatus |
US20130002686A1 (en) * | 2008-12-15 | 2013-01-03 | Leonovus Usa Inc. | Media Action Script Acceleration Apparatus, System and Method |
US8432403B2 (en) * | 2008-12-15 | 2013-04-30 | Leonovus Usa Inc. | Media action script acceleration apparatus |
US8432404B2 (en) * | 2008-12-15 | 2013-04-30 | Leonovus Usa Inc. | Media action script acceleration method |
US8441488B2 (en) * | 2008-12-15 | 2013-05-14 | Leonovus Usa Inc. | Media action script acceleration apparatus, system and method |
US8487942B2 (en) * | 2008-12-15 | 2013-07-16 | Leonovus Usa Inc. | Media action script acceleration system |
US8487941B2 (en) * | 2008-12-15 | 2013-07-16 | Leonovus Usa Inc. | Media action script acceleration apparatus |
Also Published As
Publication number | Publication date |
---|---|
DE60007252T2 (en) | 2004-09-16 |
EP1090344A2 (en) | 2001-04-11 |
WO2000052564A2 (en) | 2000-09-08 |
CA2334233C (en) | 2010-10-26 |
US7100118B1 (en) | 2006-08-29 |
DE60007252D1 (en) | 2004-01-29 |
WO2000052564A3 (en) | 2001-01-18 |
EP1090344B1 (en) | 2003-12-17 |
CA2334233A1 (en) | 2000-09-08 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US7100118B1 (en) | Graphical user interface engine for embedded systems | |
RU2466450C2 (en) | Method and system to develop it-oriented server network applications | |
US6715132B1 (en) | Datasheet browsing and creation with data-driven datasheet tabs within a microcontroller design tool | |
AU781596B2 (en) | Data entry in a GUI | |
US20030056215A1 (en) | Tv pip using java api classes and java implementation classes | |
US20020101448A1 (en) | Generating a declarative user interface | |
CN1133119C (en) | Computer system and OSD display method | |
KR100562905B1 (en) | Method for dynamic layout in application program module | |
JPH10240746A (en) | Method for generating single-frame multimedia title | |
EP0477124A1 (en) | Method and apparatus for distributed processing of display panel information | |
US20060078228A1 (en) | Information processing device and program | |
JP2005327251A (en) | System and method for interactive radio application having conditional ui control and screen navigation | |
US20200249965A1 (en) | Display Device with Built-In Web Browser for Graphical User Interface in an Embedded System | |
US6215488B1 (en) | Method and system for designing a graphical user interface for an electronic consumer product | |
US6366297B1 (en) | System and method for displaying modem information on a graphical user interface display | |
US7730500B2 (en) | Application programming interface techniques for accessing operating system resources | |
JP2005025738A (en) | Method, system and computer readable medium for data input and output using non-standard i/o device for web applications | |
US6380955B1 (en) | Applet and application display in embedded systems using bufferless child graphics contexts | |
US6351272B1 (en) | Applet and application display in embedded systems using child and orphan graphics contexts | |
KR20010024488A (en) | System to associate control with applications using drag and drop interface | |
US20010042079A1 (en) | Display control with active hypertext documents | |
US6014511A (en) | O/S abstraction architecture for HID PC applications | |
US20070079245A1 (en) | Method and apparatus for providing application with remote-controllable interface | |
CN110083407B (en) | Method and device for realizing step bar in applet, electronic equipment and storage medium | |
EP1008931A2 (en) | TV PIP applet implementation using a PIP framework |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
STCB | Information on status: application discontinuation |
Free format text: ABANDONED -- AFTER EXAMINER'S ANSWER OR BOARD OF APPEALS DECISION |