SFDC 1011
`SFDC 1011
`
`
`
`

`
`Chart
`
`Claim Chart of Bederson et al., Pad++: A Zoomable Graphical Sketchpad For Exploring
`Alternate Interface Physics, Journal of Visual Languages and Computing (1996) (“Bederson I”)
`
`and
`
`Bederson et al., A Zooming Web Browser, in Proceedings of SPIE Conference on Multimedia
`Computing and Networking, 1996 (“Bederson II”) (collectively “Pad++”)
`
`as prior art to
`
`Asserted Claims of U.S. Patent No. 7,356,482 (“the ‘482 Patent”)
`
`
`
`‘482 Patent
`Claim 1
`A system for providing a
`dynamically generated
`application having one or
`more functions and one or
`more user interface
`elements; comprising:
`
`04554.00001/6142705.1
`
`PAD++
`
`To the extent that this preamble is construed to be limiting, PAD++
`discloses a system for providing a dynamically generated
`application having one or more functions and one or more user
`interface element. See, e.g.:
`
`BEDERSON I, at 4: “The beginnings of an interface like this sheet
`exists today in a program we call Pad ++. We don’t really stretch a
`huge rubber-like sheet , but we simulate it by zooming into the
`data. We use what we call portals to simulate lenses, and a notion
`we call semantic zooming to scale data in non-geometric ways.
`The user controls where they look on this vast data surface by
`panning and zooming. Portals are objects on the Pad++ data
`surface that can see anywhere on the surface, as well as filter data
`to represent it differently than it normally appears. Panning and
`zooming allow navigation through a large information space via
`direct manipulation. By tapping into people’s natural spatial
`abilities, we hope to increase users’ intuitive access to
`information. Conventional computer search techniques are also
`provided in Pad++, bridging traditional and new interface
`metaphors. Figure 1 depicts a sequence of views as we pan and
`zoom into some data .”
`
`BEDERSON I, at 5-6: “Pad++ is a general-purpose substrate for
`creating and interacting with structured information based on a
`zoomable interface . It adds scale as a first class parameter to all
`items , as well as various mechanisms for navigating through a
`multiscale space. It has several efficiency mechanisms which help
`maintain interactive frame-rates with large and complicated
`graphical scenes .
`
`SFDC 1011
`
`

`
`‘482 Patent
`
`PAD++
`
`
`While Pad++ is not an application itself , it directly supports
`creation and manipulation of multiscale graphical objects , and
`navigation through spaces of these objects . It is implemented as a
`widget in Tcl / Tk [24] (described in a later section) which
`provides an interpreted scripting language for creating zoomable
`applications. The standard objects that pad++ supports are colored
`text , graphics , images , portals and hypertext markup language
`(HTML) . Standard input widgets (buttons , sliders , etc.) are
`supplied as extensions .
`
`One focus in the current implementation has been to provide
`smooth zooming within very large graphical datasets. The nature
`of the Pad++ interface requires consistent high frame-rate
`interactions , even as the dataspace becomes large and the scene
`gets complicated . In many applications , speed is important , but
`not critical to functionality. In Pad ++ , however , the interface
`paradigm is inherently interactive. One important searching
`strategy is to visually explore the dataspace while zooming
`through it , so it is essential that interactive frame rates be
`maintained .
`
` second focus has been to design Pad ++ to make it relatively
`easy for thirparties to build applications using it . To that end , we
`have made a clear division between what we call the ‘substrate’
`and applications . The substrate , written in C ++ , is part of every
`release and has a well-defined API . It has been written witcare to
`ensure efficiency and generality . It is connected to a scripting
`language (currently Tcl , but we are exploring alternatives) that
`provides a fairly high-level interface to the complex graphics and
`interactions available . While the scripting language runs quite
`slowly , it is used as a glue language for creating interfaces and
`putting them together. The actual interaction and rendering is
`performed by the C++ substrate . This approach allows people to
`develop applications for Pad++ while avoiding the complexities
`inherent in this type of system. (See the Implementation section
`for more information on this.)”
`
`BEDERSON I, at 7: “PadDraw has a primitive Graphical User
`Interface (GUI) builder that is in progress. Among other things , it
`allows the creation of active objects . Active objects can animate
`the view to other locations (a kind of hyperlink) or move other
`objects around on the surface .”
`
`BEDERSON I, at 11: “For example , we implemented a digital
`
` A
`
`04554.00001/6142705.1
`
`SFDC 1011
`
`

