opensocial-and-gadgets-spec@googlegroups.com

General OpenSocial social networking REST XML Extensible Markup Language JSON JavaScript Object Notation Atom

The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC2119. Domain name examples use RFC2606.

Gadgets are web-based software components based on HTML, CSS, and JavaScript. They allow developers to easily write useful web applications that work anywhere on the web without modification. They are defined using a declarative XML syntax that is processed by a gadget server into a format that allows them to be embedded into various contexts: standalone web pages, web applications, even other gadgets. A context into which a gadget is embedded is called a gadget container. The container is responsible for managing the gadgets' layout and controls, as well as for supporting various functionality on behalf of the gadget. A gadget may be a simple widget, a reusable component, or a full-blown application, possibly utilizing or communicating with other gadgets. A gadget and its XML are synonymous. The gadget XML contains all information needed to identify and render a web application. Metadata. Several pieces of metadata are specified by the gadget developer in the gadget XML, such as author information, gadget title, and description. This data gives hints to the gadget container on how to identify it, in addition to providing data to gadget directories, which are databases that help users find gadgets useful for their needs Gadget Features. A list of all gadget features that are either required for the gadget to operate, or may optionally be utilized if available. Gadget features are the primary extensibility mechanism employed by gadgets. They often direct a gadget server to make new JavaScript APIs available to rendering code, but may also manipulate the gadget's contents, for example to add extended syntax. Examples of gadget features include OpenSocial (provides gadgets with a rich set of social APIs), dynamic-height (enables gadgets to resize themselves to an appropriate height), and tabs (a UI library facilitating tabular navigation). User Preferences. These are key/value pairs that form the basis of gadget configuration and persistence. They are most often manipulable by users of the gadget, and are persisted on behalf of a user so that the gadget has access to them across multiple rendering requests. The gadget container is typically responsible for providing their persistence for this data and an interface to edit it. Message Bundles. Message bundles allow developers to internationalize their gadgets simply by adding name/message mappings corresponding to whatever languages the developer chooses to support. These messages may be accessed programmatically through the core JavaScript APIs provided to all gadgets, or may be statically substituted into code using simple syntax. Content. Provides the actual HTML, CSS, and JavaScript to be rendered by the gadget. Two delivery mechanisms are supported: Type HTML gadgets are the most prevalent, and are imbued with the most rich feature set. Code is provided directly in the gadget XML content section for rendering and control flow. This code simply assumes that functionality is available that has been requested from whatever gadget features were declared. In the case of optional-declared features, a simple feature-existence API can and should be consulted to ensure the capability is enabled. The code is processed by a gadget server and rendered in an IFRAME. Type URL gadgets only specify a base URL. A standard set of parameters are added to this URL by the gadget server, which renders the gadget in an IFRAME. The application to which the URL points must include a referenced JavaScript library using a <script> tag as it renders, to enable gadget APIs to be made available. Type URL gadgets can't take advantage of all features, notably features that manipulate HTML and JavaScript code directly. However, this gadget type has proven highly useful for turning existing web sites or applications into gadgets. Multiple Content sections may be specified in gadget XML. Each is labeled with one or more optional view identifiers, which allow the gadget to behave or appear differently depending on the context in which it's rendered. This context is provided by the gadget container. This document describes the gadget XML syntax and how it is processed by a compliant gadget server. In addition, it describes the core JavaScript APIs that must be made available to every gadget as it is rendered. While compliance can be attained by supporting only these core APIs, doing so severely limits a gadget server's usefulness. Gadget servers should support as many features as possible. Widely used, highly recommended features are listed at the end of this document.

To be gadgets-compliant, a server must be able to satisfy a Gadget Rendering Request and JavaScript Request. Containers may provide support for Content Rewriting. There are typically a number of other interfaces that a server provides, such as metadata requests, but these are a private contract between the Gadget Server and the Container.

The core gadget API, this translates gadget XML into content that can be rendered in a browser, typically in an IFRAME.

Gadget XML, typically specified as a URL pointing to a file on the web. User prefs. Locale of the end user. (optional) IgnoreCache processing option. (optional) Module ID, an integer identifier for the gadget in a given container context. If not provided, this defaults to 0.

HTML, CSS, and JavaScript.

Fetch the gadget XML. This SHOULD consult a cache to minimize load on the gadget XML hosting server. The specific properties of caching are left to the implementation. The server may honor HTTP caching headers to provide developers with a way to balance the load their servers receive against the frequency with which they can reliably deploy updated content. The server SHOULD honor an IgnoreCache processing option. This causes all built-in spec caches to be ignored, fetching the spec directly from its canonical resource. This feature is very useful while developing a gadget. HTTP-based request servers SHOULD support this via a URL parameter named nocache. The server MAY implement denial-of-service protection limiting the number fetches for a spec in a given period of time, as a courtesy to developers. Parse the gadget XML. The XML MUST conform to the extended gadget spec XSD. This XSD represents all valid elements and attributes accepted by the legacy iGoogle gadget server (gmodules.com). However, some of these fields will be phased out. The canonical gadget spec XSD the subset of attributes that must be parsed and interpreted by the server. In other words, the parser MUST NOT reject gadget specs conforming to the extended spec, yet need not interpret more than the canonical spec. On a <Content> block, the view names are represented as comma delimited strings which allows a particular <Content> block to be used on one or more surfaces. Surfaces with common view names have the inner XML of their <Content> blocks concatenated. Concatenation only occurs with exact matches of a view name on a <Content> block. Example: <Content view="Profile, Home,Home.About"/> contains Content for three named views: Profile, Home, and Home.About. Concatenation does not happen when the @href is set on a <Content> block. In this case, the set of view names on <Content> blocks with @href set to a non-null, non-empty string MUST be unique within the Gadget XML. If this is not true, the markup is invalid. A container may process gadget markup ahead of acceptance into a container's application gallery, checking for the href conditions when importing gadget XML. This validity check need not be performed at render time. Identify the Locale object corresponding to the request, and fetch messages specified by it. The <Locale> element is selected from the gadget XML by matching to the declared language and/or country. If an element matches both, use it. Otherwise select a language-only match over a country-only match. If no such match exists and an element is defined without language or country attributes defined, use it. The following assumptions are made when implementing the gadgets specification: The container MAY choose to utilize the rendered gadget's page fragment for its own purposes. Gadget developers SHOULD NOT modify this value. The behavior of relative URLs in the gadget spec is undefined. Gadget developers SHOULD output fully qualified URLs, or inject a <base> element as described in 3.1.3. Containers MUST support the <base> element as described in the HTML 4.01 specification. Containers SHOULD move <base> elements encountered in a gadget's <Content> section into the rendered gadget's <head> element, as required by the HTML 4.01 specification. Load the message bundle specified in the matched <Locale> element, if any. If the message attribute is specified, use it: load the bundle from the network using the provided URL. Otherwise use the <messagebundle> element that is a child of <Locale>, if present. Substitute "hangman variables" into supported gadget spec fields. Hangman variables are of the form __<TYPE>_<ID>__, and are replaced with string values. There are four types of hangman variables, which are defined as follows. Process message bundle into __MSG_foo__ hangman variables. The bundle MUST conform to the message bundle XSD. For each message named foo with value bar, hangman expansion __MSG_foo__ = bar. For each provided User Pref with key foo and value bar, hangman expansion __UP_foo__ = bar. Hangman expansion __MODULE_ID__ = <provided module ID>. HTTP-based request servers SHOULD use the URL parameter named mid for this. If a message bundle was found with language_direction = "rtl" , hangman expansions __BIDI_START_EDGE__ = "right", __BIDI_END_EDGE__ = "left", __BIDI_DIR__ = "rtl", __BIDI_REVERSE_DIR__ = "ltr". Otherwise __BIDI_START_EDGE__ = "left", __BIDI_END_EDGE__ = "right", __BIDI_DIR__ = "ltr", __BIDI_REVERSE_DIR__ = "rtl". Perform substitutions of each hangman expansion on all fields which get displayed to users. This currently includes, but is not limited to, the following fields: Module.ModulePrefs attributes, Module.Content@href, Module.Content, UserPref@display_name, UserPref@default_value, and UserPref.EnumValue@display_value. Process gadget features, specified as <Require> or <Optional> in the gadget XML. If one or more unsupported features are specified in a <Require> block, the server MUST emit a standard error message indicating that it cannot satisfy the rendering request. The message SHOULD list all requested features that could not be used because the container does not support them. The message MAY provide contact information for the gadget server administrator, along with a mechanism to request adding support for the feature. The server MUST support the following core JavaScript API, which applies to <Optional> features:

gadgets.util.hasFeature(featureName)

As indicated in the JsDoc, this method returns true if the server is able to satisfy featureName, false otherwise. Gadget developers can use this functionality to enhance their gadgets if features are available without disabling their gadget if the features are missing. The server MUST conform to the requirements specified by each requested feature in order to claim support for it. The particulars of this vary per feature, but include injecting JavaScript APIs into rendered output or the type URL-included libraries and manipulating type HTML content to support extended syntax. Output gadget content. Determine if the /Content/@href attribute is present. If so, the content for the active view is proxied and follows the rules in the section labeled Proxied Content For type HTML gadgets, the order is as follows: Standard HTML header, opening <html> tag and <body> tag. <head> information is optional. Gadgets run in browser quirks mode. Core gadgets JavaScript libraries, as specified here. Feature library initialization code, if needed. Processed gadget content, the result of steps #4 and possibly #5. A single call to gadgets.util.runOnLoadHandlers(); Standard HTML closing tags. For type URL gadgets, the provided URL MUST have the following parameters added to it: up_<name>=<value> for each provided user preference. lang=<language> and country=<country>, from the provided request Locale. libs=<jsLib>, where <jsLib> is a comma-separated list of URL path fragments relative to the server's JavaScript request handler path. These fragments are added to the JS path by the type URL target to load gadget API JavaScript into its execution context. The server SHOULD consolidate all libs into a single request to minimize the number of HTTP requests made by the client browser.

