Data driven interaction for networked control of a DDI target device over a home entertainment network6456892Abstract A method and system for providing a user interface for a networked target device within a home audio/visual network. The DDI allows any DDI target to describe its physical appearance including controls and displays, etc., to a DDI controller. The controller can be a remote physical device or can be a software program resident on the same or separate device as the target. The controller interfaces with the target to obtain the DDI data and generates a user interface for the target including: 1) interactive controls; and 2) user display information pertinent to the target. The DDI allows the controller to trigger actions on the target as if a user had physically manipulated the controls of the target. The controller and the target are connected to the same communication network. A particular embodiment operates within the HAVi architecture. The controller communicates with the user by using the input and output devices of (typically) the device upon which the controller is executing. This communication can be done in a controller-implementation-dependent manner. The target can be a DCM that controls its device in a implementation-dependent manner. The controller may be written in a generic manner that does not need to be implemented with knowledge of a particular target in mind; all target-dependencies are represented in the DDI data provided by the target to the controller. Claims What is claimed is: Description BACKGROUND OF THE INVENTION
TABLE I
Current Device Setting Action Result
Device Is Not Playing FF Button Pressed Advance to the Next
Track and Hold
Device Is Playing FF Button Pressed Advance to the Next Track
and Continue Playing from
that Point
Device Is Playing FF Button Pressed Play in "Fast Forward"
and Held Down Mode
As shown above, the actions taken by the DDI target device vary based on its current state and what the user does with the physical controls. The DDI of the present invention defines several user action commands such as "PUSH," "PRESS AND HOLD," and "RELEASE" that are triggered by user interaction with the displayed user interface. In accordance with the present invention, the DDI controller 220 of the present invention has no notion of what the DDI target device will do in response to the commands that are issued to it. All concerns regarding a the state transition as shown in the Table I are handled inside of the DDI target device. It is appreciated that the DDI target device already needs to have this logic in place in order to process the user interaction on its physical control panel. The DDI of the present invention is viewed as another mechanism by which to access these logical entry points. It is important that the DDI controller 220 keeps the user informed regarding the status of the DDI target device being controlled. In one embodiment, it is possible that the DDI controller 220 and the user are sitting in one room of a house or business office and the DDI target device is located in another room or office. Because the DDI controller 220 has no pre-defined knowledge of how to interpret the user interaction elements, it needs to have a mechanism of keeping its display updated with the most current status of the DDI target device. It does this by making use of a status reporting mechanism including status notification messages in accordance with the present invention. The status information of the target 210 is dynamic and is represented in an internal data structure that is kept up-to-date by the DDI 314 of the present invention. The DDI target can send status updates to the DDI controller upon state changes. Alternatively, the DDI controller 220 can examine this structure at any time so that it can update its graphical display to indicate the DDI target device status to the user. A status notification command allows the DDI controller 220 to post a notification request to the DDI target device. When any change in the state of the device results in a change to the status descriptor data structure, then the DDI target device sends a notification to the DDI controller 220. The DDI controller 220 then updates its graphical display as appropriate in response to the status information. Part of the DDI data structures includes geometry information describing the layout image and orientation of panels and controls so that they can be represented to the user in a manner similar to their physical appearance on the DDI target device or in a manner "suggested" by the DDI target device. As standard controls can be combined into hybrid controls, this geometry information can also be defined to indicate the presence of panel hierarchies, such as panels hidden behind a front flip-down face 220 (FIG. 4B). This is commonly found in many VCR devices where some basic controls are on the face of the VCR device and the more advanced controls and features are hidden behind the flip-down front panel 220. DDI MESSAGE SEQUENCE PROTOCOL FIG. 6 illustrates the DDI message sequence protocol of the present invention between a particular DDI controller 220 and a particular DDI target 210. The messages can be represented by APIs (application programming interfaces), examples of which are described further below. Any of a number of well known locator procedures can be used for the DDI controller 220 locating its particular DDI target 210 or vice-versa. Controller-target interaction starts with the DDI controller 220 sending a message, e.g., a SubscribeGui message 410, to the target 210. The DDI target 210 records which software element sent this message 410 for use in possible NotifyGuiChange messages 440 which are described below. The DDI target 210 also returns the name of an initial (or root) GUI element using response message 415. The DDI controller 220 uses the GetGuiElement 420 message with this name as an argument to obtain the complete contents of the root GUI element for rendering on the controller's display device. GUI elements represent the display of the GUI that the DDI controller 220 renders and may include images and/or text describing buttons, sliders, LCD displays, menus, etc., depending on the defined DDI of the target 210. Thereafter, based on user input (e.g., from 106 and/or 107), the contents of the controller's display device 105, and the GUI element(s) the DDI controller 220 obtained from the target 210, the controller can (1) change the information that is being displayed to the user using a controller implementation-dependent mechanism, (2) ask the DDI target 210 for another GUI element using the GetGuiElement message 420 (with the name of the desired GUI element as an argument) or (3) send a control command (determined by the contents of the GUI element and possible user input) to the target using the UserAction message 430 of FIG. 6. At any time after a DDI controller 220 has subscribed to a DDI target 210 and before that DDI controller 220 has unsubscribed to that target 210, the DDI target 210 can indicate that the GUI description held by the DDI controller 220 has changed. This can indicate, for example, that some aspect of the target's internal state which is relevant to the user has changed. The indication is done by the DDI target 210 sending a NotifyGuiChange message 440 to the DDI controller 220. Arguments to this message 440 provide the DDI controller 220 with information about which parts of the target's GUI description have changed. A UserAction message 430 sent to the DDI target 210 by the DDI controller 220 returns to the DDI controller 220 information about those parts of the targets GUI description that have changed as a direct result of the action. For example, a GUI button hit can attempt to place a target device 210 into a rewinding mode and the DDI target 210 may wish to indicate the success (or failure) of the command by returning (via response 435) a text element with an appropriate string value or a graphic image of the result. In this manner, the user and the target device 210 communicate with each other using a sequence of messages sent between the DDI controller 220 and the DDI target 210 guided by the DDI data the controller obtains from the target 210. When the DDI controller 220 is done with the interaction with a target 210, it sends an Unsubscribe message 445 to that target 210. The DDI target 210 thereafter does not send NotifyGuiChange messages 440 to that DDI controller 220 and the DDI controller 220 does not send any other messages to that target 210. The DDI controller 220 is able to open a new interaction by sending another SubscribeGui message 410 to that target 210. In addition to the GetGuiElement message 420 (which takes as an argument the name of a single element and returns the actual element with that name) a DDI target 210 also provides a number of other similar messages for efficiently returning lists of element names or lists of actual elements which are described further below. Because the HAVi DDI mechanism is primarily intended to allow users to interact with devices, the DDI controller 220 that pulls the GUI description functions essentially as a UI-controller. The DDI target 210 that supplies the GUI description is typically a HAVi device control module (DCM). However, it is possible for any application (not only a UI-controller) to act as a DDI controller 220 and for any application (not only a DCM) to act as a DDI target 210 within the present invention. It is also possible for a DDI target 210 to be controlled by more than one DDI controller (as shown in FIG. 3) and for a DDI controller 220 to control more than one DDI target 210. The DDI data used by the DDI controller 220 need not have come from the DDI target 210 being controlled, however, typically it will come from the target 210. Any DDI data that is supplied by a DDI target 210 is generally always appropriate for controlling that target. INPUT/OUTPUT DEVICE MODELS User Output and Input Device Models. The DDI controller 220 manages in an implementation-dependent manner a display device 105 to communicate to the user and a user input device 106/107 to accept commands from the user. In order to allow the DDI model to apply to a broad range of particular devices these devices are modeled abstractly by only specifying in a general manner the way in which DDI data is associated with physical user interaction. The DDI data and its constituent GUI elements provide guidelines on how the DDI controller 220 is to make this association. These guidelines depend on the type and attribute values of the GUI elements. Output Device Model. The GUI elements that the DDI controller 220 obtains from the DDI target 210 can be physically presented, rendered, to the user using the display device. Each GUI element is of a particular type (e.g., panel, icon, button) and each type of GUI element has a particular set of attributes (e.g., size, position, color, image content, audio content). All attributes are divided into two distinct classes: mandatory attributes and optional attributes. In a target's DDI data, the mandatory attributes of a GUI element generally have an associated value and optional attributes may or may not have an associated value. Every GUI element type has one or more mandatory label attributes whose values are text strings. The DDI takes into consideration that there are three broad classes of display devices. The first class is the Full Capability Devices (e.g., high resolution display screen with computer system). These devices can render all GUI elements exactly as described within the DDI of the DDI target 210 taking into account the values of all supplied attributes be they mandatory and optional alike. The second display class is the Scaled-Down Devices. These devices that can render all GUI elements taking into account the values of all mandatory attributes but only some or even none of the values of optional attributes (e.g., small display screen devices). The third class is the Text-Only Devices (e.g., some liquid crystal displays). These devices that can only render text strings and take into account only the values of mandatory label attributes. The DDI controller 220 is also responsible for physically presenting the values of audio attributes of GUI elements as best as it and its display device are able to render. Many GUI element types have attributes that are to be used by the DDI controller 220 to determine position and size on the display device. As shown in FIG. 7, the physical display device 150 (see also FIG. 2) is considered to be a rectangular array of discrete pixels. Position and size information is expressed with respect to a two-dimensional coordinate system for this rectangle with non-negative x and y coordinate values. The upper-left corner 510a of FIG. 7, as the user faces the device, is <0,0> coordinate. The lower-right corner 510c is <MAX_X, MAX_Y> coordinate, where MAX_X and MAX_Y are defined herein below. The positions of GUI elements contained within organizational GUI elements (that is, panel and group elements) are relative to the position of the most immediately containing organizational element. The values that pixels may have and the physical interpretation of the value (e.g., color) are also defined herein below. For many types of GUI elements, attributes that specify their position are optional. When a position attribute is not given for an element, the DDI controller 220 has broad freedom to locate the rendering of that element subject only to the guidelines provided by the place of that element within the overall DDI data of the present invention. Also shown in FIG. 7 are representations of GUI elements. Several buttons 512a-512c are shown as well as an icon image 514. These GUI elements are all within a logical element grouping 516. Input Device Model. Like output to the user, input from the user is modeled generically in accordance with the present invention. In order to present this model, a number of definitions are presented. GUI element types are interactive (e.g., button, set range) or non-interactive (e.g., status), based upon whether they, respectively, can or cannot be used by the DDI controller 220 to send a UserAction message 430 (FIG. 6) to the target 210. GUI element types are user-modifiable (e.g. set range) or non-user-modifiable (e.g., button, icon) depending upon whether they, respectively, have or do not have a user-modifiable attribute. User input is taken into account within the DDI model of the present invention by requiring that a DDI controller 220, in a manner appropriate for the actual physical input device (106, 107), allow the user to perform a number of actions. The user can change the value of a user-modifiable attribute of a user-modifiable GUI element (e.g., enter a new text string into a GUI entry element). The user can select an interactive GUI element (e.g., hit a GUI button element) causing the DDI controller 220 to send a UserAction message 430 to the DDI target 210 with arguments whose values depend on the type of the GUI element and on the particular kind of selection the user performed. The user can also explicitly associate with the display device another GUI panel element by selecting a GUI panel link element. This only affects the display device and it does not directly cause the DDI controller 220 to send a UserAction message 430 to the target 210. This can, however, cause the DDI controller 220 to obtain more GUI elements from the target 210. The display device can be changed by having the DDI controller 220 render GUI elements that are associated with the current GUI panel element but which are not currently rendered. This change only affects the display device and it does not directly cause the DDI controller 220 to send a UserAction message 430 to the target 210. If display resources are otherwise inadequate to render the new GUI elements, the DDI controller 220 may render GUI elements in a manner of its own choosing. For example, the DDI controller 220 may remove an arbitrary element from the current display or allow the user to control a scrolling mechanism. GUI ELEMENTS OF THE DDI Organizational GUI Elements. The GUI elements contained in a target's DDI data are arranged into a hierarchy in accordance with the present invention. This hierarchy serves three purposes. First, it allows a DDI controller 220 to navigate through the GUI elements in an organized way. Second, from the target's point of view, it indicates which GUI elements belong logically together and should, therefore, preferably be displayed physically together to the user. Third, from the controller's point of view, it can be used to let the DDI target 210 know about which GUI element changes the DDI controller 220 should be notified. FIG. 8A illustrates an exemplary hierarchy including two types of organizational GUI elements that determine the hierarchical organization of the elements in a target 210's DDI data. The first type is the GUI panel element 520, which has a (mandatory) attribute whose value is a list of the names of the GUI elements that are contained in the panel. GUI panel elements may not be (directly) contained in other GUI panel elements. The second type is the GUI group element 525a-525b, which has a (mandatory) attribute whose value is a list of the names of the GUI elements that are contained in the group. GUI panel and group elements may not be (directly) contained in other GUI group elements. Both panels and groups can contain non-organizational elements, shown in FIG. 8A as "elements" 522a-522f. Panel and group elements are non-interactive and non-user-modifiable in the sense defined with respect to the input device model. A non-organizational GUI element is defined to be an element that is not an organizational GUI element. Non-organizational GUI elements are discussed below. Non-Organizational GUI Elements. At any point in time, a DDI controller 220 has a current panel which is the GUI panel element that the DDI controller 220 has most recently obtained from the DDI target 210 and which the DDI controller 220 is currently rendering to the best of its abilities (with all its contained GUI elements) on the display device. The DDI controller 220 allows the user to navigate through the current panel's contents by means of the above described hierarchy. The DDI controller 220 can choose to render panels, groups within panels and non-organizational GUI elements within panel or groups. The way in which a DDI controller 220 navigates through the panels and groups is its choice. The only thing that a DDI target 210 can assume is that the user is aware of the panel and the group that contains any GUI element the user may select. The DDI controller 220 (depending on the capabilities of its display device) can assure this in a number of ways. First, by displaying the complete panel, all its groups with all their non-organizational GUI elements. Second, it can assure this by displaying for the panels and groups only their label or icon. Third, it can assure this by displaying the non-organizational GUI elements only. In this case, the DDI controller 220 can still assure that the user knows what he/she is looking at, because he/she steered the navigation through the panels, groups, and GUI elements in a particular way as known to the user. Lastly, some combination of the above can be used. Uses of Organizational GUI Elements. A GUI panel element (and its contained elements) can be used for the presentation and control of a function or a very closely related set of functions in the DDI target 210 device. The panel 520 (FIG. 8A) represents a set of GUI elements which the DDI controller 220 should render together on a single display screen. If this is not possible, the DDI controller 220 may divide/modify the set of panel elements over as few display screens as display capability allows. The user is allowed to navigate through these displays. However, this must be done in a manner consistent with the intention of the designer of the DDI target 210 DDI data that the user considers this set of elements as comprising a whole. Similarly, a GUI group element 525a-525b can be used for the presentation and control of a sub-function of the DDI target 210 device. The elements contained in the group all have the same level of display priority. In situations where the DDI controller 220 cannot render all the groups and other elements in a panel at the exact positions specified by their attributes, the controller 220 can move or choose to (temporarily) not render some groups or other elements. However, the DDI controller 220 makes a strong attempt to keep the elements in a group together when they are rendered. The groups within a panel have a linear ordering of their priorities. The DDI controller 220 when deciding where to position groups and their contained elements or which groups to temporarily not render should favor groups of higher priority. Like the panel and group elements which may contain them, non-organizational GUI elements may have position information supplied by their attributes. If display resources are limited, the DDI controller 220 may change the position of non-organizational GUI elements within their panel or group. Non-Organizational GUI Elements. As defined above, non-organizational GUI elements are those GUI elements that are not panel 520 or group 525a-525b elements. These types of GUI elements occupy leaf device positions in the GUI hierarchy determined by panel and group elements. A non-organizational GUI element has mandatory and optional attributes that suggest to the DDI controller 220 how the element should be rendered and what sort of effect user input should have upon the element, e.g., is the element user-modifiable with respect to the input device model. The attributes also describe what effect user selection should have with respect to the DDI controller 220 sending UserAction messages 430 to the target 210, e.g., is the element interactive in the sense defined in the input device model. What follows is a description of an exemplary subset of non-organizational GUI elements mentioning important mandatory attributes, indicating its use and typical renderings, and categorizing it with respect to interactivity and user-modifiability. The "text element" has a mandatory attribute containing a text string. This element is used to present a static label or other textual information to the user. This element is Non-interactive and non-user-modifiable. The "panel link" element has a mandatory attribute containing the name of a panel element. This element is used for user-driven navigation by the DDI controller 220 and is noninteractive and non-user-modifiable. This GUI element can be used to direct a user back to a main screen or menu item. The "button element" has mandatory attributes that describe a sequence of pressed and unpressed appearances. This GUI element is used to allow a user to send a simple (e.g., without parameters) command to the DDI controller 220 and is interactive and non-user-modifiable. The "choice element" has mandatory attributes that describe a discrete set of possible values of which the user may choose one or a number and thereby indicate to the DDI target 210 some command or course of action. Typical renderings are as many-out-of-many choice boxes or as one-out-of-many radio buttons. This element is Interactive and user-modifiable. The "entry element" allows a user to enter a text string value and send it to the target 210. A typical rendering is as a text entry field with an optional associated on-screen keyboard. This element is interactive and user-modifiable. The "animation element" has a mandatory attribute containing a sequence of icons. If there is only one icon in the sequence, that icon is statically rendered by the DDI controller 220. If there is more than one icon in the sequence the DDI controller 220 renders each icon in temporal sequence giving the user the effect of an animation. This element is interactive and non-user-modifiable. The "show range element" has mandatory attributes defining a numeric range and a particular value within that range. This element is used to present static numeric information to the user. Typical renderings are as a circular meter with variable position pointer or as a linear variable length bar. This element is non-interactive and non-user-modifiable. The "set range element" has mandatory attributes defining a numeric range. This element is used to allow a user to send a command with a numeric parameter to the target 210. Typical renderings are as a slider or dial and this element is interactive and user-modifiable. The actual appearance and position of each GUI element depends on the DDI controller 220. For instance, while a target's DDI data provides an explicit logical structure for its GUI elements, it only gives suggestions to the DDI controller 220 for their rendering. FIG. 8B illustrates an exemplary hierarchy using the above defined GUI elements. In this exemplary structure, panel 520 directly includes two text GUI elements 524a and 524b. Group 525a includes two button GUI elements 524c and 524d and also a choice GUI element 524e. Group 525b includes an animation GUI element 524f, an entry GUI element 524g and a show range GUI element 524h and a set range GUI element 524i. PROCESS FLOW FOR DDI INTERACTION FIG. 9A, FIG. 9B and FIG. 9C illustrate the high level steps of the process flow of the DDI interaction between a DDI target 210 and a DDI controller 220 in accordance with one embodiment of the present invention. These steps are realized as program code stored in computer readable memory units of computer systems and are executed by processors. Process 910 of FIG. 9A commences at step 912 where a DDI controller 220 subscribes to a particular DDI target 210 using the subscribe GUI message 410 of FIG. 6. Once subscribed, the DDI target 210, at step 914, forwards the root GUI element identification of its DDI hierarchy to the subscribing DDI controller 220. From steps 916 and 918, and based on the root element identification, the DDI controller 220 can walk through the DDI hierarchy thereby requesting leaf GUI elements and other organizational GUI elements (e.g., panels and objects) as described herein. At step 916, GUI element identification requests 420 are made of the DDI target 210. At step 918, GUI elements are forwarded to the DDI controller using messages 425. At step 920, this continues until the GUI is downloaded from the DDI target device 210 to the DDI controller 220. At step 922 of FIG. 9A, a representation of the graphical (or textual) user =interface that is described by the downloaded DDI is rendered on the DDI controller 220. The representation depends on the display capability of the DDI controller 220. The user is thereby allowed to interface with the DDI as rendered on the DDI controller 220. Process 922 is described in more detail in the below section "DDI Controller Presentation." Process 922 is also described in more detail in FIG. 9B and is described from the point of view of the DDI controller 220. At step 924, the user interacts in some way with the user interface devices of the GUI of the DDI controller 220. This can include pressing a button, moving a dial, pressing a remote control button or knob, switching a toggle, interfacing with a gauge, typing in a number, moving a rocker switch, interfacing with a displayed graphic or textual information of a display screen, entering an audible tone or signal, clicking a mouse button, etc. At step 926, the controller 220 decodes the user interaction into a user event as defined by the relevant GUI element that was used. The user event is forwarded over the network to the DDI target 210 using a user event message 430 including the GUI element identification and the action taken. At step 928 of FIG. 9B, a notification of the changed element in the form of a response message 435 is immediately forwarded to the controller 220 by the target 210 so that the controller 220 can update its GUI, if necessary, as a result of the user action. Message 435 is in response to message 430, generally. For instance, if an icon of a button was depressed, the target 210 would immediately forward this state of the GUI button element to the controller 220 so that the controller 220 would update the representation of the button as being depressed at step 930. Message 435 includes the GUI element identification and a new state code. Also at step 928, the target 210 can indicate changes in a GUI element that are a result of some decision of the target 210 and/or a new operational state of the target 210 that is based on a previous user action, or based on some third hand interaction with the target 210, e.g., a direct interface with the physical panel (assuming one exists) of the target device 210. These messages are represented by messages 440. Process 922 continues as long as the DDI controller 220 is subscribed as shown by step 932. FIG. 9C illustrates process 940 of the DDI target 210 which operates generally concurrently with process 922. At step 942, the DDI target 210 receives a user action (from a DDI controller 220), sometimes called a user event, in the form of message 430. At step 944, an immediate response (if necessary) is sent to the DDI controller 220 in the form of message 435 so that the DDI controller 220 can update its GUI to reflect the user action. For instance, change a displayed icon to represented a depressed button as a result of a button being pressed by the user. At step 946, the target device 210 interprets the user action to determine if a new operational state is to be entered as a result of the user interaction. For instance, if the user action was a press of a GUI button element with label "play," then a target tape device might likely initiate its internal tape playback mechanism. At step 948, an internally generated device state (for example, the "end-of-tape" condition for the tape player mentioned above) may result in the target device sending a NotifyGuiChange message 440 to the controller. As shown by 950, this process 940 continues as long as the DDI controller 220 is subscribed. NAVIGATION AROUND THE GUI HIERARCHY DDI controller 220-Driven Navigation. If a DDI controller 220 chooses not to render a whole panel, then the DDI controller 220 generally provides some means consistent with the capabilities of the user input and display output devices to allow the user to bring un-rendered elements into view. To allow the user to control this process, the DDI controller 220 can render items of its own choosing (e.g., arrows, scroll bars, etc.). These items are not obtained from the DDI target 210 and are specific to the DDI controller 220 implementation. If the DDI controller 220 implements DDI controller 220-driven navigation, it does so locally without explicit DDI target 210 involvement. That is, the DDI controller 220 may not during this process send UserAction messages 430 to the target 210, though it (the DDI controller 220) can obtain additional GUI elements from the target 210. This process is called, DDI controller 220-driven navigation. GUI elements can contain attributes which the DDI controller 220 may or may not use to guide the user during DDI controller 220-driven navigation. User-Driven Navigation. It is possible for DDI data to contain non-organizational GUI panel link elements. A panel link element has as the value of a mandatory attribute the ID of a panel element. Other attributes suggest a position and appearance for the rendering of the panel link element. This type of element offers a means for the DDI controller 220 to switch at the explicit request of the user from one panel to another. For instance, if the user selects this element, the DDI controller 220 can abandon rendering the currently rendered panel, make the specified panel element the current panel, and render it appropriately. This process is called user-driven navigation. Again, as for DDI controller 220-driven navigation, the DDI target 210 will only be consulted if the DDI controller 220 needs additional GUI elements. In this case, UserAction messages 430 will not be sent by the DDI controller 220. GUI panel link elements thus make it possible for a DDI target 210 to specify GUI hierarchies of effectively arbitrary depth below the root panel. Notification Scope for Target GUI Changes. As mentioned above, at any time while a DDI controller 220 is subscribed to a target 210, the DDI target 210 can indicate that its GUI description (some or all of which the DDI controller 220 may have previously read from the target 210) has changed by sending a NotifyGuiChange message 440 to the DDI controller 220. Arguments to this message will provide the DDI controller 220 with information about which parts of the target 210's GUI description have changed. The DDI target 210 may also indicate that its GUI description has changed in its response to a UserAction message 430 sent to it by the DDI controller 220. For large target GUI descriptions, this may lead to many possibly extraneous notification messages being sent to the DDI controller 220. A mechanism exists within the DDI model to reduce this message traffic. For instance, it is possible for the DDI controller 220 to give the DDI target 210 a description of a portion of the target 210's GUI description, the current notification scope. The DDI target 210 will only notify the DDI controller 220 of changes to those DDI target 210 GUI elements that are within the notification scope. DDI target 210 GUI elements outside of the current notification scope may change but the DDI target 210 will not send a corresponding indication to the DDI controller 220. This indication is called a change report and may refer to zero or more changed GUI elements. A change report is included in the arguments for both the UserAction and NotifyGuiChange messages. Any non-organizational DDI target 210 GUI element that changes and is within the current notification scope will be included in the change report sent by the DDI target 210 to the DDI controller 220. If a GUI element is added to or removed from an organizational target GUI element, then that organizational element will be included in the change report sent by the DDI target 210 to the DDI controller 220. For low notification-traffic situations, the DDI controller 220 can choose to set the notification scope to be the complete target GUI description. In higher traffic situations, the DDI controller 220 can set the notification scope to be restricted to the current panel. APIs for Data Driven Interaction This section describes the data structures and APIs for supporting the level 1 Graphics User Interface (GUI) control of a DDI target such as a DCM within the HAVi architecture. The data structures represent a set of GUI elements that can be extracted from a DDI target 210 and presented on a display screen 105. These GUI elements are sufficient in capability to allow a DDI target 210 to be controlled by the user bringing focus onto these elements and causing actions to be sent to the target 210. These actions are described herein. In turn, a DDI target 210 can inform the user of elements changing in the target.
TABLE II
Services Provided
Comm
Service Type Locality Access
DDITarget::SubscribeGui M global DDI controller
DDITarget::UnsubscibeGui M global DDI controller
DDITarget::GetGuiElement M global all
DDITarget::GetGuiPanelList M global all
DDITarget::GetGuiGroupList M global all
DDITarget::GetGuiElementList M global all
DDITarget::UserAction M global DDI controller
DDIController::NotifyGuiChange N global DDI target
(DDI controller)
GUI element data structure overview. The DDI mechanism of the present invention includes an application that is acting like a DDI controller 220 and a device as the target 210. The DDI target 210 receives all the service methods described above except for the NotifyGuiChange which is issued back to the DDI controller 220 from the DDI target 210 to indicate GUI element changes originating in the target device 210. The GUI elements are the structures that a device can use to define how it should be represented on the display screen 105. These elements are put on a screen by an application. A given element can be defined to allow the user to interact with it. In these cases, the user can apply a set of actions that result in this element's ID being returned to the device along with the respective action. Some elements are presented by the device to provide only navigation among elements. In these cases, no actions are sent back to the device. Navigation can be done between panels, groups, and/or individual elements. DDI terminology used herein is defined to be the following. Navigation is the controller responding to user inputs for moving from one GUI element to another. How this is done is controller specific. It could be with a remote control up, down, left, and right arrows. Focus is the result of the controller navigating to a GUI element. This is controller specific but the user experience results in the GUI element being highlighted, selected by changing color, etc. Interactive is once focus is on a GUI element, the user can place an action on this element resulting in this input being sent to the target device along with the GUI element ID. Display-only is a GUI element that the target provides which the controller displays but the controller does not navigate to it, thus not allowing either focus or interaction to take place. This GUI element is for display only. A panel element is intended to represent an entire screen's worth of GUI elements. Within the panel can be zero or more groups of individual elements. In addition, a panel can have standalone elements that are not part of any group. Navigation can be specified by the device for going from panel to panel, from group to group, and from element to element. An element consists of its main definition part, followed by mandatory attributes and optional attributes. All elements have a label that is defined to be a text string of minimum length one and maximum length fifteen, in one embodiment. A label is allowed to exceed the maximum length, but controllers are then allowed to render only the indicated maximum. In this case targets "know" that a user might not be able to see the complete label and the target can take this into account when designing the level 1 GUI. The concepts of panel, group, and label are used by a display device to present a given panel in three DDI modes: full-capability, scaled-down and text. If the devices current panel can be displayed on the whole screen as outlined and defined by the device than the display is said to be presented to the user as "full-capability." If the display device can not display the entire panel as given it can than drop down to the next mode of "scaled-down." Suggestions on how to scale down would be represented by the groups within a panel. The display device could than display one group at a time and move between groups by displaying next and previous groups. The last mode, "text," would be if the display device can only display either lines of text or one line of text at a time. In this case, the label is used to display this element and can be selected by the user. A GUI element has the attributes height and width. The attribute, position, is used to place it in a logical location on the panel relative to all other elements and groups. A panel size will be chosen to represent a typical screen display and each element's size will be relative to this. Each target device supports the same panel size for all of its panels. The GUI element, GuiPanelLink, does not send any message to the target device according to the user action. The "navigation" from the current panel to a different panel is done by the display device getting the next panel as contained in the panelLink attribute. The user selecting the GuiPanelLink element does not result in any GUI action other than the display device itself requesting the panel in the GuiPanelLink by using the API call getGuiElement. The same holds for groups and the panels themselves. The display device has the freedom to display the GUI elements in any manner it sees fit. The element's mandatory and optional attributes are intended to be suggestions to the display device on how to organize and present the device panels, groups, and standalone elements to the user. Panels and groups can have background colors and/or patterns. Colors provide for transparency. A pattern may take the form of a tiled sequence of icons, this would allow for textured appearances. All images conform to PNG and HAVi row bitmap formats and these format are distinguished by file signature. Panels and groups can have audio and/or video content that will be streamed in real-time when the GUI element gets the focus. In the case of audio this would allow a panel to have background music while each animation icon could be describing some device function as verbal audio speech. If either the device or the display device (controller) goes away then the HAVi messaging system capabilities of "watch on," "watch off" will notify each respective object that the other one has gone away. A device uses the NotifyGuiChange service to spontaneously put on the screen GUI elements describing changes in current panel elements or new elements. These elements would than become part of the current panel as defined by the SubscribeGUI scope parameter. It would be up to the DDI controller 220 how and when to display these types of elements when they are received in this context. An example of a GUI element definition is given below. GuiElementId is used for identification of all GUI elements specified herein.
//GuiElementId Representation
//Syntax Nb of bits Identifier
GuiElementId() {
GuiElemType 8 uimsbf
GUIElementHdl 16 uimsbf
}
The following gives some general DDI type definitions:
typedef ushort GuiElementId;
typedef sequence<GuiElementId> GuiElementIdList;
typedef sequence<GuiElement> GuiElementList;
typedef ushort GuiContentId;
typedef octet Color[3]; // R,G,B true color
typedef octet Color[COLORLENGTH]; // length to be defined
typedef sequence<octet> Bitmap; // variable size
typedef sequence<octet> Sound; // variable size
typedef sequence<char> Label;
typedef ushort Relation;
typedef short Font;
typedef Channel AudioVideo;
// stream manager iso channel media
// channel definition is in Stream
// Manager section
enum Selectable {SET, UNSET};
struct Pattern {
ushort height;
ushort width;
GuiContentId Bitmap pattern_bitmap;
}
A bitmap is an image and a sound is an audio file format identified by GuiContentId. A bitmap and/or sound can optionally be part of certain GUI elements and is intended to be a small amount of data. This would be used to attach short sounds to button clicks, release, and presses for example. These are in contrast to media streams being played back in real-time. The terms audio and video will be used when media stream references are required. The DDI protocol also allows for the DDI controller 220 to setup audio and video media streams using the Stream manager isochronous channels. If a GUI element has audio and/or video stream content then it can be supported by the Stream Manager and managed using the stream manager facilities. Within the optional attribute AudioVideo is the channel number supplied by the target. If the controller 220 can accept and provide media streams then the controller would listen on this channel number for content being supplied by the target on this channel. A panel is defined to be two dimensional with the upper left corner being defined as (x=0, y=0). The entire panel size is programmable. All positions given for groups or standalone elements would be relative to this (0,0) coordinate. A standalone element is not part of any group. The elements within a group have position values based on the group upper left most position being x=0, y=0. The x-coordinate is positive incrementing from left to right. The y-coordinate is positive incrementing from top to bottom. struct Position { ushort x_position; ushort y_position; }; Every GUI element has a label. This label is to be used in the case when the display device is in text-only mode. The label should describe the GUI element function. It is suggested that this label length not exceed fifteen characters. In all cases this set of fifteen characters will be displayed; whether the device is scrolling it across an LED or displaying it on a screen. The mandatory attributes of a GUI element must be included in the DDI data. The mandatory attributes of a GUI element must be included in the device's definition. The optional attributes need not be present but if included are intended to give the display device directions on displaying this particular GUI element. These optional attributes are defined in a (possibly empty) list at the end of the structure. For each GUI element type it is indicated by comments which optional attributes are valid. A target device returns the same GuiElementID for a given element. It is up to the controller how many GUI elements are retrieved and when they are retrieved. The target device only knows about what was last pulled from it by the API calls getting the elements and/or element lists. No GUI elements should overlap by defining their positions to be at the same relative location. typedef string Hotlink; // representing a URL The following exemplary structure defines the navigation in one implementation:
struct FocusNavigation {
GuiElementId up; GuiElementId down;
GuiElementId left; GuiElementId right;
}
typedef GuiContentId Title; // smaller than 10% of safety area
sizetypedef Bitmap Title; // size to be defined
struct Date {
unsigned short Year; // e.g. 1998
unsigned short Month; // 1 to 12
unsigned short Day; // 1 to 31
unsigned short Hour; // 0 to 23
unsigned short Minute; // 0 to 59
unsigned short Second; // 0 to 59
}
struct Time {
unsigned short Hour; // 0 to 23
unsigned short Minute; // 0 to 59
unsigned short Second; // 0 to 59
}
DDI data can include text data, bitmap data and sound data, and indicate stream data. The DDI controller uses them for the presentation of panels in DDI data. All formats are divided into two distinct classes: mandatory formats and optional formats. The mandatory formats for DDI data are specified below, and all DDI controllers shall support mandatory text format at least. The data using optional formats shall be described in GUI element with optional attributes bitmaptype and soundtype. These optional attributes are used to all for future extension, so these attributes are not defined in the HAVi architecture. Bitmap format. Both PNG and raw bitmap are used for HAVi bitmap format. However it is not necessary to have bitmap type attribute on each GUI element, because they are distinguished by using file signature. Regarding PNG, details on this format are given in PNG specification (IETF RFC 2083). However, in one embodiment, DDI data does not support the full specification of PNG, there are some limitations on it, the color type=3 (index color, max. 8bit color) and the bit depth=1,2,4,8 (max. 8bit color). Regarding HAVi raw bitmap, which is defined by HAVi, is also used for HAVi bitmap format. HAVi raw bitmap format described below uses the same style as IHDR, PLTE chunk format described in PNG specification. And RIDAT chunk defined by HAVi is used instead of IDAT chunk. Regarding the file signature, the first eight bytes of a HAVi raw bitmap file always contain the following values:
(decimal) 137 72 65 86 105 13 10 26
(hexadecimal) 89 48 41 56 69 0d 0a 1a
(ASCII C notation) .dagger.21 1 H A V i .dagger.r .dagger.n
.dagger.032
Regarding HDR, the IHDR chunk appears first in bitmap data. It contains:
Width: 4 bytes
Height: 4 bytes
Bit depth: 1 byte (value: 8)
Color type: 1 byte (value: 3, index color, max 256 color)
Compression method: 1 byte (value: 255, no compression)
Filter method: 1 byte (value: 255, no information)
Interlace method: 1 byte (using PNG method)
Regarding PLTE, the PLTE chunk contains from 1 to 256 palette entries, and each entry has a three-byte series of the form: Red(1 byte), Green(1 byte), Blue(1 byte). The first entry in PLTE is referenced by pixel value 0, the second by pixel value 1, etc., the PLTE chunk may have fewer entries than the bit depth. In that case, any out-of-range pixel value found in the RIDAT chunk is an error. Regarding RIDAT, the RIDAT chunk contains the actual image data. To create this data image scan lines are represented as described in the PNG Image layout. The layout and total size of this raw data are determined by the fields of IHDR in the PNG specification. The RIDAT chunk contains the raw image data. Sound data. The AIFF-C format (DAVIC 1.3 Part 9, Annex B "Coding of Linear Audio") is used for HAVi sound format. However, in one embodiment, DDI data does not support the full specification of AIFF-C, there are some limitations on it. The sample size=8 bit and the sample rate=22.050 kHz Audio Video Stream. There is no mandatory audio. video stream format in HAVi DDI. Optional attribute audiovideo shows the channel number supplied audio and/or video stream by the DDI target. The type of this audio and/or video stream is defined in the section of the HAVi stream manager, e.g., the HAVi stream type shows the data format on the channel given by the audiovideo attribute. When the audiovideo attribute is given in the DDI data, DDI controller can use the audio video stream for background video, etc. If the audiovideo attribute is valid, DDI controller 220 should consider audiovideo as higher priority to background picture, background pattern and background color. The following is an example: enum ContentType {PNG, HAVi_RAW_BITMAP, AIFF-C, UNICODE} union GuiContent switch (ContentType) { case PNG: Bitmap pngbitmap; case HAVi_RAW_BITMAP: Bitmap rawbitmap; case AIFF-C: Sound sound; case UNICODE: string text; }; enum OptAttrType {POSITION, BACKGROUND_COLOR, BACKGROUND_PATTERN, BACKGROUND_PICTURE_LINK, AUDIO_VIDEO, DEVICE_BITMAP, CONTENT_BITMAP, PRESSED_BITMAP_LINK, RELEASED_BITMAP_LINK, HOTLINK, FONT, RELATION, FOCUS_NAVIGATION, SHOW_WITH_PARENT, TITLE,MAX_LABEL, MIN_LABEL, CENTER_LABEL, FOCUS_SOUND_LINK,PRESSED_SOUND_LINK, RELEASED_SOUND_LINK, HELP_PANEL_LINK, PLAYBACK_TIME, RECORDED_DATE, broadcast_date}; enum OptAttrType {POSITION, BACKGROUND_COLOR, BACKGROUND_PATTERN, BACKGROUND_PICTURE, AUDIO_VIDEO, DEVICE_BITMAP, PRESSED_BITMAP, RELEASED_BITMAP, HOTLINK, FONT, RELATION, FOCUS_NAVIGATION, SHOW_WITH_PARENT, TITLE, MAX_LABEL, MIN_LABEL, CENTER_LABEL, FOCUS_SOUND, PRESSED_SOUND, RELEASED_SOUND, HELP_PANEL_LINK}; union OptionalAttribute switch (OptAttrType) { case POSITION: Position position; case BACKGROUND_COLOR: Color background_color; case BACKGROUND_PATTERN: Pattern backgroundpattern; case BACKGROUND_PICTURE_LINK: GuiContentId backgroundPicture; case AUDIO_VIDEO: AudioVideo audiovideo; case DEVICE_BITMAP: Bitmap devicebitmap; case CONTENT_BITMAP: Bitmap contentbitmap; case PRESSED_BITMAP_LINK: GuiContentId pressedbitmap; case RELEASE_BITMAP_LINK: GuiContentId releaseddbitmap; case FOCUS_SOUND_LINK: GuiContentId focussound; case PRESSED_SOUND_LINK: GuiContentId pressedsound; case RELEASED_SOUND_LINK: GuiContentId releasedsound; case HOTLINK: string hotlink; // represents URL case FONTSIZE: Fontsize fontsize; case RELATION: Relation relation, case FOCUS_NAVIGATION: FocusNavigation focusnavigation; case SHOW_WITH_PARENT: boolean showwithparent; case TITLE: Title title; case MAX_LABEL: Label maxlabel; case MIN_LABEL: Label minlabel; case CENTER_LABEL: Label centerlabel; case HELP_PANEL_LINK: GuiElementId helppanellink; case playback_time: Time playbacktime; case recorded_date: Date recordeddate; case broadcast_date: Date broadcastdate; }; union OptionalAttribute switch (OptAttrType) { case POSITION: Position position; case BACKGROUND_COLOR: Color background_color; case BACKGROUND_PATTERN: Pattern backgroundpattern; case BACKGROUND_PICTURE: Bitmap backgroundPicture; case AUDIO_VIDEO: AudioVideo audiovideo; case DEVICE_BITMAP: Bitmap devicebitmap; case PRESSED_BITMAP: Bitmap pressedbitmap; case RELEASE_BITMAP: Bitmap releasedbitmap; case FOCUS_SOUND: Sound focussound; case PRESSED_SOUND: Sound pressedsound; case RELEASED_SOUND: Sound releasedsound; case HOTLINK: string hotlink; // represents URL case FONT: Font font; case RELATION: Relation relation, case FOCUS_NAVIGATION: FocusNavigation focusnavigation; case SHOW_WITH_PARENT: boolean showwithparent; case TITLE: Title title; case MAX_LABEL: Label maxlabel; case MIN_LABEL: Label minlabel; case CENTER_LABEL: Label centerlabel; case HELP_PANEL_LINK: GuiElementId helppanellink; }; typedef sequence<OptionalAttribute> OptAttrList; enum Scope {CURRENT, GLOBAL}; enum DDIError {ENOGEI, ENOSUB, EINVALID, ENOPANEL, ENOGROUP, ENOTCUR, }; enum Fontsize {SMALL, MEDIUM, LARGE}; Individual GUI elements defined. Groups will not have explicit navigation suggestions; the only suggestion is the order of the group IDs in the panel list. The DDI controller 220 navigates between groups in this order (or some other order if it has a reason to deviate from this). GUI Elements (not panels and groups) can have optional focus change suggestions, which the controller can use to move the focus on screen. The basic set of directions is up, down, left, right, but the controller is free to have its own input device which can map to these concepts (e.g., it does not need to have an IR remote with 4 buttons). The controller can, for instance, present groups of elements as small opaque blocks on the screen, and can either make the panel background opaque or transparent. The DDI controller 220 has the freedom to display both standalone elements and groups in any manner it sees presentable. The bitmap format can have facility to define the characteristics of the screen 105, it is based on the Gamma and on what platform the particular bitmap was designed. There will be an optional color attribute to define the characteristics of the screen that is displaying a bitmap. In this way colors and brightness levels will appear correct whether its being displayed on a TV screen or other display device. GUI elements can have optional sound suggestions, which the controller can playback a sound following to user operation. The element pressed_sound indicates once playback when the GuiButton is pressed, released_sound indicates once playback when the GuiButton is released, and forcusSound indicates once playback when the GuiElement gets focus. GUI elements can have optional fontsize suggestions. In case of full capability devices, as a guideline, MEDIUM size is specified in 16.times.32 pixel (two byes code such as kanji code is 32.times.32), SMALL size is specified in 12.times.24 pixel (two byes code is 24.times.24) and LARGE size is specified in 20.times.40 pixel (two byes code is 40.times.40). MEDIUM is the default font size when no Fontsize is specified. In one implementation, the GUI elements are: enum GuiElemType (GUI_PANEL, GUI_GROUP, GUI_BUTTON, GUI_PANELLINK, GUI_ANIMATION, GUI_SHOWRANGE, GUI_SETRANGE, GUI_ENTRY, GUI_CHOICE, GUI_TEXT, GUI_STATUS, GUI_ICON, CONTENT_ICON, DEVICE_ICON}; union GuiElement switch (GuiElemType) { case GUI_PANEL: GuiPanel panel; case GUI_GROUP: GuiGroup group; case GUI_PANELLINK: GuiPanelLink panellink; case GUI_BUTTON: GuiButton button; case GUI_ANIMATION: GuiAnimation animation; case GUI_SHOWRANGE: GuiShowRange showrange; case GUI_SETRANGE: GuiSetRange setrange; case GUI_ENTRY: GuiEntry entry; case GUI_CHOICE: GuiChoice choice; case GUI_TEXT: GuiText text; case GUI_STATUS: GuiStatus status; case GUI_ICON: GuiIcon icon; case CONTENT_ICON: ContentIcon contenticon; case DEVICE_ICON: DeviceIcon deviceicon; }; In the GUI elements that require the user to send information back to the device, e.g. entry, only when the user has finished entering the information would the controllerthan send back the updated field. When and how the controller knows when to send the update is determined by the controller. It could be an ENTER button on the remote, typing the ENTER key on a keyboard, etc. The RELATION optional attribute is used to identify a set of GUI elements that are indications to the controller to try and display these together if the controller is in scale-down mode. The relation attribute can occur more than once in an optional attribute list of a GUI element. GuiPanel. The Gui Panel element can contain groups, links, and standalone elements. It can not contain other panel elements, though. It has its own GuiElementld. When using the SubscribeGui API call, the device will return the root panel GuiElementId. All panels are linked from this root panel. The actual panel size is not specified, but a safety area size which any full capability controller can generally display a panel on is 640.times.400 pixel, e.g., the upper-left corner as the user faces the device is <0,0>; the lower-right is <639, 399>. If the panel has the attribute of background AudioVideo, pattern, picture or color, then the background of the panel is displayed on actual full screen (e.g., 720.times.480 or 720.times.576). The AspectRatio attribute shows the aspect ratio of the panel and the controller may or may not display the panel using this aspect ratio, e.g., a high grade controller might support all aspect ratio but low grade controller might support only one aspect ratio for panels. The optional attribute ShowWithParent is used to indicate that this panel, if possible, should be displayed at the same time as its parent panel. The parent panel is defined as the panel previous to this current panel in the GuliPanelLink element panelLink attribute. The following is an example: enum AspectRatio { // unknown, or non-standard format (pixel aspect ratio) UNKNOWN_PIXEL_ASPECT_FORMAT, // square pixels (1.0) SQUARE_PIXEL_ASPECT_FORMAT, // 720 by 576 pixels rendered on a physical 4 by 3 display (1.067) PAL.sub.-- 720_BY.sub.-- 576_DISPLAY.sub.-- 4_BY.sub.-- 3_PIXEL_ASPECT_FORMAT, // 704 by 480 pixels rendered on a physical 4 by 3 display (0.909) NTSC.sub.-- 704_BY.sub.-- 480_DISPLAY.sub.-- 4_BY.sub.-- 3_PIXEL_ASPECT_FORMAT, // 720 by 480 pixels rendered on a physical 4 by 3 display (0.889) ARIB.sub.-- 720_BY.sub.-- 480_DISPLAY.sub.-- 4_BY.sub.-- 3_PIXEL_ASPECT_FORMAT, // 720 by 576 pixels rendered on a physical 16 by 9 display (1.422) PAL.sub.-- 720_BY.sub.-- 576_DISPLAY.sub.-- 16_BY.sub.-- 9_PIXEL_ASPECT_FORMAT, // 704 by 480 pixels rendered on a physical 16 by 9 display (1.212) ATSC.sub.-- 704_BY.sub.-- 480_DISPLAY.sub.-- 16_BY.sub.-- 9_PIXEL_ASPECT_FORMAT, // 720 by 480 pixels rendered on a physical 16 by 9 display (1.185) ARIB.sub.-- 720_BY.sub.-- 480_DISPLAY.sub.-- 16_BY.sub.-- 9_PIXEL_ASPECT_FORMAT, }; struct GuiPanel { Label panel_name; GuiElementIdList elements; AspectRatio aspect; OptAttrList optionals; }; struct GuiPanel { Label panelName; GuiElementIdList elements; OptAttrList optionals; }; // valid optional attributes: // ShowWithParent // BackGroundColor // FocusSound // fontsizefont // Title // AudioVideo GuiGroup. The GuiGroup element is optional. It is suggested to be used to indicate to the controller a set of elements that the device wants to be displayed together. This grouping is helpful when the controller has to scale down the panel and this provides the controller with the elements that need to appear together possibly on separate screens. The GuiGroup does notcontain GuiPanel elements or other GuiGroup elements. A GuiGroup has its own GuiElementld. The number of the GuiGroup's GuiElementId shows the display priority. When the DDI controller 220 has to scale down the panel, the DDI controller 220 displays the group which has the smallest number of GuiElementld on the first page. The background color, picture, audiovideo, and pattern can be chosen to be the background of this group. Only one of these should be present. The following is an example structure. struct GuiGroup { Label groupName; ushort height; ushort width; GuiElementIdList elements; OptAttrList optionals; }; // valid optional attributes: // Position // BackGroundColor // BackgroundPicture // BackgroundPattern // fontsizeFont // Title // AudioVideo // Relation GuiPanelLink. The GuiPanelLink GUI element is not interactive so the user selecting this element on the screen does not result in anything being sent to the device. The bitmap provided with a GuiPanelLink is used by the controller to represent this item; how it is presented (as an icon, button, etc.) is up to the DDI controller 220. A suggestion for GUI designers is to include the GuiPanelLink elements together in one group so that the display device can display them together. When displaying a scaled-down GUI, the display device must enable the user to navigate between all GUI elements. How the display device does this is its decision. The recommended size for the linkBitmap is to allow it to be easily displayed on a screen along with a full size panel. This allows a standard way of displaying GUI elements that are presented specifically to the user for navigation purposes. The following is an example structure. struct GuiPanelLink { Label linkName; GuiContentId Bitmap linkBitmap; ushort linkHeight; ushort linkwidth; GuiElementId panelLink; OptAttrList optionals; }; // valid optional attributes: // Position // FocusSound // fontsizeFont // FocusNavigation // HelpPanelLink GuiButton. A GuiButton element can be composed of a number of optional attributes. The display device determines how the button is presented on the screen. The button element allows numerous actions to be placed on it and the controller can determine how this is presented to the user interacting with this GUI element. The following is an example structure. struct GuiButton { Label pressed_label; Label release_label; // ignored if button_type=1 unsigned short height; unsigned short width; unsigned short button_type; // 0: press/release button, 1: single-state button OptAttrList optionals; }; struct GuiButton { Label pressedLabel; Label releaseLabel; // ignored if state=2 ushort height; ushort width; ushort state; // 0: released, 1: pressed, 2: single-state button OptAttrList optionals; }; // valid optional attributes: // Position // pressedbitmap // releasebitmap // ignored if button_type=1 // releasebitmap // ignored if state=2 // pressedsound // releasedsound // ignored if button_type=1 // releasedsound // ignored if state=2 // fontsizefont // FocusNavigation // Relation // HelpPanelLink GuiAnimation. This element is a multiple image icon (animation). enum repetitiontype {PLAY_ONCE, PLAY_REPEAT, PLAY_ALTERNATING}; Play alternating means when it reaches the end, it plays the images backwards until it reaches the beginning and than start going forwards again. A graphics controller does not have to display the labels when displaying the associated bitmaps. The following is an example structure. struct AnimationElement { Label iconname; GuiContentId Bitmap iconbitmap; }; struct GuiAnimation { Selectable selectable; ushort speed; // in units of 0.1 sec. RepetitionType repetition; ushort height; ushort width; sequence<AnimationElement> animations; // sequence should be non-empty OptAttrList optionals; }; // valid optional attributes: // Position // FocusSound // fontsizefont // FocusNavigation (only if selectable=SET) // Relation // HelpPanelLink GuiShowRange. The following is an example: enum orientationType {HORIZONTAL, VERTICAL, DIAL}; struct GuiShowRange { Label rangeName; ushort valueRange; ushort stepValue; ushort valueset; orientationType orientation; ushort height; ushort width; OptAttrList optionals; }; // valid optional attributes: // Position // BackGroundColor (color used for range indicator) // FocusSound // FocusNavigation // fontsizeFont // Relation // MaxLabel // MinLabel // CenterLabel // HelpPanelLink GuiSetRange. The following is an example: struct GuiSetRange { Label rangeName; ushort value_range; ushort step_value; ushort value_set; orientationType orientation; ushort height; ushort width; OptAttrList optionals; }; // valid optional attributes: // Position // BackgroundColor (color used for range indicator) // FocusSound // fontsizeFont // FocusNavigation // Relation // MaxLabel // MinLabel // CenterLabel // HelpPanelLink GuiEntry. The following is an example: enum EntryType {TEXTUAL, NUMERIC} enum Qualifier {CONCEAL, VISIBLE} // the CONCEAL attribute determines whether characters // within the Entryfield should be displayed, // e.g. for PIN entry struct GuiEntry { Label entryName; EntryType type; Qualifier qualifier; ushort height; ushort width; OptAttrList optionals; }; // valid optional attributes: // Position // BackgroundColor (color used for entry indicator) // FocusSound // FocusNavigation // fontsizeFont // Relation // HelpPanelLink GuiChoice This element refers to the action on the choice elements for determining how it returns the list of choices made or only returns the single choice (radio button). And element_status is used for current value of this element, e.g., chosen or not_chosen. A graphics capable controller does not need to show the Labels when displaying the supplied bitmaps. The following is an example structure. struct ChoiceElement { Label choice_name; GuiContentId choice_bitmap; Boolean element_status; struct ChoiceElement { Label choiceName; Bitmap choiceBitmap; }; enum ChoiceType {LESS_THAN, EQUAL, MORE_THAN}; struct GuiChoice { ChoiceType type; ushort choiceNumber; sequence<ChoiceElement> choiceList; // sequence should be non-empty ushort height; ushort width; OptAttrList optionals}; // valid optional attributes: // Position // BackgroundColor (color used for choice indicator) // FocusSound // FocusNavigation // fontsizeFont // Relation // HelpPanelLink GuiText. The text GUI element is used if the device only wants to display text with no user entry. String data can have at most 40 characters on horizontally and yertical limit is not needed because controller can use scrolling if necessary. The text GUI element is used if the device only wants to display text with no user entry. It can be used for textual display only or can be used as an interactive field that would be a text string that is a hot link. The hotlink atfribute if present would define the text as containing a URL address. It would be up to the controller whether to link to the address site or not. The following is an example structure. struct GuiText { Selectable selectable; ushort height; ushort width; GuiContentIdstring text; // text can contain newline characters, // however text lines should not be longer than 40 // characters. There is no limit on the number of // lines; a controller will use scrolling facilities // if needed. OptAttrList optionals; }; // valid optional attributes: // Position // BackgroundColor // Hotlink // Focussound // FocusNavigation (only if selectable=SET) // fontsizeFont // Relation // HelpPanelLink GuiStatus. This element is used to provide to the controller continuous status updates. This would provide GUI functions such as hourglass, barber pole, incrementing bar, etc. The following is an example structure. enum StatusType {HOURGLASS, BARBER_POLE}; struct GuiStatus { Label statusName; StatusType type; ushort height; ushort width; OptAttrList optionals; }; // valid optional attributes: // Position // BackGroundColor (color used for range indicator) // fontsizeFont // Relation // HelpPanelLink GuiIcon. This element is used to display a bitmap image for either selection or display only. If the controller displays the bitmap, it is suggested that it does not display the label. The following is an example structure. struct GuiIcon { Selectable selectable; Label iconname; ushort height; ushort width; GuiContentId iconbitmap; bitmap icon; OptAttrList optionals; }; // valid optional attributes: // Position // Focussound // FocusNavigation (only if selectable=SET) // fontsizeFont // Relation // HelpPanelLink ContentIcon. This icon when displayed represents what content the target device has. This icon when displayed represents that the target device contains either audio only or audio and video content. The DCM for this device makes use of this icon for user selection of the AV content. When selected the target device starts playing this content out the specified channel as described in the DCM section. The availability attribute shows whether or not the content shown by the content icon is available now. And playbacktime shows the time required for playback this content, recordeddate shows when this content was recorded and is valid for storage device, and broadcastdate shows when this content is transmitted from broadcasting station and is valid for tuner device. The following is an example structure. struct ContentIcon { Label contentName; Boolean availability //TRUE: available now, FALSE: not available now OptAttrList optionals; }; // valid optional attributes: // contentbitmap // with size limits // focussound // Fontsize // playbacktime // recordeddate // broadcastdate struct ContentIcon { Label contentName; OptAttrList optionals; }; // valid optional attributes: // contentbitmap // with size limits // focussound DeviceIcon. The device icon GUI element is returned by the HAVI DCM And DCM Manager API call GetDeviceIcon. It is a vendor device option on how to represent the device. It is a text representation with the options of bitmap and/or sound. The size of the bitmap is recommended to be a size that would allow a controller to easily display on the screen a number of device representations. This would allow the user to select a given device for further device control. The length of the sound should be kept to a small size that would be associated with this device. The following is an example: struct DeviceIcon { Label deviceName; OptAttrList optionals; }; // valid optional attributes: // devicebitmap // with size limits If the user wants to change the name of the device (label) then the device needs to provide this in the GuiEntry within the devices GUI elements. The device icon would be used by the controller to display this device on a network map or wherever the device needs to be visually represented. This Device Icon is required to be supported by the device. The DeviceIcon label denotes the HAVi UserPreferredName. GUI ACTION DATA STRUCTURES GUI actions are only defined for interactive GUI elements. Actions can be placed on GUI elements when the GUI element has the controller focus. How and when the focus is placed on a particular GUI element is-up to the controller. Typically, the focus would be shown by highlighting a box around the GUI element or changing its color. The GUI actions correspond to the GUI element types. In this way, the UserAction method can check the action taken is on the correct type of element. The following is an example structure. enum ActType {ACT_BUTTON, ACT_SETRANGE, ACT_ENTRY, ACT_CHOICE, ACT_SELECTED}; enum ActButton {PRESSED, RELEASED}; typedef ushort ActSetRange; // for setting range values >=0 and <=value_range typedef string ActEntry; // for entering characters typedef sequence<ushort> ActChoiceList; // each number in ActChoiceList corresponds with // the index of the "checked" entry; // in case of single choice, ActChoiceList contains // only one number (the one selected). typedef boolean ActSelected; // dummy value union GuiAction switch (ActType) { case ACT_BUTTON: ActButton button; case ACT_SETRANGE: ActSetRange setRange; case ACT_ENTRY: ActEntry entry; case ACT_CHOICE: ActChoiceList choiceList; case ACT_SELECTED: ActSelected selected; }; DATA DRIVEN INTERACTION API Although a number of different APIs can be used to implement the present invention in accordance with the descriptions herein, the following represents example APIs that can be used in accordance with one implementation of the present invention. DDITarget::SubscribeGui Prototype Status DDITarget::SubscribeGui( in Scope scope, out GuiElementId rootpanel) Parameters are scope and root panel. Scope indicates whether the target should generate GUI change r | ||||||