`
`‘482 Patent
`
`04554.00001/6142705.1
`
`PAD++
`clock that at normal size shows the hours and minutes . When
`zooming in , instead of making the text very large , it shows the
`seconds , and then eventually the date as well . Similarly ,
`zooming out shows just the hour . An analog clock (implemented
`as a lens that can be positioned over a digital clock) is similar—it
`does not show the second hand or the minute markings when
`zoomed out.”
`
`BEDERSON I, at 11: “We are exploring several different types of
`interactive visualizations within Pad++, some of which are
`described briefly here . Each takes advantage of the variable
`resolution available for both representation and interaction .
`Layout of graphical objects within a multi-resolution space is an
`interesting problem , and is quite different than traditional fixed-
`resolution layout . Deciding how to visually represent an arbitrary
`graph on a non-zoomable surface is extremely difficult . Often it is
`impossible to position all objects near logically related objects . In
`addition , representing the links between objects often requires
`overlapping or crossing edges . Even laying out a tree is difficult
`because , generally speaking , there are an exponential number of
`children that will not fit in a fixed size space . Traditional layout
`techniques use sophisticated iterative , adaptive algorithms for
`laying out general graphs , and still result in graphs that are hard to
`understand . Large trees are often represented hierarchically with
`one sub-tree depicted by a single box that references another tree .
`Using an interactive zoomable surface , however , allows very
`different methods of visually representing large data structures .
`The fact that there is always more room to put information
`‘between the cracks’ gives many more options . Pad++ is
`particularly well suited to visualizing hierarchical data because
`information that is deeper in the hierarchy can be made smaller .
`Accessing this information is accomplished by zooming .”
`
`BEDERSON I, at 12: “We built a zoomable directory browser as
`another exploration of multiscale layout . The directory browser
`provides a graphical interface for accessing the directory structure
`of a filesystem (see Figure 6). Each directory is represented by a
`folder icon and files are represented by solid squares colored by
`file type . Both directories and files show their filenames as labels
`when the user is sufficiently close to be able to read them . Each
`directory has all of its subdirectories and files organized
`alphabetically inside it . Searching through the directory structure
`can be done by zooming in and out of the directory tree , or by
`using the content based search mechanisms described above .
`Zooming into a file automatically loads its text or image inside the
`
`SFDC 1011
`
`

`
`‘482 Patent
`
`04554.00001/6142705.1
`
`PAD++
`colored square and it can then be annotated . At any particular
`view , typically three levels of the hierarchy are visible .”
`
`BEDERSON II, at 3: “We are exploring dynamic multiscale
`techniques to support focus and context during navigation of large
`information spaces. To accomplish this we are building a
`zoomable web browser using Pad++, a substrate for building
`multiscale dynamic user interfaces [2][3][27][28]. Pad++ provides
`an extensive graphical workspace where dynamic objects can be
`placed at any position and at any scale. Pad++ supports panning
`and zooming. Zooming can involve simple geometric scaling or
`what we term semantic zooming, in which rendering of objects can
`vary based on factors in addition to scale, such as context of the
`task or complexity of the information being displayed. Pad++ is
`built as a widget for Tcl/Tk, a scripting language and user-
`interface library [26][33]. Pad++ allows WWW pages to remain
`visible at varying scales while they are not specifically being
`visited, so the viewer may examine many pages at once. In
`addition, Pad++ allows the user to zoom in and out of pages,
`enabling explicit control of how much context is viewed at any
`time. To orient themselves, users can simply zoom back to view a
`number of web pages. To get more detailed views of a particular
`page they can zoom in. We think this variable scale contextual
`display of web pages can provide important support for
`navigation. We are currently exploring a tree layout system that
`permits users to dynamically add to and reorganize a tree of web
`pages. Using our Pad++ web browser, users navigate a space filled
`with familiar objects, not iconified representations of those
`objects. Our dynamic Pad++ tree browser combines a basic focus-
`driven layout with automatic zooming and panning to support
`navigation. The software allows the user to select a focus page.
`That selection animates the page to occupy a larger section of the
`display. Pages farther from the focus page get increasingly
`smaller, resulting in a graphical fisheye view [30]. See Figures 1
`and 2 for snapshots of the Pad++ web browser during
`reorganization.”
`
`BEDERSON II, at 7: “Currently there are a number of efforts to
`create more interactive WWW documents. The primary approach
`is to write code in a programming language, instead of HTML,
`that can be downloaded into a browser equipped to interpret the
`language. Sun’s Hot-Java project uses the Java language [18],
`Cygnus Support’s GNU Remote Operations Web (GROW)
`proposes to use GNU’s Guile extension language [17], and
`Microsoft’s Blackbird will use dynamically loadable object files
`
`SFDC 1011
`
`

`
`‘482 Patent
`
`[a] a server computer;
`
`
`04554.00001/6142705.1
`
`PAD++
`[6]. By providing the ability to download and run code locally
`allows complicated animations, for example, to be encoded in a
`concise and network efficient manner.
`
`The Pad++ WWW browser contains a full Tcl interpreter. MSML
`provides mechanisms to include Tcl code within the page, instruct
`the browser to download either scripts or saved Pad++ data files
`over the WWW, and pass the code to the Tcl interpreter. This, of
`course, carries with it enormous security risks that we have not yet
`addressed. In the future we may restrict ourselves to a safe subset
`of the language as with Java or GROW. In our case this will
`initially be SafeTcl [7] but may also include support for other
`languages (e.g. Java).”
`
`BEDERSON I, Figures 1, 2, 3, 4, 5, 6, 8, and 14, and the
`accompanying text.
`
`BEDERSON II, Figures 1, 2, and 3, and the accompanying text.
`
`To the extent this reference does not teach this claim element, this
`reference in combination with the knowledge of one of ordinary
`skill in the art and the disclosures of each of the prior art
`references provided in Salesforce’s Petitions related to the ‘482
`and ‘111 Patents renders this claim element obvious.
`PAD++ discloses a server computer. See, e.g.:
`
`BEDERSON I, at 27: “Pad++ also seems well-suited to a
`collaborative work environment . While the original Pad
`implementation allowed some basic shared workspaces (running
`from a single process displaying on multiple X servers) , we are
`designing a more sophisticated approach . The goal is to be able to
`use portals to look remotely on to any Pad++ surfaces on the
`network (assuming that the right permissions are set) . Each user’s
`system will contain a spatial database server that will send updates
`to all other systems that have portals looking on to it . With this
`approach , there may be a lag in retrieving others’ data but , once
`it arrives , it will be cached within the local system so the high-
`speed interactivity of Pad++ will not be lost.”
`
`BEDERSON II, at 2: “Annotations are another important
`information tailoring facility. Annotations are personal markings
`that can be used to highlight and comment on information for
`oneself and others. One interesting approach to annotation on the
`web separates the annotations from the original documents and
`
`SFDC 1011
`
`

`
`‘482 Patent
`
`[b] one or more client
`computers connected to the
`server computer over a
`computer network;
`
`04554.00001/6142705.1
`
`PAD++
`stores them in a special annotation server [29]. Used with an
`enhanced browser, displaying a new page automatically brings in
`the annotations of others and integrates them into the page.”
`
`BEDERSON II, at 7: “Traditionally, browsers come with pre-
`defined functions and all interactions with a web document are
`constrained to those functional abilities. Limited animation is
`possible through techniques such as server-push and client-pull.
`Forms, a simple interface built into most clients to collect
`information and send it to the server for processing, provide
`constrained GUI-like interactions. However, until recently,
`nothing supporting more interactive and flexible interfaces has
`been available.”
`
`To the extent this reference does not teach this claim element, this
`reference in combination with the knowledge of one of ordinary
`skill in the art and the disclosures of each of the prior art
`references provided in Salesforce’s Petitions related to the ‘ 482
`and ‘ 111 Patents renders this claim element obvious.
`PAD++ discloses one or more client computers connected to the
`server computer over a computer network. See, e.g.:
`
`BEDERSON I, at 29: “To adequately explore the effectiveness of
`the Pad ++ substrate and the informational physics design strategy
`discussed here will require development of a wide range of
`applications . One domain we plan to investigate is construction of
`active documents . Most tools for interacting with documents (like
`World-Wide Web browsers such as Mosaic and Netscape)
`predefine all of the interactive widgets within the client . Hooks
`are provided so that documents may access those widgets but there
`is no method to provide new ones , except to re-define the
`standards , modify the client and distribute the client to enough of
`the user population so it becomes the new standard in practice .
`Pad++’s extensibility ensures that new widgets can be defined by
`scripts which can be included with a document . This will allow
`documents to provide new forms of interactivity without
`depending on the client to supply it . We are currently in the
`design stages of an extension to HTML , we call the MultiScale
`Markup Language (MSML) , that will be the markup language to
`describe documents within Pad ++ . MSML will allow logical
`formatting of documents with dif ferent sized components and will
`provide a method for allowing Pad ++ scripts to be included with
`documents—allowing truly active documents .”
`
`
`SFDC 1011
`
`

`
`‘482 Patent
`
`[c] a first layer associated
`with the server computer
`containing information
`about the unique aspects of
`a particular application;
`
`04554.00001/6142705.1
`
`PAD++
`BEDERSON I, at 27: “Pad++ also seems well-suited to a
`collaborative work environment . While the original Pad
`implementation allowed some basic shared workspaces (running
`from a single process displaying on multiple X servers) , we are
`designing a more sophisticated approach . The goal is to be able to
`use portals to look remotely on to any Pad++ surfaces on the
`network (assuming that the right permissions are set) . Each user’s
`system will contain a spatial database server that will send updates
`to all other systems that have portals looking on to it . With this
`approach , there may be a lag in retrieving others’ data but , once
`it arrives , it will be cached within the local system so the high-
`speed interactivity of Pad++ will not be lost.”
`
`To the extent this reference does not teach this claim element, this
`reference in combination with the knowledge of one of ordinary
`skill in the art and the disclosures of each of the prior art
`references provided in Salesforce’s Petitions related to the ‘ 482
`and ‘ 111 Patents renders this claim element obvious.
`PAD++ discloses a first layer associated with the server computer
`containing information about the unique aspects of a particular
`application. See, e.g.:
`
`BEDERSON I, at 27: “Pad++ also seems well-suited to a
`collaborative work environment . While the original Pad
`implementation allowed some basic shared workspaces (running
`from a single process displaying on multiple X servers) , we are
`designing a more sophisticated approach . The goal is to be able to
`use portals to look remotely on to any Pad++ surfaces on the
`network (assuming that the right permissions are set) . Each user’s
`system will contain a spatial database server that will send updates
`to all other systems that have portals looking on to it . With this
`approach , there may be a lag in retrieving others’ data but , once
`it arrives , it will be cached within the local system so the high-
`speed interactivity of Pad++ will not be lost.”
`
`BEDERSON I, at 7: “PadDraw is a sample drawing application
`built on top of Pad++ . It supports interactive drawing and
`manipulation of objects as well as loading of predefined or
`programmatically created objects . This application is written
`entirely in Tcl (the scripting language) and was used to produce all
`the figures depicted in this paper . The tools , such as navigation
`aids , hyperlinks and the outline browser , that we discuss later ,
`are part of this application . The basic user interface for navigating
`in PadDraw uses a three button mouse . The left button is mode
`
`SFDC 1011
`
`