In order to satisfy type URL gadgets' JavaScript library loading requests, a server MUST provide an HTTP service for retrieving core and feature-linked JavaScript.

Fixed path, computed by a static base URL combined with a path fragment as described in 6.b.c.

JavaScript code corresponding to the API(s) required by the type URL gadget.

Containers MAY support content rewriting. The feature supports rewriting the content of a generated gadget and allow developers to control how the behavior of the rewriter through an optional gadget feature named content-rewrite. The content-rewrite feature defines a set of rewriting operations that a container can perform on rendered and proxied content and defines rules to allow developers to control which content the rewriter can operate on.

The rewriter feature has the general form : <Optional feature="content-rewrite"> <Param name="expires">86400</Param> <Param name="include-url"></Param> <Param name="exclude-url">excluded</Param> <Param name="exclude-url">moreexcluded</Param> <Param name="minify-css">true</Param> <Param name="minify-js">true</Param> <Param name="minify-html">true</Param> </Optional>

The parameters are defined as follows: expires - The duration in seconds to force as minimum HTTP cache time for content fetched through the proxy via a rewritten URL. Default 86400. include-url - Any URL which contains this parameters value as a case-insensitive substring is considered rewriteable. The literal string "*" is a special case and implies all URLs. If not specified an entry with the value "*" is assumed. This parameter can be repeated. exclude-url - Any URL which contains this parameters value as a case-insensitive substring is excluded from rewriting. The literal string "*" implies all URLs and effectively disables all rewriting. This parameter can be repeated. minify-css - Controls whether the container will attempt to minify css in style tags and referenced css files. Valid values are "true"|"false". Default is "true". minify-js - Controls whether the container will attempt to minify JS in script tags and referenced JS files. Valid values are true|false. Valid values are "true"|"false". Default is "true". minify-html - Controls whether the container will attempt to minify HTML content. Valid values are true|false. Valid values are "true"|"false". Default is "true". Matches for "exclude-url" take precedence over matches for "include-url" Note that the special use of "*" to denote all URLs should not be interpreted as support for GLOB or RegEx matching on strings. Containers are free to perform additional optimizations when rewriting links including but not limited to: Extract @import directives from style tags and convert them into link tags in the head tag of the containing HTML content. Merge multiple CSS fetches from successive link tags into one link tag that causes the proxy to concatenate the content fetched from the individual URLs. Merge contiguous <script src=xxx> tags into one concatenating proxy fetch.

Rewrite only gif images <Optional feature="content-rewrite"> <Param name="include-url">.gif</Param> </Optional>

Rewrite only gif images that do not contain "animated" or "cdn" <Optional feature="content-rewrite"> <Param name="include-url">.gif</Param> <Param name="exclude-url">animated</Param> <Param name="exclude-url">cdn</Param> </Optional>

Disable all rewriting <Optional feature="content-rewrite"> <Param name="exclude-url">*</Param> </Optional>

When rendering an OpenSocial Gadget, the container MUST determine if the content for the active view is to be proxied. This is done by checking for the presence of a /Content/@href attribute. If the attribute is present, the container MUST issue an HTTP request to the URI specified by the href attribute following the rules defined in gadgets.io.makeRequest. Attributes on the Content element map to makeRequest as follows: authz: gadgets.io.AuthorizationType (values are canonicalized by converting to lower case. Default value is 'none') oauth_service_name: gadgets.io.RequestParameters.OAUTH_SERVICE_NAME oauth_token_name: gadgets.io.RequestParameters.OAUTH_TOKEN_NAME oauth_request_token: gadgets.io.RequestParameters.OAUTH_REQUEST_TOKEN oauth_request_token_secret: gadgets.io.RequestParameters.OAUTH_REQUEST_TOKEN_SECRET sign_owner: gadgets.io.RequestParameters.SIGN_OWNER (default 'true') sign_viewer: gadgets.io.RequestParameters.SIGN_VIEWER (default 'true') refresh_interval: gadgets.io.RequestParameters.REFRESH_INTERVAL Note that these attributes also apply to Preload elements. The container MUST also add the following parameters to the URI query string: lang: The language of the user viewing the page as specified in Section 3 i under Process in this document. country: The country of the user viewing the page as specified in Section 3 i under Process in this document. opensocial_proxied_content: MUST be present and set to 1. Servers can use this to distinguish proxied content renders from gadgets.io.makeRequest() calls. Remote sites that expect proxied content requests SHOULD reject requests that do not have opensocial_proxied_content set to 1. If a remote site fails to implement this check, any content in the POST body may be spoofed by a malicious user or application. By default, the request is sent to the remote site MUST be sent to the remote site as an HTTP GET. When the Content section includes Data Pipelining elements, the container MUST send the data to the request URI using an HTTP POST. The structure of this data will match the format.

If the response to the proxied request returns a successful HTTP status code, the container MUST interpret the resulting response body according to the rules for content declared inline. If the response to the proxied request returns an unsuccessful HTTP status code, the container SHOULD present a meaningful error message to the end user. Containers SHOULD obtain a suitable error message for display by displaying the content specified for a view named as view-name.error, where view-name matches the name of the view that the proxied request was being processed for. If an exact match can not be found, the special value default.error should be used. If default.error is not present, the container SHOULD display a generic message indicating that a problem occurred.

Containers SHOULD cache the results of the HTTP request following the recommendations of section 13 of RFC 2616. If a container does support caching of data, it MUST also support overriding HTTP caching by using the value specified for refresh_interval. Caches SHOULD be keyed using the following: The URI of the proxied request. The opensocial owner id, if sign_owner is set to true and requests are authenticated. The opensocial viewer id, if sign_viewer is set to true and requests are authenticated. The language and country passed in to the proxied URI. Containers MAY cache unsuccessful HTTP responses ("negative caching"), but SHOULD NOT cache unsuccessful responses for a period longer than 5 minutes.

The container MUST normalize content bodies in a way that preserves semantic meaning in the resulting HTML output. Specifically, containers MUST preserve the structure of the document for the context the gadget will be rendered in as follows: If the document is a complete HTML document, including opening and closing html tags, the container MUST retain the semantic meaning of document type definition declarations as well as the relative position of elements in the document. A container MAY choose to move elements from the head of a document and into the body (or vice versa), but the end result MUST behave the same as the original input . Containers MAY modify the document in other ways for optimization and security purposes as long as semantics are preserved

The container MUST resolve all URI attributes and values relative to the location of the gadget spec xml document. This DOES NOT include links inside of the body of the Content element at this point in time.

Namespace for top-level people functions.

gadgets

<static> gadgets.log(message) Description: Log an informational message. Parameters: Name Type Description message Object The message to log

<static> gadgets.warn(message) Description: Log a warning message. Parameters: Name Type Description message Object The message to log

<static> gadgets.error(message) Description: Log an error message. Parameters: Name Type Description message Object The message to log

<static> gadgets.setLogLevel(logLevel) Description: Sets the log level threshold. Parameters: Name Type Description logLevel Number New log level threshold.

Used by gadgets.setLogLevel.

<static> Member of: gadgets.log Description: Log level for informational logging.

<static> Member of: gadgets.log Description: Log level for warning logging.

<static> Member of: gadgets.log Description: Log level for error logging.

<static> Member of: gadgets.log Description: Log level for no logging.

Provides remote content retrieval functions.

gadgets.io

<static> Type: {String} gadgets.io.encodeValues(fields) Description: Converts an input object into a URL-encoded data string. (key=value&...) Parameters: Name Type Description fields Object The post fields you wish to encode Returns: Type Description String The processed post data; this includes a trailing ampersand (&)

<static> Type: {String} gadgets.io.getProxyUrl(url, opt_params) Description: Gets the proxy version of the passed-in URL. Parameters: Name Type Description url String The URL to get the proxy URL for opt_params Map<String|String> Additional optional parameters to pass to the request Returns: Type Description String The proxied version of the URL

<static> gadgets.io.makeRequest(url, callback, opt_params) Description: Fetches content (e.g. HTML, JSON, XML, and ATOM data) from the provided URL and feeds that content into the callback function.

Example: var params = {}; params[gadgets.io.RequestParameters.CONTENT_TYPE] = gadgets.io.ContentType.TEXT; gadgets.io.makeRequest(url, callback, params);

If opt_params[gadgets.io.RequestParameters.AUTHORIZATION] is set to gadgets.io.AuthorizationType.SIGNED, container mediates communications from the gadget to the application server in a way that can not be spoofed. This trusted content fetching has two main steps: [1] the gadget contacts the container, and [2] the container sends a signed requests to the application server. When the gadget contacts the container, the container needs to be able to validate any parameters it knows about: the viewer id, the owner id (if known), and the application id. Validating these parameters is an implementation detail that may vary between containers. For example, orkut uses an encrypted token passed in the document fragment of the gadget URL. When the container contacts the app server, the app server needs to be able to validate that the parameters really came from the container (and were not forged by some other entity). OpenSocial uses OAuth's parameter signing algorithm. Note that most of the functionality in the OAuth spec, including token exchange, is not required; OpenSocial only plans to use the parameter signing piece of the spec (including timestamp and nonce). OpenSocial permits the HMAC-SHA1 method (except that the key is a shared secret between container and app, not a concatenation of tokens as specified in section 9.2 of the OAuth spec) and the RSA-SHA1 method. HMAC-SHA1 executes faster and is easier to implement, but it requires more coordination than RSA-SHA1. The container signs requests by doing the following: Removing any request parameters with names that begin with oauth, xoauth, or opensocial (case insensitive). Adding the following parameters to the request query string: Optional. The ID of the current viewer, which matches the getId() value on the viewer person object. Required. The ID of the current owner, which matches the getId() value on the owner person object. Required. The URL of the application making the request. Containers may alias multiple application URLs to a single canonical application URL in the case where an application changes URLs. Optional. An opaque identifier used to distinguish between multiple instances of the same application in a single container. If a container does not allow multiple instances of the same application to coexist, this parameter may be omitted. The combination of opensocial_app_url and opensocial_instance_id uniquely identify an instance of an application in a container. Optional. An opaque identifier for the application, unique to a particular container. Containers that wish to maintain backwards compatibility with the opensocial-0.7 specification may include this parameter. Optional. An opaque identifier for the public key used to sign the request. This parameter may be omitted by containers that do not use public keys to sign requests, or if the container arranges other means of key distribution with the target of the request. Signing the resulting request according to section 9 of the OAuth specification.

If a container uses public keys to sign requests, the container MAY use either self-signed certificates or certificates signed by a well-known certificate authority. If a container does not distribute its OAuth signing key over HTTPS, it SHOULD use a certificate signed by a well-known certificate authority. The commonName attribute of the certificate SHOULD match the hostname of the container server, and should also match the value of the oauth_consumer_key parameter specified in the request. The container SHOULD make its public key available for download at a well-known location. The location https://[container-hostname]/opensocial/certificates/xoauth_public_keyvalue is recommended. Recipients of signed requests MUST verify that the signature on the request is correct, and that the timestamp on the request is within a reasonable time window. A time window of 5 minutes before and after the current time is recommended. Recipients of signed requests may use the oauth_consumer_key and xoauth_public_key parameters to automatically detect when a container deploys new certificates. If the container deploys certificates at a well-known location, the recipient MAY automatically download the new certificate. Recipients that automatically download new certificates SHOULD cache the resulting certificates. If a container's certificate is not downloaded from https://[container-hostname], the recipient SHOULD verify that the certificate is signed by a well-known certificate authority before trusting the certificate.

If opt_params[gadgets.io.RequestParameters.AUTHORIZATION] is set to gadgets.io.AuthorizationType.OAUTH, the container needs to use OAuth to gain access to the resource specified in the request. This may require that the gadget obtain the user's content by directing the user to the service provider to gain access.

The following additional parameters may be specified in opt_params: The nickname the gadget uses to refer to the OAuth <Service> element from its XML spec. If unspecified, defaults to "". The nickname the gadget uses to refer to an OAuth token granting access to a particular resources. If unspecified, defaults to "". Gadgets can use multiple token names if they have access to multiple resources from the same service provider. For example, a gadget with access to a contact list and a calendar might use a token name of "contacts" to use the contact list token, and a contact list of "calendar" to use the calendar token. A service provider may be able to automatically provision a gadget with a request token that is preapproved for access to a resource. The gadget can use that token with the OAUTH_REQUEST_TOKEN parameter. This parameter is optional. The secret corresponding to a preapproved request token. This parameter is optional. If OAuth is used, the container should execute the OAuth protocol on behalf of the gadget. If the gadget has not registered a consumer key for use with this service provider, the container may choose to use a default RSA signing key corresponding to a well-known certificate to sign requests. If the container uses a default consumer key, it MUST include an additional OAuth parameter xoauth_app_url that identifies the gadget making the request.

The makeRequest() callback parameter is passed a JavaScript object with several OAuth-specific fields in addition to the normal values returned by makeRequest(): If this value is specified, the user needs to visit an external page to approve the gadget's request to access data. Use of a pop-up window to direct the user to the external page is recommended. Once the user has approved access, the gadget can repeat the makeRequest call to retrieve the data. If this value is specified, it indicates an OAuth-related error occurred. The value will be one of a set of string constants that can be used for programmatically detecting errors. The constants are undefined for opensocial-0.8, but implementers should attempt to agree on a set of useful constant values for standardization in opensocial-0.9. If this value is specified, it indicates an OAuth-related error occurred. The value is free-form text that can be used to provide debugging information for gadget developers.

Gadgets calls to makeRequest, the calls MAY be cached, reducing the load that application servers have to be able to handle. The gadgets.io.RequestParameters.REFRESH_INTERVAL parameter is used to specify the number of seconds that should elapse before the makeRequest call requests content from your servers again. For example, specifying 10 will mean that the container would only query the supplied URL once every 10 seconds, no matter how many people are using the application. Specifying 0 will query the server each time the function is called, effectively bypassing the cached version.

Name Type Description url String The URL where the content is located callback Function The function to call with the data from the URL once it is fetched. The callback function will not be called until after the existing callstack has completed execution. opt_params Map.<gadgets.io.RequestParameters|Object> Additional request parameters or proxy request parameters

Used by RequestParameters.

gadgets.io.AuthorizationType

<static> Member of: gadgets.io.AuthorizationType.NONE Description: No authorization. This field may be used interchangeably with the string 'NONE'.

<static> Member of: gadgets.io.AuthorizationType.OAUTH Description: The container will use OAuth for authentication. This field may be used interchangeably with the string 'OAUTH'.

<static> Member of: gadgets.io.AuthorizationType.SIGNED Description: The request will be signed by the container. This field may be used interchangeably with the string 'SIGNED'.

Used by RequestParameters.

gadgets.io.ContentType

<static> Member of: gadgets.io.ContentType.DOM Description: Returns a DOM object; used for fetching XML. This field may be used interchangeably with the string 'DOM'.

<static> Member of: gadgets.io.ContentType.FEED Description: Returns a JSON representation of an RSS or Atom feed. This field may be used interchangeably with the string 'FEED'.

<static> Member of: gadgets.io.ContentType.JSON Description: Returns a JSON object. This field may be used interchangeably with the string 'JSON'.

<static> Member of: gadgets.io.ContentType.TEXT Description: Returns text; used for fetching HTML. This field may be used interchangeably with the string 'TEXT'.

Defines values for RequestParameters.METHOD.

gadgets.io.MethodType

<static> Member of: gadgets.io.MethodType.DELETE Description: Container support for this method type is OPTIONAL. This field may be used interchangeably with the string 'DELETE'.

<static> Member of: gadgets.io.MethodType.GET Description: The default type. This field may be used interchangeably with the string 'GET'.

<static> Member of: gadgets.io.MethodType.HEAD Description: Container support for this method type is OPTIONAL. This field may be used interchangeably with the string 'HEAD'.

<static> Member of: gadgets.io.MethodType.POST Description: Container support for this method type is OPTIONAL. This field may be used interchangeably with the string 'POST'.

<static> Member of: gadgets.io.MethodType.PUT Description: Container support for this method type is OPTIONAL. This field may be used interchangeably with the string 'PUT'.

Used by gadgets.io.getProxyUrl() method.

gadgets.io.ProxyUrlRequestParameters

<static> Member of: gadgets.io.ProxyUrlRequestParameters.REFRESH_INTERVAL Description: Explicitly sets the lifespan of cached content. The Refresh Interval is the number of seconds the container should cache the given response. By default, the HTTP caching headers will be respected for fetched content. If the refresh interval is set, this value will take precedence over any HTTP cache headers. If this value is not set and there are no HTTP caching headers specified, this value will default to 3600 (one hour). Note that Signed requests and objects with POST_DATA present will generally not be cached. This field may be used interchangeably with the string 'REFRESH_INTERVAL'.

Used by the gadgets.io.makeRequest() method.

gadgets.io.RequestParameters

<static> Member of: gadgets.io.RequestParameters.AUTHORIZATION Description: The type of authentication to use when fetching the content; defaults to AuthorizationType.NONE. Specified as an AuthorizationType. This field may be used interchangeably with the string 'AUTHORIZATION'.

<static> Member of: gadgets.io.RequestParameters.CONTENT_TYPE Description: The type of content that lives at the URL; defaults to ContentType.TEXT. Specified as a ContentType. This field may be used interchangeably with the string 'CONTENT_TYPE'.

<static> Member of: gadgets.io.RequestParameters.GET_SUMMARIES Description: If the content is a feed, whether to fetch summaries for that feed; defaults to false. Specified as a Boolean. This field may be used interchangeably with the string 'GET_SUMMARIES'.

<static> Member of: gadgets.io.RequestParameters.HEADERS Description: The HTTP headers to send to the URL; defaults to null. Specified as a Map.<String,String>. This field may be used interchangeably with the string 'HEADERS'.

<static> Member of: gadgets.io.RequestParameters.METHOD Description: The method to use when fetching content from the URL; defaults to MethodType.GET. Valid values are specified by MethodType. This field may be used interchangeably with the string 'METHOD'.

<static> Member of: gadgets.io.RequestParameters.NUM_ENTRIES Description: If the content is a feed, the number of entries to fetch; defaults to 3. Specified as a Number. This field may be used interchangeably with the string 'NUM_ENTRIES'.

<static> Member of: gadgets.io.RequestParameters.POST_DATA Description: The data to send to the URL using the POST method; defaults to null. Specified as a String. This field may be used interchangeably with the string 'POST_DATA'.

<static> Member of: gadgets.io.RequestParameters.REFRESH_INTERVAL Description: Explicitly sets the lifespan of cached content. The Refresh Interval is the number of seconds the container should cache the given response. By default, the HTTP caching headers will be respected for fetched content. If the refresh interval is set, this value will take precedence over any HTTP cache headers. If this value is not set and there are no HTTP caching headers specified, this value will default to 3600 (one hour). Note that Signed requests and objects with POST_DATA present will generally not be cached. This field may be used interchangeably with the string 'REFRESH_INTERVAL'.

Provides operations for translating objects to and from JSON.

gadgets.json

<static> Type: {Object} gadgets.json.parse(text) Description: Parses a JSON string, producing a JavaScript value. Parameters: Name Type Description text String The string to transform into an object; usually the result of a previous stringify call Returns: Type Description Object The object parsed from the passed in text; false if an error occurred

<static> Type: {String} gadgets.json.stringify(v) Description: Converts a JavaScript value to a JSON string. Parameters: Name Type Description v Object The object to convert Returns: Type Description String The JSON equivalent

