Download MacGudu_wdgt 1.0

Posted : admin On 1/25/2022

W3C Working Draft 14 April 2008

  1. Download MacGudu_wdgt 1.0 For Pc
  2. Download MacGudu_wdgt 1.0 Crack
This version:
Latest version:
Latest Editor's Draft:
Previous version:
Version history:
Twitter messages (non-editorial changes only): (RSS)
Marcos Caceres, Invited Expert

Copyright © 2008 W3C® (MIT, ERCIM,Keio), All Rights Reserved. W3C liability, trademark and document use rulesapply.

Download MacGudu_wdgt 1.0 For Pc

Item model number ‏: ‎ DVF01F1L01-404. Department ‏: ‎ Men. Manufacturer ‏: ‎ Diverse. Item Weight ‏: ‎ 250 g. Generic Name ‏: ‎ Formal Shirt. Amazon Bestsellers Rank: #78,780 in Clothing & Accessories ( See Top 100 in Clothing & Accessories) #1172 in Men's Formal Shirts. Customer Reviews: 3.8 out of 5 stars. New episode weekly You have never been this close to Borussia Dortmund. In this 4-part docu-series, go behind-the-scenes with one of the Bundesliga’s biggest clubs and re-live the thrilling 2018/19 football season from the team’s point of view. New episode weekly You have never been this close to Borussia Dortmund. In this 4-part docu-series, go behind-the-scenes with one of the Bundesliga’s biggest clubs and re-live the thrilling 2018/19 football season from the team’s point of view. Copy the new InfosemanticsCpExtra.wdgt file. Navigate to where you stored your old InfosemanticsCpExtra.wdgt file. Paste the new InfosemanticsCpExtra.wdgt over the old one. Open up your Captivate project. Navigate to the slide that contains the widget. Right click on the widget and pick Update from the context menu.


This document surveys a group of market-leading widget user agents with the aim toinform the requirements of the Widgets 1.0: Requirements document. Thesurvey exposes commonalities and fragmentation across widget user agents, and discusseshow fragmentation currently affects, amongst other things, authoring, security,distribution and deployment, internationalisation and the device-independence of widgets.The document concludes by making a set of recommendations on what aspects of widgetsrequire standardization to reduce fragmentation to ultimately standardize across-platform widget solution.

Status of this Document

This section describes the status of this document at the time of its publication.Other documents may supersede this document. A list of current W3C publications and thelatest revision of this technical report can be found in the W3C technical reports index at

This is the W3CFirst Public Working Draft of the Widgets 1.0: Landscape. Once all thecomments about this document will have been addressed, the Working Group intends topublish a final version of this document as a W3C Working Group Note.

The W3C Membership and other interested parties are invited to send comments [email protected], the W3C's publicemail list for issues related to Web Application Formats. Archives of the list areavailable.

This document is produced by the WebApplication Formats WG, part of the Rich Web Clients Activity in the W3C Interaction Domain. It is expected that thisdocument will become a Working Group Note. Publication as a Working Draft does not implyendorsement by the W3C Membership. This is a draft document and may be updated, replacedor obsoleted by other documents at any time. It is inappropriate to cite this document asother than work in progress.

This document was produced by a group operating under the 5 February 2004 W3C PatentPolicy. W3C maintains a public list of any patent disclosures made in connection with thedeliverables of the group; that page also includes instructions for disclosing a patent.An individual who has actual knowledge of a patent which the individual believes containsEssentialClaim(s) must disclose the information in accordance with section 6 of theW3C Patent Policy.

Table of Contents

  • 1. Introduction
  • 3. Widgets and Widget User Agents
  • 4. Packaging for Distribution andDeployment
  • 5. Metadata and Configuration
    • 5.1 Metadata
  • 6. Authoring and Scripting
  • References

1. Introduction

This document surveys the widget landscape by examining how market-leading widget user agents address issues around:

  • distribution and deployment,
  • metadata and configuration,
  • user interface and accessibility,
  • authoring,
  • internationalization and localization,
  • device-independence,
  • Initialization,
  • automatic updates,
  • and security.

The market-leading widget user agents thatare included in the survey are listed below. The widget useragents were subjectively chosen because of their perceived prevalence in themarket place. This survey was conducted independently of any vendor and novendor explicitly requested they be included in the survey.