`
`‘482 Patent
`
`[d] a second layer
`associated with the server
`computer containing
`information about the user
`interface and functions
`common to a variety of
`applications,
`
`04554.00001/6142705.1
`
`PAD++
`dependent and lets users select and move objects , draw graphical
`objects , follow hyperlinks , etc . The middle button zooms in and
`the right button zooms out . Zooming is always centered on the
`cursor , so moving the mouse while zooming lets the user
`dynamically control which point they are zooming around .
`PadDraw has a primitive Graphical User Interface (GUI) builder
`that is in progress . Among other things , it allows the creation of
`active objects . Active objects can animate the view to other
`locations (a kind of hyperlink) or move other objects around on
`the surface .”
`
`BEDERSON I, at 12: “We built a zoomable directory browser as
`another exploration of multiscale layout . The directory browser
`provides a graphical interface for accessing the directory structure
`of a filesystem (see Figure 6) . Each directory is represented by a
`folder icon and files are represented by solid squares colored by
`file type . Both directories and files show their filenames as labels
`when the user is sufficiently close to be able to read them . Each
`directory has all of its subdirectories and files organized
`alphabetically inside it . Searching through the directory structure
`can be done by zooming in and out of the directory tree , or by
`using the content based search mechanisms described above .
`Zooming into a file automatically loads its text or image inside the
`colored square and it can then be annotated . At any particular
`view , typically three levels of the hierarchy are visible .”
`
`To the extent this reference does not teach this claim element, this
`reference in combination with the knowledge of one of ordinary
`skill in the art and the disclosures of each of the prior art
`references provided in Salesforce’s Petitions related to the ‘ 482
`and ‘ 111 Patents renders this claim element obvious.
`PAD++ discloses a second layer associated with the server
`computer containing information about the user interface and
`functions common to a variety of applications. See, e.g.:
`
`BEDERSON I, at 27: “Pad++ also seems well-suited to a
`collaborative work environment . While the original Pad
`implementation allowed some basic shared workspaces (running
`from a single process displaying on multiple X servers) , we are
`designing a more sophisticated approach . The goal is to be able to
`use portals to look remotely on to any Pad++ surfaces on the
`network (assuming that the right permissions are set) . Each user’s
`system will contain a spatial database server that will send updates
`to all other systems that have portals looking on to it . With this
`
`SFDC 1011
`
`

`
`‘482 Patent
`
`04554.00001/6142705.1
`
`PAD++
`approach , there may be a lag in retrieving others’ data but , once
`it arrives , it will be cached within the local system so the high-
`speed interactivity of Pad++ will not be lost.”
`
`BEDERSON I, at 27: “While an informational physics strategy for
`interface design certainly involves metaphor , we think there is
`much that is distinctive about a physics-based approach .
`Traditional metaphor-based approaches map at the level of high-
`level objects and functionality . They yield interfaces with objects
`such as windows , trash cans and menus , and functions like
`opening and closing windows and choosing from menus . While
`there are ease-of-use benefits from such mappings , they also
`orient designers towards mimicking mechanisms of earlier media
`rather than towards exploring potentially more effective computer-
`based mechanisms . Semantic zooming is but one example
`mechanism that we think arises more naturally from adopting an
`informational physics strategy . Even geometric zooming ,
`especially with the orders of magnitude possible in Pad ++ , is not
`a mechanism that traditional metaphors would lead designers to
`investigate.”
`
`BEDERSON I, at 7: “PadDraw is a sample drawing application
`built on top of Pad++ . It supports interactive drawing and
`manipulation of objects as well as loading of predefined or
`programmatically created objects . This application is written
`entirely in Tcl (the scripting language) and was used to produce all
`the figures depicted in this paper . The tools , such as navigation
`aids , hyperlinks and the outline browser , that we discuss later ,
`are part of this application . The basic user interface for navigating
`in PadDraw uses a three button mouse . The left button is mode
`dependent and lets users select and move objects , draw graphical
`objects , follow hyperlinks , etc . The middle button zooms in and
`the right button zooms out . Zooming is always centered on the
`cursor , so moving the mouse while zooming lets the user
`dynamically control which point they are zooming around .
`PadDraw has a primitive Graphical User Interface (GUI) builder
`that is in progress . Among other things , it allows the creation of
`active objects . Active objects can animate the view to other
`locations (a kind of hyperlink) or move other objects around on
`the surface .”
`
`BEDERSON I, at 7: “Easily finding information on the Pad ++
`surface is obviously very important since intuitive navigation
`through large dataspaces is one of its primary motivations. Pad ++
`supports visual searching with direct manipulation panning and
`
`SFDC 1011
`
`

`
`‘482 Patent
`
`[e] a particular application
`being generated based on
`the data in both the first and
`second layers;
`
`04554.00001/6142705.1
`
`PAD++
`zooming in addition to traditional mechanisms, such as content-
`based search. We have also implemented visual bookmarks as
`another navigational aid.”
`
`BEDERSON I, at 7: “Portals are special items that provide views
`onto other areas of the Pad++ surface , or even other surfaces .
`Each portal passes interaction events that occur within it to the
`place it is looking . Thus , you can pan and zoom within a portal .
`In fact , you can perform any kind of interaction through a portal .
`Portals can filter input events , providing a mechanism for
`changing behavior of objects when viewed through a portal .
`Portals can also change the way objects are presented . When used
`in this fashion , we call them lenses (see below) . Portals can be
`used to replicate information efficiently , and also provide a
`method to bring physically separate data near each other . Figure 1
`was created using several portals , each looking at approximately
`the same place at different magnifications . Portals can also be
`used to create indices . For example , creating a portal that looks
`onto a hyperlink allows the hyperlink to be followed by clicking
`on it within the portal , changing the main view . This however ,
`may move the hyperlink of f the screen “
`
`To the extent this reference does not teach this claim element, this
`reference in combination with the knowledge of one of ordinary
`skill in the art and the disclosures of each of the prior art
`references provided in Salesforce’s Petitions related to the ‘ 482
`and ‘ 111 Patents renders this claim element obvious.
`Pad++ discloses a particular application being generated based on
`the data in both the first and second layers. See, e.g.:
`
`BEDERSON I, at 5: “Here we describe the motivation behind the
`Pad ++ development, report the status of the current
`implementation and present initial prototype applications.”
`
`BEDERSON I, at 5-6: “Pad++ is a general-purpose substrate for
`creating and interacting with structured information based on a
`zoomable interface . It adds scale as a first class parameter to all
`items , as well as various mechanisms for navigating through a
`multiscale space. It has several efficiency mechanisms which help
`maintain interactive frame-rates with large and complicated
`graphical scenes .
`
`While Pad++ is not an application itself , it directly supports
`creation and manipulation of multiscale graphical objects , and
`
`SFDC 1011
`
`

`
`PAD++
`navigation through spaces of these objects . It is implemented as a
`widget in Tcl / Tk [24] (described in a later section) which
`provides an interpreted scripting language for creating zoomable
`applications. The standard objects that pad++ supports are colored
`text , graphics , images , portals and hypertext markup language
`(HTML) . Standard input widgets (buttons , sliders , etc.) are
`supplied as extensions .
`
`One focus in the current implementation has been to provide
`smooth zooming within very large graphical datasets. The nature
`of the Pad++ interface requires consistent high frame-rate
`interactions , even as the dataspace becomes large and the scene
`gets complicated . In many applications , speed is important , but
`not critical to functionality. In Pad ++ , however , the interface
`paradigm is inherently interactive. One important searching
`strategy is to visually explore the dataspace while zooming
`through it , so it is essential that interactive frame rates be
`maintained .
`
` A
`
` second focus has been to design Pad ++ to make it relatively
`easy for thirparties to build applications using it . To that end , we
`have made a clear division between what we call the ‘substrate’
`and applications . The substrate , written in C ++ , is part of every
`release and has a well-defined API . It has been written witcare to
`ensure efficiency and generality . It is connected to a scripting
`language (currently Tcl , but we are exploring alternatives) that
`provides a fairly high-level interface to the complex graphics and
`interactions available . While the scripting language runs quite
`slowly , it is used as a glue language for creating interfaces and
`putting them together. The actual interaction and rendering is
`performed by the C++ substrate . This approach allows people to
`develop applications for Pad++ while avoiding the complexities
`inherent in this type of system. (See the Implementation section
`for more information on this.)”
`
`See Claims 1[c], 1[d].
`
`To the extent this reference does not teach this claim element, this
`reference in combination with the knowledge of one of ordinary
`skill in the art and the disclosures of each of the prior art
`references provided in Salesforce’s Petitions related to the ‘ 482
`and ‘ 111 Patents renders this claim element obvious.
`PAD++ discloses a third layer associated with the server computer
`that retrieves the data in the first and second layers in order to
`
`‘482 Patent
`
`[f] a third layer associated
`with the server computer
`
`04554.00001/6142705.1
`
`SFDC 1011
`
`

`
`‘482 Patent
`that retrieves the data in the
`first and second layers in
`order to generate the
`functionality and user
`interface elements of the
`application; and
`
`[g] a change management
`layer for automatically
`detecting changes that
`affect an application,
`
`04554.00001/6142705.1
`
`PAD++
`generate the functionality and user interface elements of the
`application. See, e.g.:
`
`See Claims 1[c], 1[d].
`
`To the extent this reference does not teach this claim element, this
`reference in combination with the knowledge of one of ordinary
`skill in the art and the disclosures of each of the prior art
`references provided in Salesforce’s Petitions related to the ‘ 482
`and ‘ 111 Patents renders this claim element obvious.
`PAD++ discloses a change management layer for automatically
`detecting changes that affect an application. See, e.g.:
`
`BEDERSON I, at 7: “Portals are special items that provide views
`onto other areas of the Pad++ surface , or even other surfaces .
`Each portal passes interaction events that occur within it to the
`place it is looking . Thus , you can pan and zoom within a portal .
`In fact , you can perform any kind of interaction through a portal .
`Portals can filter input events , providing a mechanism for
`changing behavior of objects when viewed through a portal .
`Portals can also change the way objects are presented . When used
`in this fashion , we call them lenses (see below) . Portals can be
`used to replicate information efficiently , and also provide a
`method to bring physically separate data near each other . Figure 1
`was created using several portals , each looking at approximately
`the same place at different magnifications . Portals can also be
`used to create indices . For example , creating a portal that looks
`onto a hyperlink allows the hyperlink to be followed by clicking
`on it within the portal , changing the main view. This however ,
`may move the hyperlink off the screen.”
`
`BEDERSON I, at 7: “Portals can be used to replicate information
`efficiently , and also provide a method to bring physically separate
`data near each other . Figure 1 was created using several portals ,
`each looking at approximately the same place at different
`magnifications . Portals can also be used to create indices . For
`example , creating a portal that looks onto a hyperlink allows the
`hyperlink to be followed by clicking on it within the portal ,
`changing the main view . This however , may move the hyperlink
`of f the screen.”
`
`BEDERSON I, at 9: “We can use lenses to design interfaces at the
`level of specific tasks . For example , we have designed a pair of
`number entry lenses for Pad++ that can change a generic number
`
`SFDC 1011
`
`

`
`PAD++
`entry mechanism into a slider or dial , as the user prefers . By
`default the generic number entry mechanism allows entering a
`number by typing . However , dragging the slider lens over it
`changes the representation of the number from text to a slider , and
`now the mouse can be used to change the number . Another lens
`shows the data as a dial and lets you modify that with a mouse as
`well .”
`
`BEDERSON I, at 10: “Once we make zooming a standard part of
`the interface , many parts of the interface need to be reevaluated .
`For example , we can use semantic zooming to change the way
`things look depending on their size . As we mentioned , zooming
`provides a natural mechanism for representing abstractions of
`objects . It is natural to see extra details of an object when zoomed
`in and viewing it up close . When zoomed out , instead of simply
`seeing a scaled down version of the object , it is potentially more
`effective to see a different representation of it.”
`
`BEDERSON I, at 23: “Region Management : Only updates