Provides access to user preferences, module dimensions, and messages. Clients can access their preferences by constructing an instance of gadgets.Prefs and passing in their module ID. Example:

var prefs = new gadgets.Prefs(); var name = prefs.getString("name"); var lang = prefs.getLang();

gadgets.Prefs(opt_moduleId) Creates a new Prefs object. Parameters: Name Type Description opt_moduleId String | Number An optional parameter specifying the module ID to create prefs for; if not provided, the default module ID is used

Type: {Array.<String>} getArray(key) Description: Retrieves a preference as an array. UserPref values that were not declared as lists are treated as one-element arrays. Parameters: Name Type Description key String The preference to fetch Returns: Type Description Array.<String> The preference; if not set, an empty array

Type: {Boolean} getBool(key) Description: Retrieves a preference as a boolean. Parameters: Name Type Description key String The preference to fetch Returns: Type Description Boolean The preference; if not set, false

Type: {String} getCountry() Description: Gets the current country, returned as ISO 3166-1 alpha-2 code. Returns: Type Description String The country for this module instance

Type: {Number} getFloat(key) Description: Retrieves a preference as a floating-point value. Parameters: Name Type Description key String The preference to fetch Returns: Type Description Number The preference; if not set, 0

Type: {Number} getInt(key) Description: Retrieves a preference as an integer. Parameters: Name Type Description key String The preference to fetch Returns: Type Description Number The preference; if not set, 0

Type: {String} getLang() Description: Gets the current language the gadget should use when rendering, returned as a ISO 639-1 language code. Returns: Type Description String The language for this module instance

Type: {String | Number} getModuleId() Description: Gets the module ID for the current instance. Returns: Type Description String | Number The module ID for this module instance

Type: {String} getMsg(key) Description: Fetches an unformatted message. Parameters: Name Type Description key String The message to fetch Returns: Type Description String The message

Type: {String} getString(key) Description: Retrieves a preference as a string. Parameters: Name Type Description key String The preference to fetch Returns: Type Description String The preference; if not set, an empty string

set(key, val) Description: Stores a preference. To use this call, the gadget must require the feature setprefs. Note: If the gadget needs to store an Array it should use setArray instead of this call. Parameters: Name Type Description key String The pref to store val Object The values to store

setArray(key, val) Description: Stores an array preference. To use this call, the gadget must require the feature setprefs. Parameters: Name Type Description key String The pref to store val Array The values to store

Provides general-purpose utility functions.

gadgets.util

<static> Type: {String} gadgets.util.escapeString(str) Description: Escapes the input using HTML entities to make it safer. The following characters are affected: newline (\n, Unicode code point 10) carriage return (\r, Unicode 13) double quote (", Unicode 34) ampersand (&, Unicode 38) single quote (', Unicode 39) left angle bracket (<, Unicode 60) right angle bracket (>, Unicode 62) backslash (\, Unicode 92) line separator (Unicode 8232) paragraph separator (Unicode 8233) Parameters: Name Type Description str String The string to escape Returns: Type Description String The escaped string

<static> Type: {Object} gadgets.util.getFeatureParameters(feature) Description: Returns the value of parameters for this feature. A gadget specifies parameters using the <Param> subelement of the <Requires> or <Optional> element. Parameters: Name Type Description feature String The feature to get parameters for Returns: Type Description Object The parameters for the given feature, or null

<static> Type: {Boolean} gadgets.util.hasFeature(feature) Description: Returns whether the specified feature is supported. Parameters: Name Type Description feature String The feature to test for Returns: Type Description Boolean True if the feature is supported

<static> gadgets.util.registerOnLoadHandler(callback) Description: Registers an onload handler; a function that's executed when the gadget loads. Multiple handlers can be registered, and all will be invoked in the same order that they were registered. Parameters: Name Type Description callback Function The handler to run. The callback function will not be called until after the existing callstack has completed execution.

<static> Type: {String} gadgets.util.sanitizeHtml(text) Description: Sanitizes a text string. The returned value is safe to assign to innerHTML. The returned value may include HTML tags. If plain text is desired, use gadgets.util.escapeString instead. Parameters: Name Type Description text String arbitrary text string Returns: Type Description String a sanitized version that may include HTML tags, but will not execute script.

<static> Type: {String} gadgets.util.unescapeString(str) Description: Reverses escapeString Parameters: Name Type Description str String The string to unescape. Returns: Type Description String The unescaped string

Provides operations for dealing with views. See also: gadgets.views.View

gadgets.views

<static> Type: {String} gadgets.views.bind(urlTemplate, environment) Description: Binds a URL template with variables in the passed environment to produce a URL string. See also: View.getUrlTemplate() Parameters: Name Type Description urlTemplate A url template for a container view environment A set of named variables (for example, [[]OWNER | PATH | PARAMS | NAME]) of type string. Returns: Type Description String A URL string

<static> Type: { gadgets.views.View } gadgets.views.getCurrentView() Description: Returns the current view. Returns: Type Description gadgets.views.View The current view

<static> Type: {Map.<String|String>} gadgets.views.getParams() Description: Returns the parameters passed into this gadget for this view. Does not include all URL parameters, only the ones passed into gadgets.views.requestNavigateTo. Returns: Type Description Map.<String|String> The parameter map

<static> Type: {Map<gadgets.views.ViewType | String|gadgets.views.View>} gadgets.views.getSupportedViews() Description: Returns a map of all the supported views. Keys each gadgets.view.View by its name. This function only returns the primary views and does not return any secondary views. Example: if the markup indicates a set of views named Canvas.About, Profile.About, Home.About, Canvas.Help the returned views will only be Canvas, Profile, Home. Returns: Type Description Map<gadgets.views.ViewType | String|gadgets.views.View> All supported views, keyed by their name attribute.

<static> gadgets.views.requestNavigateTo(|, |, opt_ownerId) Description: Attempts to navigate to this gadget in a different view. If the container supports parameter passing it will pass the optional parameters along to the gadget in the new view. This also allows for navigation to named views on the current surface. Views are composed of names that are [Surface](.[Secondary])?. The canonical Surface names are Canvas, Profile, Home. The Secondary names are user defined. When navigating from [Surface].valueX to [Surface].valueY, the container can stay on the same Surface but will show the appropriate <Content> sections whose View is [Surface].valueY. When navigating from SurfaceA.[Secondary] to SurfaceB.[Secondary], the container will switch to the SurfaceB surface and show the appropriate <Content> sections whose View is SurfaceB.[Secondary].In no cases must the .[Secondary] item ever be declared. Parameters: Name Type Description | gadgets.views.View {string} view If set to a string, the name of the view to navigate to. If set to a View, the View object to navigate to. Passing a View has been deprecated. | Map.<String|String> {string} opt_params If the value is an object, it represents parameters to pass to the gadget after it has been navigated to on the surface. If the view navigated to contains an href and opt_params is a string, the value in opt_params is treated as a relative path that must be resolved relative to the href of the referenced view according to RFC 3986. If opt_params is a string all query parameters including query parameters encoded in a fragment are available in the receiving view using gadgets.views.getParams() opt_ownerId String The ID of the owner of the page to navigate to; defaults to the current owner

Base interface for all view objects.

Type: {String} bind(environment) Description: Binds the view's URL template with variables in the passed environment to produce a URL string. See also: getUrlTemplate() Parameters: Name Type Description environment A set of named variables (for example, [[]OWNER | PATH | PARAMS | NAME]) of type string. Returns: Type Description String A URL string

Type: { gadgets.views.ViewType | String} getName() Description: Returns the name of this view. Returns: Type Description gadgets.views.ViewType | String The view name, usually specified as a gadgets.views.ViewType

Type: {String} getUrlTemplate() Description: Returns a string URI template conforming to the IETF spec draft with variables for substitution. Four variables are supported: The name or ID of the application The ID of the owner of the page An array of path steps` Associative array or array[[]param1,value1,param2,value2,...]Example

Here are two valid URL template strings: http://container.com/{-list|/|name,owner,path}?{-join|&|params} http://container.com/apps/{name}/{owner}{-prefix|/|path}{-opt|?os_|params}{-join|&os_|params}

Here are some parameters:

{ name : 'Wilma', owner : 'Betty', path : ['dino','car'], params : { a : 'Barney', b : 'Fred'} }

With those parameters, the two example URL template strings resolve to the following URLs:

http://container.com/Wilma/Betty/dino/car?a=Barney&b=Fred http://container.com/apps/Wilma/Betty/dino/car?os_a=Barney&os_b=Fred

See also: bind() Returns: Type Description String A template that can be used to construct URLs that navigate to this view

Type: {boolean} isOnlyVisibleGadget() Description: Returns true if the gadget is the only visible gadget in this view. On a canvas page or in maximize mode this is most likely true; on a profile page or in dashboard mode, it is most likely false. Returns: Type Description boolean True if the gadget is the only visible gadget; otherwise, false

Used by View s.

gadgets.views.ViewType

<static> Member of: gadgets.views.ViewType.CANVAS Description: A view where the gadget is displayed in a very large mode. It is typically the main content on the page. The viewer is not always the same as the owner. This field may be used interchangeably with the string 'CANVAS'.

<static> Member of: gadgets.views.ViewType.HOME Description: A view where the gadget is displayed in a small area usually on a page with other gadgets. Typically the viewer is the same as the owner. This field may be used interchangeably with the string 'HOME'.

<static> Member of: gadgets.views.ViewType.PREVIEW Description: A demo view of the gadget. In this view the owner and viewer are not known. This field may be used interchangeably with the string 'PREVIEW'.

<static> Member of: gadgets.views.ViewType.PROFILE Description: A view where the gadget is displayed in a small area usually on a page with other gadgets. The viewer is not always the same as the owner. This field may be used interchangeably with the string 'PROFILE'.

Embeds Flash content in gadgets.

gadgets.flash

<static> Type: {Boolean} gadgets.flash.embedCachedFlash() Description: Injects a cached Flash file into the DOM tree. Accepts the same parameters as gadgets.flash.embedFlash does. Returns: Type Description Boolean Whether the function call completes successfully

<static> Type: {Boolean} gadgets.flash.embedFlash(swfUrl, swfContainer, swfVersion, opt_params) Description: Injects a Flash file into the DOM tree. Parameters: Name Type Description swfUrl String SWF URL swfContainer String | Object The ID or object reference of an existing HTML container element swfVersion Number Minimum Flash Player version required opt_params Object An optional object that may contain any valid HTML parameter; all attributes will be passed through to the Flash movie on creation Returns: Type Description Boolean Whether the function call completes successfully

<static> Type: {Number} gadgets.flash.getMajorVersion() Description: Detects Flash Player and its major version. Returns: Type Description Number The major version of Flash Player or 0 if Flash is not supported

MiniMessage class, used to create messages that will appear to the user within the gadget. Typical use cases: Status messages: loading, saving, etc. Promotional messages: new features, new gadget, etc. Debug/error messages: bad input, failed connection to server, etc.

gadgets.MiniMessage(opt_moduleId, opt_container) Creates a MiniMessage. Parameters: Name Type Description opt_moduleId String Optional module ID opt_container HTMLElement Optional HTML container element where mini-messages will appear

Type: {HTMLElement} createDismissibleMessage(message, opt_callback) Description: Creates a dismissible message with an [x] icon that allows users to dismiss the message. When the message is dismissed, it is removed from the DOM and the optional callback function, if defined, is called. Parameters: Name Type Description message String | Object The message as an HTML string or DOM element opt_callback Function Optional callback function to be called when the message is dismissed. The callback function will not be called until after the existing callstack has completed execution. Returns: Type Description HTMLElement HTML element of the created message

Type: {HTMLElement} createStaticMessage(message) Description: Creates a static message that can only be dismissed programmatically (by calling dismissMessage()). Parameters: Name Type Description message String | Object The message as an HTML string or DOM element Returns: Type Description HTMLElement HTML element of the created message

Type: {HTMLElement} createTimerMessage(message, seconds, opt_callback) Description: Creates a message that displays for the specified number of seconds. When the timer expires, the message is dismissed and the optional callback function is executed. Parameters: Name Type Description message String | Object The message as an HTML string or DOM element seconds number Number of seconds to wait before dismissing the message opt_callback Function Optional callback function to be called when the message is dismissed. To continue the dismissal of the message, this function should return true. The callback function will not be called until after the existing callstack has completed execution. Returns: Type Description HTMLElement HTML element of the created message

dismissMessage(message) Description: Dismisses the specified message. Parameters: Name Type Description message HTMLElement HTML element of the message to remove

OAuth popup window manager. Expected usage: Gadget attempts to fetch OAuth data for the user and discovers that approval is needed. The gadget creates two new UI elements: a "personalize this gadget" button or link a "personalization done" button or link, which is initially hidden. The "personalization done" button may be unnecessary. The popup window manager will attempt to detect when the window closes. However, the "personalization done" button should still be displayed to handle cases where the popup manager is unable to detect that a window has closed. This allows the user to signal approval manually. Gadget creates a popup object and associates event handlers with the UI elements:

// Called when the user opens the popup window. var onOpen = function() { $("personalizeDone").style.display = "block" } // Called when the user closes the popup window. var onClose = function() { $("personalizeDone").style.display = "none" fetchData(); } var popup = new gadgets.oauth.Popup( response.oauthApprovalUrl, "height=300,width=200", onOpen, onClose ); personalizeButton.onclick = popup.createOpenerOnClick(); personalizeDoneButton.onclick = popup.createApprovedOnClick();

When the user clicks the personalization button/link, a window is opened to the approval URL. The onOpen function is called to notify the gadget that the window was opened. When the window is closed, the popup manager calls the onClose function and the gadget attempts to fetch the user's data.

gadgets.oauth.Popup(destination, windowOptions, openCallback, closeCallback) Description: used to create a new OAuth popup window manager. Parameters: Name Type Description destination String Target URL for the popup window. windowOptions String Options for window.open, used to specify look and feel of the window. openCallback Function Function to call when the window is opened. closeCallback Function Function to call when the window is closed.

Type: {Function} createOpenerOnClick() Returns: Type Description Function an onclick handler for the "open the approval window" link.

Type: {Function} createApprovedOnClick() Returns: Type Description Function an onclick handler for the "I've approved" link. This may not ever be called. If we successfully detect that the window was closed, this link is unnecessary.

Provides operations for making remote procedure calls for gadget-to-container, container-to-gadget, and gadget-to-gadget communication.

gadgets.rpc

<static> gadgets.rpc.call(targetId, serviceName, callback, var_args) Description: Calls an RPC service. Parameters: Name Type Description targetId String ID of the RPC service provider; empty if calling the parent container serviceName String Service name to call callback Function|null Callback function (if any) to process the return value of the RPC request. The callback function will not be called until after the existing callstack has completed execution. var_args * Parameters for the RPC request

<static> gadgets.rpc.register(serviceName, handler) Description: Registers an RPC service. Parameters: Name Type Description serviceName String Service name to register handler Function Service handler

<static> gadgets.rpc.registerDefault(handler) Description: Registers a default service handler to process all unknown remote procedure calls, which fail silently by default. Parameters: Name Type Description handler Function Service handler

<static> gadgets.rpc.unregister(serviceName) Description: Unregisters an RPC service. Parameters: Name Type Description serviceName String Service name to unregister

<static> gadgets.rpc.unregisterDefault() Description: Unregisters the default service handler. Future unknown remote procedure calls will fail silently.

Provides operations for getting display information about the currently shown skin.

gadgets.skins

<static> Type: {String} gadgets.skins.getProperty(propertyKey) Description: Fetches the display property mapped to the given key. Parameters: Name Type Description propertyKey String The key to get data for; keys are defined in gadgets.skins.Property Returns: Type Description String The data

All of the display values that can be fetched and used in the gadgets UI. These are the supported keys for the gadgets.skins.getProperty() method.

gadgets.skins.Property

<static> Member of: gadgets.skins.Property.ANCHOR_COLOR Description: The color that anchor tags should use. This field may be used interchangeably with the string 'ANCHOR_COLOR'.

<static> Member of: gadgets.skins.Property.BG_COLOR Description: The color of the background of the gadget. This field may be used interchangeably with the string 'BG_COLOR'.

<static> Member of: gadgets.skins.Property.BG_IMAGE Description: An image to use in the background of the gadget. This field may be used interchangeably with the string 'BG_IMAGE'.

<static> Member of: gadgets.skins.Property.FONT_COLOR Description: The color in which the main font should be rendered. This field may be used interchangeably with the string 'FONT_COLOR'.

Tab class for gadgets. You create tabs using the TabSet addTab() method. To get Tab objects, use the TabSet getSelectedTab() or getTabs() methods. See also: TabSet

Type: {Function} getCallback() Description: Returns the callback function that is executed when the tab is selected. Returns: Type Description Function The callback function of the tab

Type: {HTMLElement} getContentContainer() Description: Returns the HTML element where the tab content is rendered. Returns: Type Description HTMLElement The HTML element of the content container

Type: {Number} getIndex() Description: Returns the tab's index. Returns: Type Description Number The tab's index

Type: {String} getName() Description: Returns the label of the tab as a string (may contain HTML). Returns: Type Description String The label of the tab

Type: {HTMLElement} getNameContainer() Description: Returns the HTML element that contains the tab's label. Returns: Type Description HTMLElement The HTML element of the tab's label

A class gadgets can use to make tabs.

gadgets.TabSet(opt_moduleId, opt_defaultTab, opt_container) Creates a new TabSet object Parameters: Name Type Description opt_moduleId String Optional suffix for the ID of tab container opt_defaultTab String Optional tab name that specifies the name of of the tab that is selected after initialization; if this parameter is omitted, the first tab is selected by default opt_container HTMLElement The HTML element to contain the tabs; if omitted, a new div element is created and inserted at the very top

Type: {String} addTab(tabName, opt_params) Description: Adds a new tab based on the name-value pairs specified in opt_params. The following properties are supported in opt_params: An existing HTML element to be used as the tab content container. If omitted, the tabs library creates one. A callback function to be executed when the tab is selected. The callback function will not be called until after the existing callstack has completed execution. A tooltip description that pops up when user moves the mouse cursor over the tab. The index at which to insert the tab. If omitted, the new tab is appended to the end. Parameters: Name Type Description tabName String Label of the tab to create opt_params Object Optional parameter object Returns: Type Description String DOM id of the tab container

alignTabs(align, opt_offset) Description: Sets the alignment of tabs. Tabs are center-aligned by default. Parameters: Name Type Description align String 'left', 'center', or 'right' opt_offset Number Optional parameter to set the number of pixels to offset tabs from the left or right edge; the default value is 3px

displayTabs(display) Description: Shows or hides tabs and all associated content. Parameters: Name Type Description display Boolean True to show tabs; false to hide tabs

Type: {HTMLElement} getHeaderContainer() Description: Returns the tab headers container element. Returns: Type Description HTMLElement The tab headers container element

Type: { gadgets.Tab } getSelectedTab() Description: Returns the currently selected tab object. Returns: Type Description gadgets.Tab The currently selected tab object

Type: {Array.<gadgets.Tab>} getTabs() Description: Returns an array of all existing tab objects. Returns: Type Description Array.<gadgets.Tab> Array of all existing tab objects

removeTab(tabIndex) Description: Removes a tab at tabIndex and all of its associated content. Parameters: Name Type Description tabIndex Number Index of the tab to remove

setSelectedTab(tabIndex) Description: Selects the tab at tabIndex and fires the tab's callback function if it exists. If the tab is already selected, the callback is not fired. Parameters: Name Type Description tabIndex Number Index of the tab to select

swapTabs(tabIndex1, tabIndex2) Description: Swaps the positions of tabs at tabIndex1 and tabIndex2. The selected tab does not change, and no callback functions are called. Parameters: Name Type Description tabIndex1 Number Index of the first tab to swap tabIndex2 Number Index of the secnod tab to swap

Provides operations for getting information about and modifying the window the gadget is placed in.

gadgets.window

<static> gadgets.window.adjustHeight(opt_height) Description: Adjusts the gadget height. Parameters: Name Type Description opt_height Number An optional preferred height in pixels; If not specified, will attempt to fit the gadget to its content

<static> Type: {Object} gadgets.window.getViewportDimensions() Description: Detects the inner dimensions of a frame. See http://www.quirksmode.org/dom/w3c_cssom for more information. Returns: Type Description Object An object with width and height properties

<static> gadgets.window.setTitle(title) Description: Sets the gadget title. Parameters: Name Type Description title String The preferred title

A container MUST emit the OpenSocial JavaScript internationalization libraries and data files required by the libraries if an application requires the feature <Require feature="opensocial-i18n"/>. The container SHOULD emit the OpenSocial JavaScript internationalization libraries and data files required by the libraries if an application optionallly requests the feature <Optional feature="opensocial-i18n"/>.

Class for internationalization features.

Gadgets locale is set at render time. The i18n package above will use getCountry and getLanguage to load the corresponding formatter/parser for that locale if any of the functions in the package are invoked. For example, let's say gadgets has lanuguage as french and country as france, the i18n package will use formatter/parser following french conventions by default. That means gadget developers could format/parse French date/time/number/currency using the predefined CURRENCY_PATTERN.

Example gadgets.i18n.parseNumber(gadgets.i18n.CURRENCY_PATTERN, "20 000 \u20AC"); // will return 20000

They could also parse foreign currency by passing in a opt_currencyCode. Note when French writes an amount of foreign currency, they will still use the French way of writing numbers the positioning currency code - just the currency code is different.

Example gadgets.i18n.parseNumber(gadgets.i18n.CURRENCY_PATTERN, "20 000 $", 0, "USD"); // will return 20000

It gets a little bit complicated if a foreign currency written in the foreign way is to be parsed. In that case, predefined patterns won't work, and string patterns need to be used. The example below returns 0 (indicating error in parsing), as the number presented is not in French format.

Example gadgets.i18n.parseNumber(gadgets.i18n.CURRENCY_PATTERN, "$20,000"); // will return 0, indicating error

To make this work, a string pattern needs to be passed in, like what is done below:

Example gadgets.i18n.parseNumber("#,###", "$20,000", 0, "USD"); // will return 20000

Both Formatting and Parsing following the same pattern specification. The date/time pattern specifications are found in Unicode Locale Data Markup Language, Date Format Patterns The following specifiers are not required in this release: w: Week of year W: Week of Month. D: Day of year. F: Day of Week in Month. g: Modified Julian day

Many characters in a pattern are taken literally; they are matched during parsing and output unchanged during formatting. Special characters, on the other hand, stand for other characters, strings, or classes of characters. For example, the '#' character is replaced by a localized digit. Often the replacement character is the same as the pattern character; in the U.S. locale, the ',' grouping character is replaced by ','. However, the replacement is still happening, and if the symbols are modified, the grouping character changes. Some special characters affect the behavior of the formatter by their presence; for example, if the percent character is seen, then the value is multiplied by 100 before being displayed. To insert a special character in a pattern as a literal, that is, without any special meaning, the character must be quoted. There are some exceptions to this which are noted below. The characters listed here are used in non-localized patterns. Localized patterns use the corresponding characters taken from corresponding locale symbol collection. Two exceptions are the currency sign and quote, which are not localized. Symbol Location Localized? Meaning 0 Number Yes Digit # Number Yes Digit, zero shows as absent. . Number Yes Decimal separator or monetary decimal separator. - Number Yes Minus sign , Number Yes Grouping Separator E Number Yes Separates mantizza and exponent in scientific notation. Need not be quoted in prefix or suffix. ; Subpattern boundary Yes Separates positive and negative subpatterns. % Prefix or suffix Yes Multiply by 100 and show as percentage. \u2030 Prefix or suffix Yes Multiply by 1000 and show as per mile. ¤ (\u00A4) Prefix or suffix No Currency sign, replaced by currency symbol. If doubled, replaced by international currency symbol. If present in a pattern, the monetary decimal separator is used instead of the decimal separator. ' Prefix or suffix No Used to quote special characters in a prefix or suffix, for example, "'#'#" formats 123 to "#123". To create a single quote itself, use two in a row: "# o''clock". A NumberFormat pattern contains a postive and negative subpattern, for example, "#,##0.00;(#,##0.00)". Each subpattern has a prefix, a numeric part, and a suffix. If there is no explicit negative subpattern, the negative subpattern is the localized minus sign prefixed to the positive subpattern. That is, "0.00" alone is equivalent to "0.00;-0.00". If there is an explicit negative subpattern, it serves only to specify the negative prefix and suffix; the number of digits, minimal digits, and other characteristics are ignored in the negative subpattern. That means that "#,##0.0#;(#)" has precisely the same result as "#,##0.0#;(#,##0.0#)". The prefixes, suffixes, and various symbols used for infinity, digits, thousands separators, decimal separators, etc. may be set to arbitrary values, and they will appear properly during formatting. However, care must be taken that the symbols and strings do not conflict, or parsing will be unreliable. For example, the decimal separator and thousands separator should be distinct characters, or parsing will be impossible. The grouping separator is a character that separates clusters of integer digits to make large numbers more legible. It commonly used for thousands, but in some locales it separates ten-thousands. The grouping size is the number of digits between the grouping separators, such as 3 for "100,000,000" or 4 for "1 0000 0000".

pattern := subpattern (';' subpattern)? subpattern := prefix? number exponent? suffix? number := (integer ('.' fraction)?) | sigDigits prefix := '\u0000'..'\uFFFD' - specialCharacters suffix := '\u0000'..'\uFFFD' - specialCharacters integer := '#'* '0'* '0' fraction := '0'* '#'* sigDigits := '#'* '@' '@'* '#'* exponent := 'E' '+'? '0'* '0' padSpec := '*' padChar padChar := '\u0000'..'\uFFFD' - quote Notation: X* 0 or more instances of X X? 0 or 1 instances of X X|Y either X or Y C..D any character from C up to D, inclusive S-T characters in S, except those in T

The first subpattern is for positive numbers. The second (optional) subpattern is for negative numbers.

<static> Member of: gadgets.i18n.CURRENCY_PATTERN Description: Pattern for currency.

<static> Member of: gadgets.i18n.DECIMAL_PATTERN Description: Pattern for decimal numbers.

<static> Member of: gadgets.i18n.FULL_DATE_FORMAT Description: Format for full representations of dates.

<static> Member of: gadgets.i18n.FULL_DATETIME_FORMAT Description: Format for short representations of datetimes.

<static> Member of: gadgets.i18n.FULL_TIME_FORMAT Description: Format for full representations of times.

<static> Member of: gadgets.i18n.LONG_DATE_FORMAT Description: Format for long representations of dates.

<static> Member of: gadgets.i18n.LONG_DATETIME_FORMAT Description: Format for short representations of datetimes.

<static> Member of: gadgets.i18n.LONG_TIME_FORMAT Description: Format for long representations of times.

<static> Member of: gadgets.i18n.MEDIUM_DATE_FORMAT Description: Format for medium representations of dates.

<static> Member of: gadgets.i18n.MEDIUM_DATETIME_FORMAT Description: Format for medium representations of datetimes.

<static> Member of: gadgets.i18n.MEDIUM_TIME_FORMAT Description: Format for medium representations of times.

<static> Member of: gadgets.i18n.PERCENT_PATTERN Description: Pattern for percentages.

<static> Member of: gadgets.i18n.SCIENTIFIC_PATTERN Description: Pattern for scientific numbers.

<static> Member of: gadgets.i18n.SHORT_DATE_FORMAT Description: Format for short representations of dates.

<static> Member of: gadgets.i18n.SHORT_DATETIME_FORMAT Description: Format for short representations of datetimes.

<static> Member of: gadgets.i18n.SHORT_TIME_FORMAT Description: Format for short representations of times.

<static> Type: {string} gadgets.i18n.formatDateTime(pattern, date) Description: This method formats a "Date" object with provided pattern specification. The pattern could be a string using ICU notation or a predefined pattern. A string using ICU notation offers the most flexibility. Each field as specified in the pattern has locale specific behavior. The pattern string is allowed to contain string literals, and one type of pattern might not work for all locales. In those case, the pattern itself could also be locale specific, thus not good for sharing among locales.

Example date = new Date(2006, 6, 27, 13, 10, 10, 250); assertEquals("13:10:10", gadgets.i18n.formatDateTime("HH:mm:ss", date));

Parameters: Name Type Description pattern string/number String to specify patterns or Number used to reference predefined pattern that a date should be formatted into. date Date Date object being formatted. Returns: Type Description string string representation of date/time.

<static> Type: {string} gadgets.i18n.formatNumber(pattern, value, opt_currencyCode) Description: Format number using the pattern specified. The pattern could be a string pattern or one of the predefined patterns. The formatted string is returned. If an error is encountered, zero will be returned.

Example var str = gadgets.i18n.formatNumber("#,###", 1234567890); assertEquals("1,234,567,890", str); var str = gadgets.i18n.formatNumber(gadgets.i18n.CURRRENCY_PATTERN, 1234.569); assertEquals("$1,234.58", str);

Parameters: Name Type Description pattern string/number String to specify patterns or Number used to reference predefined pattern that a number should be formatted into. value number The number being formatted. opt_currencyCode string optional international currency code, it determines the currency code/symbol should be used in format/parse. If not given, the currency code for current locale will be used. Returns: Type Description string The formatted string.

<static> Type: {number} gadgets.i18n.parseDateTime(pattern, text, start, date) Description: This method will parse the input string ("text"), interpretting it as specified by pattern. The parsed result will be saved into a Date object ("date"). "start" indicates from where in the string the parse should start. This method returns the number of characters consumed.

Example assertTrue(gadgets.i18n.parseDateTime("yyMMdd", "991202", 0, date) > 0); assertEquals(1999, date.getFullYear()); assertTrue(date.getMonth() == 12 - 1); assertTrue(date.getDate() == 02); assertTrue(gadgets.i18n.parseDateTime("yyyyMMdd", "20051202", 0, date) > 0); assertEquals(2005, date.getFullYear()); assertTrue(date.getMonth() == 12 - 1); assertTrue(date.getDate() == 02);

A whole piece of string is usually the target for parsing. But in some cases, you might just want to parse part of the string, "start" parameter and return value also make it very convenient. For example, suppose you want to parse a string like "88/01, 99/03, 98/05, 97/02", the following code will do the job.

Example var date_array = [] var pos = 0; var text = "88/01, 99/03, 98/05, 97/02"; while(1) { var date = new Date; var consumed = gadgets.i18n.parseDateTime("yy/MM", text, pos, date); if (consumed <= 0) break; date_array.push(date); pos += consumed; if (pos < text.length && text[pos] == ',') ++pos; if (pos < text.length && text[pos] == ' ') ++pos; }

Similar to the formatting functions, a predefined pattern could also be passed in as the first parameter.

Example //assume locale has already been set to zh_CN var date = new Date(); gadgets.i18n.parseDateTime(gadgets.i18n.LONG_DATE_FORMAT, "2006年7月24日", 0, date); assertEquals(date.getFullYear(), 2006); assertEquals(date.getMonth(), 7 - 1); assertEquals(date.getDate(), 24);

Parameters: Name Type Description pattern string/number String to specify patterns or Number used to reference predefined pattern that a date should be parsed from. text string The string that need to be parsed. start number The character position in "text" where parse begins. date Date The date object that will hold parsed value. Returns: Type Description number The number of characters advanced or 0 if failed.

<static> Type: {number} gadgets.i18n.parseNumber(pattern, text, opt_pos, opt_currencyCode) Description: Parse string to get a number the pattern specified. The pattern could be a string pattern or one of the predefined patterns.

Example var value = gadgets.i18n.parseNumber("0E0", "1.2345E+4"); assertEquals(12345.0, value); //assume locale has already been set to fr var value = gadgets.i18n.parseNumber(gadgets.i18n.CURRENCY_PATTERN, "0,30 €"); assertEquals(0.30, value);

Parameters: Name Type Description pattern string/number String to specify patterns or Number used to reference predefined pattern that a number should be parsed from. text string input text being parsed. opt_pos Array optional one element array that holds position information. It tells from where parse should begin. Upon return, it holds parse stop position. opt_currencyCode string optional international currency code, it determines the currency code/symbol should be used in format/parse. If not given, the currency code for current locale will be used. Returns: Type Description number Parsed number, 0 if in error.

<?xml version="1.0"?> <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"> <xs:element name="Module"> <xs:complexType> <xs:sequence> <xs:element name="ModulePrefs" minOccurs="0"> <xs:complexType> <xs:choice minOccurs="0" maxOccurs="unbounded"> <xs:element name="Require" type="GadgetFeatureType"/> <xs:element name="Optional" type="GadgetFeatureType"/> <xs:element name="Preload"> <xs:complexType> <xs:attribute name="href" type="xs:string" use="required"/> <xs:attribute name="authz" default="none"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:enumeration value="none"/> <xs:enumeration value="signed"/> <xs:enumeration value="oauth"/> </xs:restriction> </xs:simpleType> </xs:attribute> <xs:attribute name="sign_owner" type="xs:boolean" default="true"/> <xs:attribute name="sign_viewer" type="xs:boolean" default="true"/> <xs:attribute name="views" type="xs:string" use="optional"/> <xs:attribute name="oauth_service_name" type="xs:string" use="optional"/> <xs:attribute name="oauth_token_name" type="xs:string" use="optional"/> <xs:attribute name="oauth_request_token" type="xs:string" use="optional"/> <xs:attribute name="oauth_request_token_secret" type="xs:string" use="optional"/> </xs:complexType> </xs:element> <xs:element name="Icon"> <xs:complexType> <xs:simpleContent> <xs:extension base="xs:string"> <xs:attribute name="mode"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:enumeration value="base64"/> </xs:restriction> </xs:simpleType> </xs:attribute> <xs:attribute name="type" type="xs:string"/> </xs:extension> </xs:simpleContent> </xs:complexType> </xs:element> <xs:element name="Locale"> <xs:complexType> <xs:sequence> <xs:element name="msg" minOccurs="0" maxOccurs="unbounded"> <xs:complexType> <xs:simpleContent> <xs:extension base="xs:string"> <xs:attribute name="name" type="xs:string" use="required"/> <xs:attribute name="desc" type="xs:string" use="optional"/> </xs:extension> </xs:simpleContent> </xs:complexType> </xs:element> </xs:sequence> <xs:attribute name="lang" type="xs:string" use="optional"/> <xs:attribute name="country" type="xs:string" use="optional"/> <xs:attribute name="messages" type="xs:string" use="optional"/> <xs:attribute name="language_direction"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:enumeration value="ltr"/> <xs:enumeration value="rtl"/> </xs:restriction> </xs:simpleType> </xs:attribute> </xs:complexType> </xs:element> <xs:element name="Link"> <xs:complexType> <xs:attribute name="href" type="xs:string" use="required"/> <xs:attribute name="rel" type="xs:string" use="required"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:enumeration value="gadgets.help"/> <xs:enumeration value="gadgets.support"/> <xs:enumeration value="icon"/> </xs:restriction> </xs:simpleType> </xs:attribute> </xs:complexType> </xs:element> <xs:element name="OAuth" minOccurs="0" maxOccurs="1"> <xs:complexType> <xs:sequence> <xs:element name="Service" maxOccurs="unbounded"> <xs:complexType> <xs:sequence> <xs:element name="Request" type="OAuthResourceType" minOccurs="0"/> <xs:element name="Access" type="OAuthResourceType" minOccurs="0"/> <xs:element name="Authorization" minOccurs="0"> <xs:complexType> <xs:attribute name="url" type="xs:string" use="required"/> </xs:complexType> </xs:element> </xs:sequence> </xs:complexType> </xs:element> </xs:sequence> <xs:attribute name="name" type="xs:string" use="optional"/> </xs:complexType> </xs:element> </xs:choice> <xs:attribute name="title" type="xs:string" use="optional"/> <xs:attribute name="title_url" type="xs:string" use="optional"/> <xs:attribute name="description" type="xs:string" use="optional"/> <xs:attribute name="author" type="xs:string" use="optional"/> <xs:attribute name="author_email" type="xs:string" use="optional"/> <xs:attribute name="screenshot" type="xs:string" use="optional"/> <xs:attribute name="thumbnail" type="xs:string" use="optional"/> <xs:attribute name="directory_title" type="xs:string" use="optional"/> <xs:attribute name="author_affiliation" type="xs:string" use="optional"/> <xs:attribute name="author_location" type="xs:string" use="optional"/> <xs:attribute name="author_photo" type="xs:string" use="optional"/> <xs:attribute name="author_aboutme" type="xs:string" use="optional"/> <xs:attribute name="author_quote" type="xs:string" use="optional"/> <xs:attribute name="author_link" type="xs:string" use="optional"/> <xs:attribute name="show_stats" type="xs:boolean" use="optional"/> <xs:attribute name="show_in_directory" type="xs:boolean" use="optional"/> <xs:attribute name="string" type="xs:string" use="optional"/> <xs:attribute name="width" type="xs:int" use="optional"/> <xs:attribute name="height" type="xs:int" use="optional"/> <xs:attribute name="category" type="xs:string" use="optional"/> <xs:attribute name="category2" type="xs:string" use="optional"/> <xs:attribute name="singleton" type="xs:boolean" use="optional"/> <xs:attribute name="render_inline" type="xs:string" use="optional"/> <xs:attribute name="scaling" type="xs:boolean" use="optional"/> <xs:attribute name="scrolling" type="xs:boolean" use="optional"/> </xs:complexType> </xs:element> <xs:element name="UserPref" minOccurs="0" maxOccurs="unbounded"> <xs:complexType> <xs:sequence> <xs:element name="EnumValue" minOccurs="0" maxOccurs="unbounded"> <xs:complexType> <xs:attribute name="value" type="xs:string" use="required"/> <xs:attribute name="display_value" type="xs:string" use="optional"/> </xs:complexType> </xs:element> </xs:sequence> <xs:attribute name="name" type="xs:string" use="required"/> <xs:attribute name="display_name" type="xs:string" use="optional"/> <xs:attribute name="default_value" type="xs:string" use="optional"/> <xs:attribute name="required" type="xs:string" use="optional"/> <xs:attribute name="datatype" default="string"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:enumeration value="string"/> <xs:enumeration value="hidden"/> <xs:enumeration value="bool"/> <xs:enumeration value="enum"/> <xs:enumeration value="list"/> <xs:enumeration value="number"/> <xs:enumeration value="location"/> </xs:restriction> </xs:simpleType> </xs:attribute> <xs:attribute name="urlparam" type="xs:string" use="optional"/> <xs:attribute name="autocomplete_url" type="xs:string" use="optional"/> <xs:attribute name="num_minval" type="xs:double" use="optional"/> <xs:attribute name="num_maxval" type="xs:double" use="optional"/> <xs:attribute name="str_maxlen" type="xs:int" use="optional"/> <xs:attribute name="restrict_to_completions" type="xs:boolean" use="optional"/> <xs:attribute name="prefix_match" type="xs:boolean" use="optional"/> <xs:attribute name="publish" type="xs:boolean" use="optional"/> <xs:attribute name="listen" type="xs:boolean" use="optional"/> <xs:attribute name="on_change" type="xs:string" use="optional"/> <xs:attribute name="group" type="xs:string" use="optional"/> </xs:complexType> </xs:element> <xs:element name="Content" minOccurs="1" maxOccurs="unbounded"> <xs:complexType> <xs:simpleContent> <xs:extension base="xs:string"> <xs:attribute name="type" use="optional" default="html"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:enumeration value="html"/> <xs:enumeration value="url"/> <xs:enumeration value="html-inline"/> </xs:restriction> </xs:simpleType> </xs:attribute> <xs:attribute name="href" type="xs:string" use="optional"/> <xs:attribute name="view" type="xs:string" use="optional"/> <xs:attribute name="preferred_height" type="xs:integer" use="optional"/> <xs:attribute name="preferred_width" type="xs:integer" use="optional"/> </xs:extension> </xs:simpleContent> </xs:complexType> </xs:element> </xs:sequence> </xs:complexType> </xs:element> <xs:complexType name="GadgetFeatureType"> <xs:sequence> <xs:element name="Param" minOccurs="0" maxOccurs="unbounded"> <xs:complexType> <xs:simpleContent> <xs:extension base="xs:string"> <xs:attribute name="name" type="xs:string" use="required"/> </xs:extension> </xs:simpleContent> </xs:complexType> </xs:element> </xs:sequence> <xs:attribute name="feature" type="xs:string" use="required"/> </xs:complexType> <xs:complexType name="OAuthResourceType"> <xs:attribute name="url" type="xs:string" use="required"/> <xs:attribute name="method" use="optional" default="GET"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:enumeration value="GET"/> <xs:enumeration value="POST"/> </xs:restriction> </xs:simpleType> </xs:attribute> <xs:attribute name="param_location" use="optional" default="header"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:enumeration value="header"/> <xs:enumeration value="url"/> <xs:enumeration value="body"/> </xs:restriction> </xs:simpleType> </xs:attribute> </xs:complexType> </xs:schema>

<?xml version="1.0"?> <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"> <xs:element name="Module"> <xs:complexType> <xs:sequence> <xs:element name="ModulePrefs" minOccurs="0"> <xs:complexType> <xs:choice minOccurs="0" maxOccurs="unbounded"> <xs:element name="Require" type="GadgetFeatureType"/> <xs:element name="Optional" type="GadgetFeatureType"/> <xs:element name="Preload"> <xs:complexType> <xs:attribute name="href" type="xs:string" use="required"/> <xs:attribute name="authz" default="none"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:enumeration value="none"/> <xs:enumeration value="signed"/> <xs:enumeration value="oauth"/> </xs:restriction> </xs:simpleType> </xs:attribute> <xs:attribute name="sign_owner" type="xs:boolean" default="true"/> <xs:attribute name="sign_viewer" type="xs:boolean" default="true"/> <xs:attribute name="views" type="xs:string" use="optional"/> <xs:attribute name="oauth_service_name" type="xs:string" use="optional"/> <xs:attribute name="oauth_token_name" type="xs:string" use="optional"/> <xs:attribute name="oauth_request_token" type="xs:string" use="optional"/> <xs:attribute name="oauth_request_token_secret" type="xs:string" use="optional"/> </xs:complexType> </xs:element> <xs:element name="Icon"> <xs:complexType> <xs:simpleContent> <xs:extension base="xs:string"> <xs:attribute name="mode"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:enumeration value="base64"/> </xs:restriction> </xs:simpleType> </xs:attribute> <xs:attribute name="type" type="xs:string"/> </xs:extension> </xs:simpleContent> </xs:complexType> </xs:element> <xs:element name="Locale"> <xs:complexType> <xs:sequence> <xs:element name="msg" minOccurs="0" maxOccurs="unbounded"> <xs:complexType> <xs:simpleContent> <xs:extension base="xs:string"> <xs:attribute name="name" type="xs:string" use="required"/> <xs:attribute name="desc" type="xs:string" use="optional"/> </xs:extension> </xs:simpleContent> </xs:complexType> </xs:element> </xs:sequence> <xs:attribute name="lang" type="xs:string" use="optional"/> <xs:attribute name="country" type="xs:string" use="optional"/> <xs:attribute name="messages" type="xs:string" use="optional"/> <xs:attribute name="language_direction"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:enumeration value="ltr"/> <xs:enumeration value="rtl"/> </xs:restriction> </xs:simpleType> </xs:attribute> </xs:complexType> </xs:element> <xs:element name="Link"> <xs:complexType> <xs:attribute name="href" type="xs:string" use="required"/> <xs:attribute name="rel" type="xs:string" use="required"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:enumeration value="gadgets.help"/> <xs:enumeration value="gadgets.support"/> <xs:enumeration value="icon"/> </xs:restriction> </xs:simpleType> </xs:attribute> </xs:complexType> </xs:element> <xs:element name="OAuth" minOccurs="0" maxOccurs="1"> <xs:complexType> <xs:sequence> <xs:element name="Service" maxOccurs="unbounded"> <xs:complexType> <xs:sequence> <xs:element name="Request" type="OAuthResourceType" minOccurs="0"/> <xs:element name="Access" type="OAuthResourceType" minOccurs="0"/> <xs:element name="Authorization" minOccurs="0"> <xs:complexType> <xs:attribute name="url" type="xs:string" use="required"/> </xs:complexType> </xs:element> </xs:sequence> </xs:complexType> </xs:element> </xs:sequence> <xs:element name="Rating"> <xs:complexType> <xs:attribute name="scheme" type="xs:anyURI" use="optional" default=""/> </xs:complexType> </xs:element> <xs:attribute name="name" type="xs:string" use="optional"/> </xs:complexType> </xs:element> </xs:choice> <xs:attribute name="title" type="xs:string" use="optional"/> <xs:attribute name="title_url" type="xs:string" use="optional"/> <xs:attribute name="description" type="xs:string" use="optional"/> <xs:attribute name="author" type="xs:string" use="optional"/> <xs:attribute name="author_email" type="xs:string" use="optional"/> <xs:attribute name="screenshot" type="xs:string" use="optional"/> <xs:attribute name="thumbnail" type="xs:string" use="optional"/> </xs:complexType> </xs:element> <xs:element name="UserPref" minOccurs="0" maxOccurs="unbounded"> <xs:complexType> <xs:sequence> <xs:element name="EnumValue" minOccurs="0" maxOccurs="unbounded"> <xs:complexType> <xs:attribute name="value" type="xs:string" use="required"/> <xs:attribute name="display_value" type="xs:string" use="optional"/> </xs:complexType> </xs:element> </xs:sequence> <xs:attribute name="name" type="xs:string" use="required"/> <xs:attribute name="display_name" type="xs:string" use="optional"/> <xs:attribute name="default_value" type="xs:string" use="optional"/> <xs:attribute name="required" type="xs:string" use="optional"/> <xs:attribute name="datatype" default="string"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:enumeration value="string"/> <xs:enumeration value="hidden"/> <xs:enumeration value="bool"/> <xs:enumeration value="enum"/> <xs:enumeration value="list"/> <xs:enumeration value="number"/> </xs:restriction> </xs:simpleType> </xs:attribute> </xs:complexType> </xs:element> <xs:element name="Content" minOccurs="1" maxOccurs="unbounded"> <xs:complexType> <xs:simpleContent> <xs:extension base="xs:string"> <xs:attribute name="type" use="optional" default="html"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:enumeration value="html"/> <xs:enumeration value="url"/> </xs:restriction> </xs:simpleType> </xs:attribute> <xs:attribute name="href" type="xs:string" use="optional"/> <xs:attribute name="view" type="xs:string" use="optional"/> <xs:attribute name="preferred_height" type="xs:integer" use="optional"/> <xs:attribute name="preferred_width" type="xs:integer" use="optional"/> </xs:extension> </xs:simpleContent> </xs:complexType> </xs:element> </xs:sequence> </xs:complexType> </xs:element> <xs:complexType name="GadgetFeatureType"> <xs:sequence> <xs:element name="Param" minOccurs="0" maxOccurs="unbounded"> <xs:complexType> <xs:simpleContent> <xs:extension base="xs:string"> <xs:attribute name="name" type="xs:string" use="required"/> </xs:extension> </xs:simpleContent> </xs:complexType> </xs:element> </xs:sequence> <xs:attribute name="feature" type="xs:string" use="required"/> </xs:complexType> <xs:complexType name="OAuthResourceType"> <xs:attribute name="url" type="xs:string" use="required"/> <xs:attribute name="method" use="optional" default="GET"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:enumeration value="GET"/> <xs:enumeration value="POST"/> </xs:restriction> </xs:simpleType> </xs:attribute> <xs:attribute name="param_location" use="optional" default="auth-header"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:enumeration value="auth-header"/> <xs:enumeration value="uri-query"/> <xs:enumeration value="post-body"/> </xs:restriction> </xs:simpleType> </xs:attribute> </xs:complexType> </xs:schema>

<?xml version="1.0"?> <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"> <xs:element name="messagebundle"> <xs:complexType> <xs:sequence> <xs:element name="msg" minOccurs="0" maxOccurs="unbounded"> <xs:complexType> <xs:simpleContent> <xs:extension base="xs:string"> <xs:attribute name="name" type="xs:string" use="required"/> <xs:attribute name="desc" type="xs:string" use="optional"/> </xs:extension> </xs:simpleContent> </xs:complexType> </xs:element> </xs:sequence> </xs:complexType> </xs:element> </xs:schema>

Harvard University IBM UC Irvine Compaq/W3C Compaq W3C/MIT Xerox Microsoft W3C/MIT University of Edinburgh Oracle Corporation Commerce One Lotus Development Corporation OAuth Core Workgroup