Widget user agent:
The user agent (software application) that hosts an instantiated widget. Generallyspeaking, widget user agents are either directly built on, or provide similarfunctionality to a Web browser. An increasing number are actually built directly on topof Web browsers so they are able to process/render HTMLdocuments, while others incorporate Web browser components like ECMAScript interpreters.widget user agents are built for many different software platforms and devices, includingMicrosoft's Windows, Apple's MacOS, Symbian, Linux, and so on; and some widget useragents, such as the Konfabulator and Opera Widgets, run on multiple platforms.
Instantiated widget:
The runtime manifestation of a decompressed widget resource whose start file has beeninstantiated on a widget user agent. The instantiated widget may have been configuredthrough a configuration document. The ability for an instantiated widget to be programmedand behave interactively is provided via a widgets API.
An image or symbolic representation of an instantiated widget. Icons are usually usedto represent the widget in non-running context, such as menus and docks. Some widget useragents, such as Konfabulator, allow authors to dynamically change the icon at runtime.For example, a weather widget might update its icon as the weather or time of daychanges.
Widget resource:
A resource created from some packaging format that encapsulates the resources of awidget for the purposes of distribution and deployment. On the wire, a widget resource isidentified by an arbitrary widget media type.
Media type:
An media type that formally associates a widgetresource with some proprietary widget user agent. For example, Joost's widget enginesrequires that widgets be served over HTTP with aapplication/vnd.joost.joda-archive media type.
Packaging format:
The physical data format used to create a widget resource. For example, the flat-fileformat described in the Konfabulator Referenceor the Zip file format supported by Opera Widgets andMicrosoft's Vista Sidebar.
Any file or directory used by an instantiated widget that resides either inside awidget resource or is accessible over HTTP. In a widget resource, resourcesmay be organized in directories and may have versions of those directories tailored forlocalization purposes. Examples of resources include images, text, markup, style sheets,executable scripts, and sounds.
Start file:
A resource either inside the widget resource or on the Web that when instantiatedrepresents the widget. If an instantiated widget contains a configuration document, thewidget user agent may configure the start file through that configuration document.
Configuration document:
A distinguished resource where authors can declare metadata and/or configurationparameters for a widget. A widget user agent uses a configuration document to configure awidget upon instantiation. The configuration document may also define the relationshipbetween resources in the widget resource. The configuration document usually takes theform of an XML file; for example, theconfig.xml resource bundled with an Opera widget.
Data declared in the configuration document about a widget that relates to authorshipor classification, but does not affect the behavior of the widget at runtime (eg. theauthor's name and email).
Configuration parameter:
Any declaration in the configuration document that affords the widget withfunctionality beyond its default behavior (eg. declaring that the widget will requirenetwork access).
A mechanism that either declaratively or automatically finds the start file in aninstantiated widget.
Widget API:
A set of programming interfaces that provide functionality specific to andinstantiated widget. Current APIs range extensively in the level of functionality theyprovide an author; see for example Microsoft's API for accessing the operating system in theSidebar Reference.

3. Widgets and Widget User Agents

Since around 2003, a relatively new kind of application has seen significantproliferation onto desktop computers and, more recently, web-enabled portable deviceslike mobile phones. This kind of application is generally referred to by developers as awidget engine: a piece of software that is able to run other smallerapplications known as widgets or gadgets. On the user's desktop,widgets have gradually taken the place of some traditional single-purpose applications.Typical examples of widgets range from simple clocks, CPU gauges, post-it notes, games,battery-life indicators, to more sophisticated web-enabled widgets like weatherforecasters, news readers, email checkers, photo albums and currency converters.
There are literally thousands of unique widgets available for download on the web, whichusers generally collect to create personal widget inventories. These widget inventoriesprovide users with access to online services that they commonly use. This means that, ina lot of instances, users don't need to open up a web browser to get the information thatthey want (eg. to check the weather). This is an aspect of widgets that makes themparticularly attractive on mobile devices, where the monetary cost of downloading webpages is currently an issue for many users.

For developers, some widgets differ from traditional binary applications in that theyare created using the same open technologies used to create web pages. Widget enginesmimic, in many ways, the behavior of web browsers: an increasing number are actuallybuilt directly on top of web browsers so they are able to render web pages, while othersincorporate web browser components such as ECMAScript interpreters. To developers andvendors, this means that most widgets are significantly easier to create thanapplications developed with lower-level programming languages such as Java and C#.

Amidst the popular rise of widgets and widget engines lay a number of issues forusers, developers, current vendors and new vendors wanting to enter the market. Bysurveying various aspects that pertain to widget user agents, this document discussesthese issues so they may be resolved through the W3C standardization process.

As shown in figure 1, a widget is instantiated on a widget user agent and can make useof a number of technologies that serve a different role (eg. distribution and deployment,etc). However, some of those technologies have not yet been formally standardized (itemsmarked with an asterisk), which has contributed to fragmentation across the widgetspace.

Figure 1. A typical widget technology stack and aspects thathave require standardization. Please note that this technology stack is intended as aguide, and does not represent the technology stack of any particular user agent.

3.1 Differences from Web Widgets

Web widgets (also known as modules orbadges) are fragments of HTML, CSS, and ECMAScript (orpossibly an Adobe Flash movie) that are either declaratively or dynamically included intoa Web document. A common example of Web widgets is one that downloads a set of icon-sizedimages from a photo-sharing Web site and displays those images as a slide-show based on aset of user preferences (eg. the images tagged 'vacation Italy'); such Web widgets arecommonly seen embedded into social networking Web sites and blogs. Popular providers ofWeb widgets include:

  • Google Homepage Gadgets (iGoogle Gadgets),
  • WordPress Widgets,
  • and Microsoft Live Gadgets.

Unlike widgets, Web widgets a hosted on the server-side and are embedded into HTMLdocuments prior to being served to the client. The creation of a Web widget usuallyinvolves having an author specify, in XML or some other format (eg. PHP), what the widgetdoes and which APIs the Web widget depends on. This document is then uploaded to aserver, where when it is served to a client, it is transformed into HTML, CSS, andECMAScript. For example, the input column of the table below shows a typical iGooglegadget specification:

iGoogle Gadget Transformation Example

After being processed on the server-side, the code in the input column is transformedto HTML, CSS, and ECMAScript and inserted into the served document as either aniframe or as HTML elements (see the the Output column above). The actualcode that Google generates from the example is too large to be included in thisdocument.

Functional Differences

Because Web widgets and a widget have a reliance of Web technologies, their offer muchof the same functionality. However, differences exist in:

  • the packaging format,
  • the security model,
  • and the APIs.

In relation to the packaging format , Web widgets are generally not packaged ordownloaded as a single file (except in the case of Adobe Flash movies). Instead, Webwidgets are commonly dynamically instantiated through a mix of ECMAScript, HTML elements, andCSS. However,similar to a widget as described in this document, some Web widgets make use of adynamically loaded RSS file or JSON as a configuration document format.

In relation to security models, unlike a widget, Web widgets are generally part of aHTMLdocument's DOM and so are bound to all thesecurity constraints imposed by Web browsers.This means that Web widgets cannot makecross-domain requests, cannot autonomously access resources on an end-user's device,access system-level properties like the make, model, or usage percentage of theCPU, or execute system level commands likecreating or deleting files, while widgets that run on most market-leading widget useragents generally can. In other words, some widget user agents provide a more relaxedsecurity model than the one afforded to Web widgets by Web browsers.

Download macgudu_wdgt 1.0 download

The ability for a widget to perform actions beyond the security scope of Web widgetsis partially afforded by widget-specific APIs. For example, on Windows Vista's Sidebar, awidget can be scripted to create a new folder on the end-user's hard drive by calling'System.Shell.Folder.newFolder(strNewFolderName)'. See Microsoft'sSidebar Reference or Konfabulator Reference for more examples of API functionalitythat is beyond the scope of Web widgets.

Another difference is how widget user agents handle internationalization when comparedto Web widgets (Web Browsers). On the Web, internationalization is sometimes handledthrough HTTP's Accept-Language header: thisworks by allowing the Web Browser to send the end-user's preferred language to a server(eg. Accept-Language: en-us). If the server contains a version of thedesired resource in the end-user's language of choice, then the localized resource may bereturned to the end-user. A widget, on the other hand, may sometimes contained alllocalized resources inside the widget resource in folders named using the commonlanguage-region pattern (eg. /en-us/). When the widget is instantiated, the widget useragent attempts to match one of these specially named folders to user's languagepreferences. See the Internationalization and Localization sectionfor more information.

3.2 Differences from Java Applets

Widgets and Java applets share many commonalities. For instance, both widgets andapplets rely on a pre-installed runtime engine for execution: java applets rely on thepresence of the Java Runtime Environment (JRE), while widgets rely on the presence oftheir target widget engine. Widget and Java applets also share many similar functionalaspects, like being able to do asynchronous HTTP requests to download resources from theWeb.

It is argued that the most notable difference between them is that widgets are easierfor authors to create than Java applets. This argument is made because widgets arecreated using HTML, CSS, and ECMAScript, which have very forgiving error handling and ashort learning curve compared to Java. Another difference is that Java Applets areintended to run inside Web pages, while widgets as described in this document generallyserve the purpose of stand-alone applications that run outside of a Web browser.

4. Packaging for Distribution andDeployment

Packaging refers to encapsulating all the necessaryresources and metadata required by the widget into a single file for the purpose ofdistribution and deployment. Distribution and deploymentrefers to getting a widget from the Web to run on an user's device as easily aspossible.

4.1 Packaging Formats, file extensions andMedia Types

The de facto standard for packaging widgets is the Zip file format, but withvendors requesting that their developers use a vendor specified file extension (ie., but .widget, or .gadget, etc) when packaging their widgets.

Once a widget has been packaged for distribution, it is put onto a web server andserved with an appropriate media type. The purpose of a media type is to allow a browser,for instance, to automatically associate a widget resource with the appropriate widgetuser agent. For example, widgets served for Operas widget engine are served with theapplication/x-opera-widgets media type and associated with the Operabrowser. If a widget engine has correctly registered itself with the operatig system tobe the program of choice to deal with a particular media type media type and/or fileextension with, the web browser should automatically pass widgets to the widget enginewithout the end-user having to select the widget resource manually.

End-users generally acquire widget resources directly from vendors (eg. Apple, Yahoo!)who often host dedicated online galleries where users can search for widgets and wheredevelopers can submit or update widgets they have created. However, authors are free todistribute their widgets from their own web sites.

Packaging Format
The packaging format is supported widgetuser agent.
The compressions algorithm supported by the widget user agent.
File extension
The file extensions that associates a widget with a widget user agent.
Media type
As widgets are generally distributed via the Web, vendorsusually assign them an arbitrary MIME type. The MIME type, which is usually used inconjunction with the file extension, helps a widget user agentassociate the a widget with the appropriate widget useragent.

Interoperable Aspects

  • Zip format
  • Deflate compression

Fragmentation Issues

  • There is no consistent file extension for widgets; each vendor uses their own uniquefile extension.
  • Nowhere is it defined exactly which parts of the Zip specification should besupported by a widget user agent. Zip is a large specification that is constantlyevolving. Zip supports multiple compression algorithms and features. If a widget ispackaged using the wrong compression algorithm, it might not be interoperable withanother widget engine or device. Although the issue of compression is not currently amajor issue, it has the potential to become one as widgets become more prevalent onmobile devices and computers start to work natively in 64-bit.
  • There is no standardized Media Type, which results in widgets served over HTTP beingassociated with only one kind of widget engine. One media type per widget engine resultsin vendor lock-in.

5. Metadata and Configuration

A widget resource will typically include a configuration document, in which an authordeclares metadata and/or some configuration parameters that a widget user agent may useto configure a widget upon instantiation. All market leading widget engines use XML asthe preferred format for storing metadata.

XML vocabulary
The proprietary specification that defines the semantics of the elements andattributes that authors should use when marking up a configuration document.
File name
The name of the file as
Is the configuration document required for the widget user agent to instantiate thewidget. This was tested by attempting to instantiate a widget without a configurationdocument present inside the widget resource.
Does the configuration document require authors to declare a namespace. Also testedusing a bogus namespace on the root element xmlns='
Conforming Parser?
Is the XML parser used by the widget user agent conformant to the XML specificationand XMLNS aware?

Interoperable Aspects

  • XML is the preferred format for structuring metadata.

Fragmentation Issues

  • The XML dialects are all different.
  • XML parsers are generally non-conforming to the XML and XMLNS specifications.

5.1 Metadata

Metadata refers to how authors store information about their widget inside the widget,and how that data is made accessible to people or machines.

In practice, the inclusion of any metadata elements is generally considered optionalbut is nonetheless recommended by vendors. Widget user agents generally make use ofmetadata elements in different application contexts such as menus, lists, andabout-boxes. The most common metadata elements captured in configuration documentsinclude:

Root element:
The element found at the root of each configuration document, which contains allother elements in the document.
The human readable name of the widget as it appears in menus or other contexts.
Unique identifier:
An author assigned unique identifier for the widget.
Version identifier:
Some string that identifies the version of the widget.
A human readable description of the widget, generally describing what it does.
Copyright information.
information about the authorship of the widget, including the author's name, email,and the organization that they may be affiliated with
Nokia Web-Runtime<plist version='1.0'><key>CFBundleDisplayName</key><string>text</string><key>Identifier</key>
Joost Widgets<widget-manifest><name>text</name><id>URI</id>none.

*Although care has been take to ensure the accuracy of theinformation contained in this table, there is no guarantee that the information iscomplete, correct, or up-to-date. To obtain authoritative information about anyparticular widget user agent, please visit the vendor's web site.

Windows Vista Sidebar<description>Text</description><author name='> <info url='URL'/> <logo src='rel-path'/></author><copyright>text</copyright>
Google Desktop<description>Text</description><author>text</author> <authorEmail>text</authorEmai><authorWebsite>URL </authorWebsite><copyright>text</copyright>
Opera Widgets<description>Text</description><author> <name>text</name> <email>text</email><link>text</link> <organization>text</organization></author>none.
Apple Dashboardnone.none.none.
Nokia Web-Runtimenone.none.none.
Joost Widgetsnone.<web site.>URI</web site.>none. Often included as an xml comment inside the configuration document.

*Although care has been take to ensure the accuracy of theinformation contained in this table, there is no guarantee that the information iscomplete, correct, or up-to-date. To obtain authoritative information about anyparticular widget user agent, please visit the vendor's web site.

Interoperable Aspects

  • Although element names differ, the semantics captured by elements is relativelyconsistent.

5.1.1 Fragmentation Issues

  • There some fragmentation in regards to recording the description, authorshipinformation and copyright.

Configuration parameters

The most common configuration parameters include:

A way to identify the start file (or main content), including a way to identify thecontent type of the start file (eg. type='HTML').
The need for a widget to access the network.
Width and height:
The initial rendering dimensions (width, height).
The intention to use plugins (eg. Flash and Java).
The minimum version of the widget user agent required to run the widget.

Please note that some configuration parameters have a close relationship to thesecurity model of widgets.

none.<platform minVersion='n.n' os='macintosh windows'/>
Windows Sidebar<host> <base type='HTML' src='rel-path/file' /></host>none.none. Allowed by default.none. Allowed by default.<host name='sidebar'> <platform minPlatformVersion ='n.n'/></host>
Google DesktopNot declared. Root of container must have a 'main.xml' file which serves as the startfile.none.none. Allowed by default.none.<gadget minimumGoogleDesktopVersion='n.n.n.n'>
<windows minimumGadgetHostVersion='n.n.n.n'/>
<mac minimumGadgetHostVersion='n.n.n.n'/>
Opera WidgetsNone. The start file must be called 'index.html' and must be at the root of thearchive.<width>n</width> <height>n</height><security> <access><protocol>http ftp</protocol><host>IP Address domain name</host> <port>integer integer-range(eg1200-1500)</port></access> </security><content><plugins>yes no</plugins><java>yes no</java></content>
Apple Dashboard<key>MainHTML</key><string>rel-path/any.html</string>

<key>Width</key> <integer>n</integer><key>Height</key> <integer>n</integer>

When not present, the width and height of Default.png is used.

<key>AllowFullAccess</key> <true false/>
Nokia Web-Runtime<key>MainHTML</key><string>rel-path/any.html</string><key>AllowNetworkAccess</key> <true false/><key>AllowFullAccess</key> <true false/>none.
Joost Widgets<main-file>rel-path/a.[jwl,html,svg]</main-file><key>AllowNetworkAccess</key> <true false/><key>AllowInternetPlugins</key> <true false/>

*Although care has been take to ensure the accuracy of theinformation contained in this table, there is no guarantee that the information iscomplete, correct, or up-to-date. To obtain authoritative information about anyparticular widget user agent, please visit the vendor's web site.

Interoperable Aspects


Fragmentation Issues


Download MacGudu_wdgt 1.0 Crack

6. Authoring and Scripting

Authoring refers to how widgets are created, marked-up andscripted. In terms of authoring, there is a fairly congruent set of commonalities thatmost widget user agents share, and which authors exploit when authoring a widget: mainlytheir reliance on Web standards and protocols, and a strong focus on rapid development.Most widget user agents will typically support HTTP, IRIs, andUnicode, as well as ECMAScript, the DOM,and the ability to render markup languages, like HTML and CSS. Widget user agentsalso generally support multimedia resources, such as images, sounds, and some evenvideo.

To make authoring of widgets possible, widget user agents provide authors withApplication Programming Interfaces (APIs) that are mostly identical to thosefound in Web browsers, as well as APIs that provide functionality that isspecific to widgets. Also, because of the rise in popularity of Ajax-style development, many widget user agents now implement theXMLHttpRequest object or some similarmechanism for making asynchronous data requests over HTTP.

explain functionality exclusively available to widgets (run programs,cross domain requests)

Interoperable Aspects

  • All widget user agents support XMLHttpRequest.
  • All but one support HTML and CSS as layout

Fragmentation Issues

  • There is some limited fragmantation is regards to support of proprietarytechnologies, such as Flash.

6.1 APIs


Open page in browser
Open a web document in the standard system browser
Get, set and delete user preferences
Close widget
Destroy instance of currently running widget
or using javascript within the document:
System.Gadget.Settings.write(String name, Object Value)
System.Gadget.Settings.writeString(String name, String Value)
Google Desktopno method, use <a href='> element
Opera WidgetsopenURL(String url)widget.setPreferenceForKey(preference, key)
setPreferenceForKey(String preference, null)
Apple DashboardopenURL(String url)widget.setPreferenceForKey(preference, key)
setPreferenceForKey(String preference, null)
Nokia Web RuntimeopenURL(String url)

widget.setPreferenceForKey(preference, key)
setPreferenceForKey(String preference,null)

Joost Widgetsnavigate(String url);widget.setString(String name, String vlaue);

*Although care has been take to ensure the accuracy of theinformation contained in this table, there is no guarantee that the information iscomplete, correct, or up-to-date. To obtain authoritative information about anyparticular widget user agent, please visit the vendor's web site.

Interoperable Aspects


Fragmentation Issues


6.2 Widget object: properties and events

6.2.1 Properties of theWidget object

KonfabulatorWindows SidebarGoogle DesktopOpera WidgetsApple DashboardNokia Web-RuntimeJoost Widgets
locale informationlocalewindow.navigator.languagewindow.navigator.language
Engine version needed to runrequiredEngineVersionSystem.Gadget.platformVersion
If the widget is visiblevisibleSystem.Gadget.visible
The version of the widget as specified in the configuration documentversionSystem.Gadget.version
The name of the widget as specified in the configuration
The details of the author as specified in the configuration document

The copyright declaration as in the configuration documentwidget.copyright
Access the unique identifier for the widget

String widget.identifier

This read-only property contains a stringvalue that is unique among all of the instances of a single widget. This value isassigned by Dashboard and persists between instantiations of each widget instance.

string widget.identifier;

requiredPlatformDocument, opacity, path, settingsUI, docked, background

*Although care has been take to ensure the accuracy of theinformation contained in this table, there is no guarantee that the information iscomplete, correct, or up-to-date. To obtain authoritative information about anyparticular widget user agent, please visit the vendor's web site.

6.2.2 Events


KonfabulatorWindows SidebarGoogle DesktopOpera WidgetsApple DashboardNokia Web-RuntimeJoost Widgets
Widget has loadedwidget.onLoad
WUA has focuswidget.onshow
WUA lost focuswidget.onhide
Widget focuswidget.onGainFocuswindow.onfocus
Widget lost focuswidget.onLoseFocuswindow.onblur
Widget drag startwidget.onMouseDragwidget.ondragstart
Widget is being dragged
Widget drag endwidget.ondragend
Widget is removed from WUAwidget.onUnloadwidget.onremove
Cross widget communicationwidget.onTellWidget = function(){ }
OtherdockOpen onDockClosed onDockOpened onPreferencesChanged onRunCommandInBgCompleteonScreenChanged onTellWidget onWakeFromSleep onWillChangePreferences

*Although care has been take to ensure the accuracy of theinformation contained in this table, there is no guarantee that the information iscomplete, correct, or up-to-date. To obtain authoritative information about anyparticular widget user agent, please visit the vendor's web site.

Accessing the file system

Download macgudu_wdgt 1.00


Execute system level commands or open applications.

Interoperable Aspects


Fragmentation Issues


7. User interface andAccessibility

Accessibility refers to how end-users, and those withspecial needs, can access the content and use the interactive elements of an instantiatedwidget. Most market-leading widget user agents allow widgets to be authored usingHTML, CSS, andECMAScript. HTML,when authored with care, is generally regarded to be an accessible technology whosestructure and semantics are generally well understood and correctly implemented by mostmarket-leading widget user agents. To extend It is also therefore theoretically possiblefor authors to make their widgets fairly accessible by applying, for example, therelevant sections of the Web Content Accessibility Guidelines (WCAG).

Interoperable Aspects


Fragmentation Issues



8. Instantiation

What addressing mechanism does the widget user agent support at runtime to getto resources inside the package? (ie. how does a developer address and include thingslike images or sounds in their widget?)

TBW: discusses different ways that the start file of widget is located:1. having a preset name (eg. index.html ala Opera Widgets). Having it declared in theconfiguration document (ala Joost), Having it match a search pattern (alaKonfabulator)

Interoperable Aspects


Fragmentation Issues


9. Internationalization and Localization

internationalization refers to the technicalaspects that allow a widget to work in multilingual contexts without requiring anauthor to make significant engineering changes to a widget.Localization is the processes where by a widget is adapted to usethe local conventions of particular end-users (eg. using a particular dialect). Toallow authors to distribute a widget to multiple locales, the majority of vendors provideguidelines explain to authors how to make effective use of internationalizationmechanisms built into widget user agents. When authors follow localization guidelines, awidget user agent can use automated mechanisms to select the appropriate localizedresources for a widget based on a system's locale information; thus making it easier forauthors to create localized widgets.

In the widget space, internationalization is commonly achieved in one of two ways:

  • One way is to have authors place localized resources into specifically named foldersthat identify the language and region (eg. '/en-au/' for English Australian)of localized content. If the widget user agent can identify the end-user's locale, andthe widget package contains matching localized content, then a localized widget will bepresented to the end-user.
  • Another way is to have authors place localized textual content inside a specificallynamed text file, which is in turn placed inside specially named folders (eg.'/en-au/Localizable.strings'). Inside the text file, localized strings areidentified by an unique identifier and must be formatted using a special syntax. Forinstance, Konfabulator uses a special syntax for localizing strings, for example:

Note that this method only localizes textual content, but can be used to also identifythe path or URI to localized resources. At runtime, the widget user agent makes thoselocalized strings available via a scripting interface:

When automated internationalization is not provided by a widget user agent, authorsusually result to using arbitrary solutions to achieve localization. Such is the case forOpera widgets.

Interoperable Aspects


Fragmentation Issues


10. Digital Signatures

A digital signature is the product of applying a secretnumeric key (known as a private key) and an encryption algorithm over some datato produce a unique hash value. The only way to validate a digital signature isto use a corresponding public key in a process known as asymmetriccryptography.

Although not widely supported by market-leading widget user agents, some widget useragents allow an author to digitally sign a widget resource. Digitally signing a widgetresource involves calculating the hash values of all the resources inside the widgetresource and encrypting those values using a unique private key that is known only to theauthor. The resulting data is bundled inside the widget resource with a digitalcertificate, which an author can obtain from a certification authority (such as VeriSign) for a charge.

A digital certificate is therefore a trust mechanism intended to verify to a user thatan author really did sign the widget resource. A widget user agent can use the digitalcertificate to verify the authenticity and data integrity of the widget resource. In therare case where a widget damages the end-user's device, the digital certificate providesa user with a legal means to prove that a widget resource was signed by a particularauthor or publisher.

Because digital certificates can come from untrusted sources, widget user agents willinclude root certificates from sources that it trusts. Root certificates areexplicitly trusted and are considered impossible to forge. For example, the Konfabulatoris bundled with the Yahoo! root certificate which it uses to verify widgets signed byYahoo! Inc. are in fact signed by Yahoo! Inc.

Interoperable Aspects

  • The use of X509 certificates.

Fragmentation Issues

  • General lack of support for digital signatures.

11. Automatic Updates

Automatic updates refers to a service that allows a widgetuser agent to automatically check if a new or different version of an installed widgetresource has become available, and somehow acquire the new version and install it.Automatic updates models work by allowing authors to assign a unique identifier andversion identifier to a widget resource (eg. id=''version='1.2').

To keep a widget resource up to date, the widget user agent periodically checks if adifferent version of a widget resource has become available on a remote server. In thecase of the Konfabulator, it does this by sending an XML document that identifies the widgetvia an unique identifier, and what version the end-user currently has installed. If a newversion of the widget resource is available on the server, the server sends back anXML filethat contains a URL from where the widget user agent can acquire the latest version. Thewidget user agent then informs the end-user that an update to a widget has becomeavailable and if they want to perform the update. If the end-user agrees, then the widgetuser agent downloads the latest version of the widget resource, archives the old version,installs the new one in its place. The updated widget is re-instantiated with itspreexisting preferences (eg. an updated weather forecaster widget will generally notrequire the end-user to re-input their preferred city after an update).

Download macgudu_wdgt 1.0 download

Interoperable Aspects

Download MacGudu_wdgt 1.0


Fragmentation Issues

  • General lack of support for automatic updates.

12. Device Independence

Need to read up on how Nokia Web Runtime recommends authors deal withmigration of Dashboard widgets, etc.

Interoperable Aspects


Fragmentation Issues


13. Security Models

Security model refers to the security policies under which awidget user agent operates that either prevents or allows an instantiated widget fromperforming particular actions (eg. accessing the network or reading/writing files). Whencompared to Web browsers, some market-leading widget user agents have a comparativelyrelaxed security model that allows an instantiated widget to read, write, modify, and/ordelete files, automatically upload files, automatically download files, execute localapplications, and even perform cross-domain request to 'mash-up' data from multipledifferent sources. All without the end-user having any indication that their privacy andsecurity might be at risk.

The ability to perform most of the aforementioned actions is strictly forbidden indocuments running in Web Browsers. Such a relaxed security model has been generallypositive in the widget space with very useful and powerful widgets being developed.However, this has created an environment where users are left extremely vulnerable tomalicious attacks, and serious security risks have been demonstrated. Some market-leadingwidget user agents, such as Opera Widgets, have a much tighter security model thatadheres more closely to the security model of a Web Browser; as such, they may be lessprone to serious security issues.

Need to discuss how security declarations are made using pInfo list orOpera's security element.

Interoperable Aspects


Fragmentation Issues


14. Icons


Two images may be declared, depending on the usage attribute. Theusage attribute allows either values docksecurityto indicate where the image should be used. Security image is shown as part of the widgetsecurity warning when the widget is instantiated.

Windows Vista Sidebar

<icons> <icon src='rel-path' [width=' height=']> </icons>

<hosts> <host> <defaultImage src='/> </host>

any GDI+ 1.0 supported format.

Having multiple icon elements allows the engine to select the icon most appropriatefor communication based on size. Preferred size is 64px*64px, but any size is ok.

The documentation contradicts itself in regards to icon and defaultImage.Need to verify which one is actually used!

Google Desktop




Need to test other formats

Opera Widgets


Apple Dashboardnone.PNG

Not declared. An optional icon must appear in the root of the archive and must becalled icon.png. If the icon is missing, then the runtime will use a default icon.

Nokia Web-Runtimenone.PNGPNGinclude an 'icon.png' file at the root of the widget.
Joost Widgets


SVG, PNG, JPEG, GIFSVG or PNG are preferred.

*Although care has been take to ensure the accuracy of theinformation contained in this table, there is no guarantee that the information iscomplete, correct, or up-to-date. To obtain authoritative information about anyparticular widget user agent, please visit the vendor's web site.

This section will describe how icons are used by different widgetengines. It will discuss static icons (images, pngs), and dynamic icons, such as Yahoo!'sicons. Might also talk briefly about iPod/Phone icons here too, as they are dynamic.

Interoperable Aspects

PNG, GIF87/89


Fragmentation Issues


15. Standardizable Aspects ofWidgets

The following list represents the aspects of a widget that members of the workinggroup have identified as requiring standardization to reduce fragmentation in the widgetspace. Aspects that are currently outside the scope of the working group charter areproceeded by the text 'out of scope'. To addressaspects beyond the scope of the working group, the working group will require liaisonwith other working groups at the W3C and possibly other related consortia such as theOMA and the OAA.

Standardizable aspects of widgets include:

  • Finding a suitable packaging format capable of encapsulating and structuringresources for distribution and deployment, including:
    • The relevant technical aspects of the physical packaging format that make the formatinteroperable across multiple platforms and mobile devices.
    • The abstract container, including required parts and hierarchies (eg. required filesand folders, if any).
    • The model by which the internal structure of a widget resource can be exploited by aninstantiated widget for localization purposes in internationalized contexts.
    • A means for an instantiated widget to address resources in a widget resource atruntime.
    • A file extension.
    • A MIME type to formally denote that a widget resource distributed over HTTP conforms to theWidgets 1.0: Packaging specification.
    • A widely supported digital signature format that adequately provides data security,authenticity and non-repudiation.
  • The configuration document language including:
    • The structure, semantics, and processing model for a vocabulary that would make upthe configuration document format.
    • Metadata elements pertaining to authorship (eg. author's name, email, etc).
    • Metadata elements pertaining to the widget (eg. id, title, description, etc).
    • Configuration parameters (eg. width, height, network access, etc).
    • A bootstrap mechanism that allows the widget user agent to find the start file of awidget resource.
    • A model for finding a start file of a widget resource when a bootstrap is unavailableor is in error.
    • A means for distinguishing the configuration document from other resources.
    • A means to declare an alternative representation of a widget (eg. an image icon) forwhen a widget has not been instantiated.
  • A widgets API that could be implemented by a widget user agent and made available toan instantiated widget that would allow authors to:
    • Access preferences particular to each instantiated widget.
    • Access runtime configuration properties and other relevant platform properties(out of scope).
    • Access to services particular to the device on which the widget has been instantiated(eg. camera, short message service, address book, etc) (out ofscope).
    • The ability to instantiate other applications on an end-user's device(out of scope).
    • Access metadata values that the author declared in the configuration document.
    • Capture events and access properties that are particular to each instantiatedwidget.
    • Control alternative runtime representations of a widget (eg. the dockedrepresentation).
  • The security model/policies that determines what an instantiated widget can accesswhile running on a end-user's device.
  • A pre-existing language to declare the user interface in an accessible manner (eg.mandating the use of HTML or some other XML vocabulary).
  • A HTTP-based model for a widget user agentto check if an updated version of a widget resource has become available fordownload.

Standardizable aspects of widget engines include:

  • TBW


The editor would particularly like to thank Corin Edwards for his help on improvingthe design on of figure 1.

The editor would like to thank to the following people who have contributed to thisdocument (ordered by first name):

  • Alexander Dreiling
  • Anne van Kesteren
  • Arthur Barstow
  • Arun Ranganathan
  • Benoit Suzanne
  • Bert Bos
  • Bradford Lassey
  • Cameron McCormack
  • Cliff Schmidt
  • Claudio
  • Coach Wei
  • Corin Edwards
  • Dan Brickley
  • David Pollington
  • Dean Jackson
  • Debra Polson
  • Doug Schepers
  • Ed Voas
  • Gene Vayngrib
  • Guido Grassel
  • Jay Sweeney
  • Jim Ley
  • Jose Manuel Cantera Fonseca
  • Kevin Lawver
  • Krzysztof Maczyński
  • Lachlan Hunt
  • Marc Silbey
  • Mark Baker
  • Mikko Pohja
  • Philipp Heltewig
  • Stephen Paul Weber
  • Thomas Landspurg
  • Yang Wong
  • Zachary Fitz-Walter


Ajax: ANew Approach to Web Applications. J. J. Garrett. February 18, 2005. Adaptive Path.Available at
Apple pList
Introduction to Property List Programming Topics for Core Foundation, Apple ComputerInc, 7 February 2006. Available at
Cascading Style Sheets, level 2, revision1, B. Bos, T. Çelik, I. Hickson, and H. Wium Lie. W3C Candidate Recommendation19 July 2007. Available at
Document Object Model (DOM) Level 1Specification, L. Wood et al., 1 October 1998. Available at
Dashboard Reference
Dashboard Reference, Apple Computer, Inc, May 2006. Available at
Google Gadgets
Google Desktop Sidebar ScriptingAPI, Google Inc., 2006.Available at
The application/json media type forECMAScript Object Notation. D. Crockford. July 2006. Available at
Opera Spec
Opera WidgetsSpecification 1.0, A. Bersvendsen (Editor), Opera Software, 30 Apr, 2007. Availableat
WindowsSidebar Reference, Microsoft Corporation, 2006. Available at
XML Internationalization andLocalization
XML Internationalization andLocalization. Savourel, Y. Sams Publishing, Indiana. June 2001.
Konfabulator Reference
KonfabulatorReference 4.5 Reference Manual Yahoo! Inc., April 14, 2006. Available at
Web Content Accessibility Guidelines1.0. W. Chisholm, G. Vanderheiden, and I. Jacobs. W3C Recommendation, 5 May 1999.Available at
ECMAScriptLanguage Specification, Third Edition. ECMA, December 1999. Available at
HTML 4.01 Specification, D. Raggett, A.Le Hors, I. Jacobs, 24 December 1999. Available at
Hypertext Transfer Protocol --HTTP/1.1, R. Fielding, J. Gettys, J. Mogul, H. Frystyk Nielsen, L. Masinter, P. Leachand T. Berners-Lee, June 1999. Available at
Multipurpose Internet Mail Extensions(MIME) Part Two: media types, N. Freed and N. Borenstein, November 1996. Available at
The Unicode Standard, The Unicode Consortium, Version 5.
Extensible Markup Language (XML)1.0 Specification (Second Edition), T. Bray, J. Paoli, C. M. Sperberg-McQueen, E.Maler, 6 October 2000. Available at
The XMLHttpRequest object. A. vanKesteren. 2006. W3C Working Draft, Available at
CCITT, Recommendation X.509: The Directory Authentication Framework,1988.
Internationalized resource Identifiers(IRIs), M. Duerst, M. Suignard. IETF, January 2005. RFC3987 is Available at
.ZIP File FormatSpecification. PKWare Inc., September 2007. Available at

Related Sources

Light Web Applications
Setting the scope forlight-weight Web-based applications. B. Bos. Work in Progress. 26 Feb 2004. Availableat
XML Packaging
XML Packaging Working Group Charter, J. Nava.W3C. Available at
Semantic Webapps
Semantic Webapps?Lightweight RDF interfaces for SVG. Sept 7, SVGOpen 2004, Japan. Available from:

UPDATE (2018.10.11): v6326

A new update is available. More details about version can be found HERE.

Same OpenGL (4.6 with 245 OpenGL extensions) and Vulkan (1.1.83) support.


Intel’s driver team has published a new graphics driver for all recent GPUs (Intel 6th, 7th and 8th Gen processors) on Windows 10. This new driver (version brings support for Windows 10 October 2018 Update (version 1809 with WDDM 2.5) and HDR for embedded laptop panels.

Loaded with many visual enhancements, this WDDM 2.5 Windows 10 October 2018 Update (v1809) driver introduces brilliant HDR10 on internal displays, enabling full quality HDR10 for video streaming, games, and content creation on both external and laptop displays. Support for Wide Color Gamut has been added for capable displays as well as improvements in EDR quality. This driver also introduces support for the DirectX* 12 Shader Model 6.3 Compiler and improves hot plug audio synchronization between the Graphics and Audio drivers.

This driver also introduces performance improvements for Microsoft WinML-based applications on 7th Generation Intel® Core processors and higher, by including an initial set of DirectML MetaCommands on supported platforms. These driver optimizations bring a substantial speedup to machine learning and AI-enabled applications that require certain types of convolution or matrix multiply operations.

This driver brings power optimizations to your system to improve battery lifetime, including when the display is in standby. This driver also has performance improvements for Pro Evolution Soccer* 2019 (DirectX* 11 version) on 6th Generation Intel® Core processors or higher.

New Features

– Enables full quality HDR10 in embedded laptop displays
– HDR and EDR enhancements for external and laptop displays
– Support for Wide Color Gamut Displays
– WinML performance optimizations
– Support for DirectX 12 Shader Model 6.3 Compiler
– Improves hot plug audio synchronization between the Graphics and Audio drivers
– Performance improvements and optimizations for Pro Evolution Soccer* 2019 on 6th Generation Intel® Core processors or higher
– Memory Optimizations in Vulkan
– Improved color quality during video playback and battery lifetime when display is in standby
– Security fixes and improvements

Complete release notes are available HERE.


GL-Z 0.4.1

OpenGL support

Intel v6323 is an OpenGL 4.5 driver and exposes the same OpenGL support than v4944 (245 OpenGL extensions).

Vulkan support

Intel v6323 exposes Vulkan 1.1.83. Here is the report from GPU Caps Viewer 1.39:

Related posts: