WO2001035217A2 - Interface utilisateur graphique - Google Patents
Interface utilisateur graphique Download PDFInfo
- Publication number
- WO2001035217A2 WO2001035217A2 PCT/US2000/031351 US0031351W WO0135217A2 WO 2001035217 A2 WO2001035217 A2 WO 2001035217A2 US 0031351 W US0031351 W US 0031351W WO 0135217 A2 WO0135217 A2 WO 0135217A2
- Authority
- WO
- WIPO (PCT)
- Prior art keywords
- active
- elements
- text
- size
- computer
- Prior art date
Links
- 238000000034 method Methods 0.000 claims description 72
- 230000000694 effects Effects 0.000 claims description 20
- 238000004590 computer program Methods 0.000 claims 1
- 239000003086 colorant Substances 0.000 description 36
- 230000008859 change Effects 0.000 description 16
- 230000006399 behavior Effects 0.000 description 15
- 230000004913 activation Effects 0.000 description 10
- 230000009471 action Effects 0.000 description 7
- 230000008569 process Effects 0.000 description 6
- 230000000994 depressogenic effect Effects 0.000 description 5
- 230000006870 function Effects 0.000 description 5
- 238000012545 processing Methods 0.000 description 4
- 238000012986 modification Methods 0.000 description 3
- 230000004048 modification Effects 0.000 description 3
- 239000003607 modifier Substances 0.000 description 3
- 230000008901 benefit Effects 0.000 description 2
- 230000007423 decrease Effects 0.000 description 2
- 230000003247 decreasing effect Effects 0.000 description 2
- 238000013461 design Methods 0.000 description 2
- 238000010422 painting Methods 0.000 description 2
- 230000035755 proliferation Effects 0.000 description 2
- 239000007787 solid Substances 0.000 description 2
- 230000001960 triggered effect Effects 0.000 description 2
- YJVBLROMQZEFPA-UHFFFAOYSA-L acid red 26 Chemical compound [Na+].[Na+].CC1=CC(C)=CC=C1N=NC1=C(O)C(S([O-])(=O)=O)=CC2=CC(S([O-])(=O)=O)=CC=C12 YJVBLROMQZEFPA-UHFFFAOYSA-L 0.000 description 1
- 238000013459 approach Methods 0.000 description 1
- 238000003491 array Methods 0.000 description 1
- 239000011230 binding agent Substances 0.000 description 1
- 230000000295 complement effect Effects 0.000 description 1
- 239000002131 composite material Substances 0.000 description 1
- 230000001419 dependent effect Effects 0.000 description 1
- 238000011161 development Methods 0.000 description 1
- 235000021384 green leafy vegetables Nutrition 0.000 description 1
- 238000007373 indentation Methods 0.000 description 1
- 238000002372 labelling Methods 0.000 description 1
- 239000000463 material Substances 0.000 description 1
- 230000007246 mechanism Effects 0.000 description 1
- 239000003973 paint Substances 0.000 description 1
- 238000003672 processing method Methods 0.000 description 1
- 230000004044 response Effects 0.000 description 1
- 238000010187 selection method Methods 0.000 description 1
- 238000000926 separation method Methods 0.000 description 1
- 238000001228 spectrum Methods 0.000 description 1
- 238000012360 testing method Methods 0.000 description 1
- 238000013519 translation Methods 0.000 description 1
- 230000000007 visual effect Effects 0.000 description 1
- 238000004804 winding Methods 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/451—Execution arrangements for user interfaces
-
- G—PHYSICS
- G10—MUSICAL INSTRUMENTS; ACOUSTICS
- G10L—SPEECH ANALYSIS TECHNIQUES OR SPEECH SYNTHESIS; SPEECH RECOGNITION; SPEECH OR VOICE PROCESSING TECHNIQUES; SPEECH OR AUDIO CODING OR DECODING
- G10L15/00—Speech recognition
- G10L15/26—Speech to text systems
Definitions
- the present invention relates to graphical user interfaces. Particularly, the present invention relates to a graphical user interface that consists entirely of a single window. More particularly, the present invention relates to a graphical user interface that consists entirely of a single window containing a desktop where all of the displays are painted onto the desktop. Even more particularly, the present invention relates to a graphical user interface where everything displayed on the screen is an "active element.”
- GUI graphic user interface
- GUI In a typical window-based GUI system, visually distinct display objects are provided on the display screen, and are commonly referred to as "icons.” Each of the icons represents a function or object on the desktop.
- a cursor is also displayed that may be selectively moved in response to the movement of a mouse or other pointer control device. The cursor may be moved over display objects that the user may select on the screen. The user may delete information from a window, move data from one window to another, and generally operate on the windows as if an actual file or other physical object is being manipulated.
- a variety of pull-down menus also may be displayed, using a technique for selecting particular command options appearing along a menu bar, and subcommand items corresponding to the command options.
- these various items are rectangular in shape and the user is not allowed to change the shape of a given item. In some limited instances, the user may be allowed to resize the shape within certain limits. In all instances, certain items such as menus and command buttons are particular to a given window and thus cannot be moved outside of the window with which it is associated. Furthermore, a user cannot change these items to a custom shape or alter and change any borders associated with a window, buttons, etc.
- GUI graphic user interface
- the GUI consists entirely of active elements.
- a GUI where all displays are painted into a single window, i.e. desktop.
- a GUI where all the active elements are free to move out of their displays and around the desktop.
- the present invention achieves these and other objectives by providing a method and apparatus for a graphical user interface that has a desktop display window consisting essentially of a single window, one or more active elements displayed on the single window where the active elements are drawn into the single window and where every active element is dependent on the single window, a configuration tool operable with each active element where the configuration tool permits a user to alter the characteristics of each active element, and a semi-automatic view generator capable of generating active elements to daisplay a single-record view of an object or a multi-record view of a group of like objects.
- FIGURE 1 illustrates an embodiment of the present invention showing various active elements of the graphical user interface.
- FIGURE 2 illustrates an embodiment of the present invention showing the various shapes an active element of the graphical user interface may have.
- FIGURE 3 illustrates an embodiment of the present invention showing an active element configuration panel.
- FIGURE 4 illustrates an embodiment of the present invention showing a simple shape selection tool called a shape editor.
- FIGURE 5 illustrates an embodiment of the present invention showing a simple border selection tool.
- FIGURE 5A-5E illustrates an embodiment of the present invention showing each one of five different panels of the color selection tool called a color editor.
- FIGURE 5F illustrates an embodiment of the present invention showing an enlargement of the transparency selector.
- FIGURE 6 illustrates an embodiment of the present invention showing a simple image selection tool.
- FIGURE 7 illustrates an embodiment of a simple event editor tool of the present invention.
- FIGURE 8A illustrates an embodiment of a simple text editor of the present invention.
- FIGURE 8B illustrates an embodiment of the simple text editor of the present invention showing how the individual active elements of the present invention can be moved from each other and still function.
- FIGURE 9 illustrates an embodiment of the drawing tool of the present invention.
- FIGURE 9A illustrates an enlarged view of the tools panel of the drawing tool of the present invention that also shows various active elements separated from the tools grouping.
- FIGURE 10 illustrates an embodiment of the present invention showing a multi-record view.
- FIGURE 11 illustrates an embodiment of the present invention showing a single record view with embedded objects in various expanded views.
- Figs. 1-11 The preferred embodiment of the present invention is illustrated in Figs. 1-11.
- the simplest elements can take various shapes and borders. They can display a solid color or an image as a background. They can be moved, resized or configured by the user; and can store hints used by a parent element, if the element is a child element of a parent element, when they are laid out.
- Java JFrame Java JFrame
- All elements of the present invention are "Java children" of the desktop, that is, contained by and displayed by it. No Java layout manager is used on the desktop, leaving the present invention parent elements free to manage the sizes and positions of their children. This also allows the present invention's "windows" to overlap each other, slide partially off screen, etc., behaviors which would be prohibited were the desktop to manage their layout.
- Java programmers will recognize and understand the references made throughout this preferred embodiment to the Java objects.
- All the displays present the appearance of sub windows, and can be moved about and resized like traditional windows. However, this is an illusion. All the displays are painted into the desktop of the present invention. All active elements of the present invention have at least a shape, which is initially transparent. The minimum size of a simple element is 4 pixels in each dimension plus the size of its borders all around, if any. If an exact size is specified in its size hints, this size overrides the minimum. To construct an element, its name, identifier, and list of properties and events must be provided. This information is typically provided by the programmer/developer as default views or by a database. Details about properties and events are discussed later.
- the shape of an active element defines its active portion. Unlike prior art graphic user interfaces, the user can change the shape of any active element of the present invention.
- the present invention provides a variety of shapes from which the user may choose. These include a box shape, an oval shape, a cloud shape, a triangle shape, and a custom shape. Referring to Figure 2, there is illustrated a variety of the shapes an active element may have.
- a box shape 10 is a simple rectangle created using a Java Rectangle2D object.
- the oval shape 20 is an ellipse or circle created using a Java Ellipse2D object.
- the cloud shape 30 is a custom construct, which can be resized without changing its form. No two cloud shapes will be exactly alike.
- the cloud is created by starting with a Java Ellipse2D object, just like an oval shape, using a size 200 pixels wide x 100 pixels high.
- the Java Pathlterator describing this object consists of equations for four cubic splines, one for each quadrant. Each spline consists of three pairs of coefficients that define the control points for the spline. A random value D between 30-50 pixels is chosen.
- Another Java Ellipse2D object of size 2D pixels wide x D pixels high is centered at each of the twelve control points. This appears to guarantee "reasonable" looking clouds.
- the cloud shape is the composite of the thirteen ellipses so generated. It is then resized to fit within the desired size of the element.
- a triangle shape 40 is a custom construct with its point facing up, down, left or right. This shape is very useful as a button control, but is not limited to that application. In the preferred embodiment, it is constructed from a Java Polygon object using the following pre-computed coordinates:
- the result is then resized to fit within the desired size of the active element.
- a custom shape (see the up- and down-pointing scroll buttons in Figure 1) is a construct which starts out as a plain box.
- Each side of the box can be left plain or changed by the user to a slant, point, bevel, semicircle, or rounded plain shape.
- Two directions are associated with each side.
- the right side can be slanted lower-left to upper-right or lower-right to upper-left. It can be pointed right ("out") or left ("in”) and so on.
- the preferred embodiment uses the following values:
- Circle Arc2D (-SIZE_2, 0, SIZE, SIZE, 0, 360, CHORD) Round RoundRectangle2D (-SIZE_4, 0, SIZE_2, SIZE, SIZE_4, SIZE_4)
- SIZE ⁇ y ⁇ 0, SIZE_2, SIZE ⁇
- Circle Arc2D (SIZE_2, 0, SIZE, SIZE, 0, 360, CHORD) Round RoundRectangle2D (SIZE3_4, 0, SIZE_2, SIZE, SIZE_4, SIZE_4)
- a Java Area object is formed as above. Where x and y values are given, a Java Polygon is used to form the area. For out-pointing sides, the area is added to a base rectangle SIZE x SIZE. For in- pointing sides, the area is subtracted from a base rectangle SIZE x SIZE. The finished product is resized to fit within the desired shape of the element.
- a button with one side pointed or rounded can be used to indicate direction such as the up and down buttons on a scroll bar.
- a text field with a point "out” on the right end and a point "in” on the left end looks much like an arrow.
- Shapes frequently require resizing modifications. This happens when the element itself is resized and when borders are added to or removed from the element.
- the original shape and its size are stored for reference in the shape object.
- the new shape is obtained by scaling the original shape by a transform based on the new size divided by the original size, bigger or smaller as appropriate. The scaling can be different in the horizontal and vertical directions.
- the shape is also translated to lie within the new borders.
- Text layout methods require horizontal rectangles of a given height that lie within a shape.
- the present invention loops across the width of the shape's bounding box looking at rectangles of the given height and 1 pixel wide. If such a rectangle lies fully within the shape, and the previous one did not, the method starts tracking a new output rectangle. If the previous one lies within the shape, the method of the present invention moves the right edge of the output rectangle over another pixel. If the current rectangle does not lie within the shape and the previous one did, the method ends the output rectangle and stores it. When the right edge of the shape is reached and if an output rectangle is in progress, the method of the present invention stores it. The list of rectangles for the shape is returned.
- Every active element has an active element configuration that may be changed by a user through the active element configuration panel.
- the preferred embodiment of the active element configuration panel is shown in Figure 3. it will be understood by those skilled in the art that the active element configuration panel 60 is itself a parent active element 61 having children active elements 70, 90, 110, 130, and 150, respectively, programmed using the methods of the present invention.
- the configuration panel 60 for the active element contains various options that allows a user to configure a particular active element. The user may change or not any one of the following by selecting shapes 70, colors 90, borders 110, events 130, or images 150.
- a simple shape selection tool 71 (also configured according to the teachings of the present invention) called a shape editor is provided as part of the active element configuration panel 60.
- the user can select a box (not shown), oval 73, cloud 74, triangle 75, or custom shape 76. If triangle 75 is selected, the user can choose to point it left 77, right 78, up 79 or down 80. If custom 76 is selected, for each edge the user can choose plain 81, slant 82, point 83, bevel 84, circle (not shown) or round styles (not shown), and whether the edge is pointed in 87 or out 88. To construct a shape editor, the list of available styles such as box, oval, etc. must be provided.
- each element of the present invention may have zero or more borders of various styles. If there are borders, they fit snugly within the box defined by the size of the active element. The active shape fits snugly within the borders. The user can change the style, color or number of borders of any element. Furthermore, borders can surround any shape, not just rectangles.
- Border color can have a significant effect on the appearance of the border. Leaving the color "null" allows the software to compute appropriate border colors based on the background color of the active shape. Such borders are often the most attractive choice. In some situations, it is desirable to specify a color explicitly. In that case, border colors are computed from the specified color.
- a plain border is a simple region of constant pixel width with a single color. It can be used as the innermost border around a text field, to provide some margin around the text, or between borders of other styles to "widen" them.
- the plain border has a width and a color. In the preferred embodiment, default values for the width and the color are provided as default one pixel for a width and null for a color.
- the plain border pre-computes and stores the area it needs to fill. The area is computed by taking the original shape and centering within it a second, similar shape, smaller all around by the width of the plain border. The smaller shape is subtracted from the larger. The annulus becomes the area of the plain border. The smaller shape is returned, and will become the active shape of the element. This technique works for all the shapes used for active elements and does not need to know what type of shape is receiving the border.
- An etched border can be either raised or lowered.
- Lowered etched borders are often used as the outline for pushbuttons. Raised etched borders commonly delimit groups of related items in displays.
- the etched border has a color (default null). That color (or if null, the active shape background color) is used as the basis to compute a lighter and darker variant using the Java Color object's brighter() and darker() methods. All etched borders are 2 pixels wide.
- the etched border pre-computes and stores two areas it needs to outline.
- the upper-left area is computed by taking the original shape and reducing its width and height by 1 pixel.
- the upper-left corner remains fixed.
- the lower-right area is the same size, but its upper-left corner is offset by one pixel in both dimensions.
- the active shape is 4 pixels smaller in both dimensions than the original shape, and its upper-left corner is offset by 2 pixels in both dimensions. This technique works for all the shapes used for active elements and does not need to know what type of shape is receiving the border. Note that the etched border is not a perfect fit around the shape, but it is close enough for display purposes.
- a lowered border has areas outlined with colors as follows: lower-right area highlight color upper-left area shadow color
- a raised border has the colors reversed, as follows: lower-right area shadow color upper-left area highlight color
- a beveled border can be either raised or lowered.
- Lowered beveled borders are often used as the outline for text fields. Raised beveled borders can delimit groups of related items in displays, or outline buttons for a 3-D effect.
- the beveled border has a color (default null). That color (or, if null, the active shape background color) is used as the basis to compute two lighter and two darker variants using the Java Color object's brighter() and darker() methods. All beveled borders are 2 pixels wide.
- the beveled border stores four areas it needs to fill. The areas involved are actually the same as those for the etched border, but each is subsequently split in half at its lower-left and upper-right corners.
- an upper-left area is computed by taking the original shape and reducing its width and height by 1 pixel.
- the upper-left corner remains fixed.
- a similar area 1 pixel smaller all around is subtracted, leaving an annulus 1 pixel wide.
- the lower-right area is computed in a similar way as the upper-right area, but with the lower-right corner remaining fixed.
- These annular shapes have been obtained, they are split at the lower-left and upper-right corners, creating four areas to fill.
- the active shape is 4 pixels smaller in both dimensions than the original shape, and its upper-left corner is offset by 2 pixels in both dimensions. This technique works for all the shapes used for active elements, and does not need to know what type of shape is receiving the border. Note that the beveled border is not a perfect fit around the shape, but it is close enough for display purposes.
- a lowered border has the areas filled with colors as follows: outer upper area lighter shadow color outer lower area darker highlight color inner upper area darker shadow color inner lower area lighter highlight color
- a raised border has the colors reversed, as follows: outer upper area lighter highlight color outer lower area darker shadow color inner upper area darker highlight color inner lower area lighter shadow color
- a simple border selection tool 111 is provided as part of the active element configuration panel. Active elements initially have no border. The tool displays border "#1" with style "None.” The user can choose from etched, beveled and plain border styles. For etched and beveled styles, the user can choose raised or lowered. For the plain style, the user can choose a width. If border #1 112 is added to the element, border #2 113 will be displayed with style "None.” As each new border is added, a slot or space will be provided for yet another border. There is no limit to how many borders can be applied to an active element.
- a color may be used in the active shape. Such colors may be opaque or partially transparent.
- the user can change the color used inside the active shape of any element. Colors in the preferred embodiment use the Java Color object, taking advantage of 24 bits of color information plus 8 bits of transparency. Note that the effect of active elements having a "shape" is achieved by painting the border and/or the active shape background.
- the color(s) used in the active shape can be opaque or partly transparent (a fully transparent color is stored as "null" and has no hue). Borders with no color of their own specified derive their colors from the active shape background color. Most borders use this method, since this generates an attractive, coordinated appearance.
- a color selection/editor tool is provided as part of the active element configuration panel.
- This tool is used throughout the present invention whenever a color is needed such as for the element background colors, for text foreground and background colors, for border colors, for colors in the drawing tool, etc. It consists of five different panels overlaid on each other.
- a scroller 92 to select the panel of interest and a slider 150 to set the transparency.
- the color editor is capable of displaying and selecting any of about 16 million colors (256 reds x 256 greens x 256 blues) at any of 255 transparencies for a total of about 4 billion combinations.
- the color book tool consists of a panel 100 displaying a variety of colors, four radio buttons (red 101, green 102, blue 103 and gray 104) and a page slider 105.
- the "red” button is selected.
- a red color book has a constant red value everywhere on the panel. All possible green and blue combinations appear on the panel. Blue ranges from full off (0) at the top to full on (255) at the bottom. Green ranges from full off (0) at the left to full on (255) at the right.
- Changing the page of the color book with the page slider changes the fixed red value for the panel. Blue and green always cover the full spectrum. The user chooses a color from the panel by clicking on it.
- the color book is a display technique for reducing a three-dimensional problem to two dimensions.
- Each page of the book is actually a slice taken from a color cube.
- the color cube has red full-on on one face and full-off on the opposite face.
- Green is full-on on another face and full-off on the one opposite.
- Blue is full-on on another face and full-off on the remaining one.
- the color book pages described above are slices taken from the cube parallel to the face where red is full on. Likewise, the green color book takes slices parallel to the green full on face.
- the blue color book takes slices parallel to the blue full on face.
- the gray color book is just a single page long, and is provided as a convenience. All the gray values are available in the other books, but they are hard to pinpoint exactly. In the color cube, gray values lie along the line between the corner where all of red, green and blue are full on and the diagonally opposite corner where they are all full off. To construct a color book element, the current book (red, green, blue or gray) must be provided.
- the color palette tool 110 is shown in Figure 5B. It consists of a few dozen colors 112 pre- selected for the user. The user chooses a color from the palette by clicking on it. To construct a color palette editor, the list of colors to display must be provided.
- the red/green/blue tool 120 is shown in Figure 5C. It consists of a red slider 121, a green slider 122 and a blue slider 123.
- the red, green and blue sliders allow the user to adjust the color components individually. Red, green and blue values range from full off (0) to full on (255); each slider adjusts one of the components within this range. The user chooses a color by clicking on the slider and dragging it to a new position.
- the hue, saturation and brightness tool 130 is shown in Figure 5D. It consists of a hue slider 131, a saturation slider 132 and a brightness slider 133.
- the hue, saturation and brightness sliders allow the user to adjust the color components individually. Hue, saturation and brightness values range from full off (0) to full on (1 ). Each slider adjusts one of the components within this range. The user chooses a color by clicking on the slider and dragging it to a new position. Note that brightness must be at least partially on (not full left) for hue or saturation to respond. Note that saturation must be at least partially on (not full left) for hue to respond.
- the values generated are converted to and from red, green and blue values using the Java Color object's RGBtoHSB() and HSBtoRGB() methods.
- the red, green and blue text field tool 140 is shown in Fig. 5E. It consists of a red text field 141, a green text field 142 and a blue text field 143.
- the red, green and blue text fields allow the user to adjust the color components individually. Integer values between 0 and 255 can be entered. The user can also choose decimal values between 0 and 1. If any value exceeds 1 , the tool treats all three values as integers between 0 and 255, truncating any fractions. To avoid unnecessary and confusing color changes while the user is still typing, the color does not change until "Apply" is selected.
- the transparency slider 150 which appears on all of the panels but which is more clearly shown in Figure 5F, allows the user to modify a color selected by any of the five methods described above to make it partially transparent. Transparency ranges from full off (0) to full on (255). The user chooses a transparency by clicking and dragging the slider 152 to a new position. A fully- transparent color has no hue and is stored as a "null" value. Moving the transparency slider 152 to full off leaves all color components set to full off (0). When the slider 152 is moved back again, the color will be black (red, green and blue full off) no matter what color was there before.
- An image may be displayed in the active shape.
- the user can change the image displayed inside the active shape of any element.
- An image smaller than the active shape will be tiled to fill the active shape.
- An image larger than the active shape will be cropped to fit from the upper-left corner.
- a simple image selection tool 160 is shown in Fig. 6.
- the image selection tool 160 is provided as part of the active element configuration panel. It displays a list 161 showing a small sample of all the images available to the tool, plus "None". An image is selected by clicking on it. When "None" is selected, the element will use its background color instead. To construct an image editor, the list of available images must be provided. Images in the JPEG and GIF formats are currently supported.
- Size hints are used by parent elements to help with the layout of displays.
- the "end of row or column” hint if true, signals the layout routine to end the current row (in horizontal layouts) or column (in vertical layouts) after this element, even if more space is available.
- the "exact width or height in pixels” hint if the width or height in pixels is provided, signals the desire of this element to be a specific size. For example it might be used with an image having a specific size preference.
- the "full width or height” hint if true, signals the layout routine to make this element occupy the entire row (full width) or column (full height).
- the "maximum number of rows or columns” hint tells the layout routine that more or less space is needed than might otherwise be expected. If a button group will have a scroller, maximum rows might limit the items displayed. If a scrolled label has the potential to display several digits, maximum columns might ensure enough space is available to view them all.
- the "uses all remaining width or height” hint if true, signals the layout routine to give this element all the remaining width in a row (for horizontal layouts) or all the remaining height in a column (for vertical layouts). It does not mean the row or column ends with this element. It just requests that this element receive any excess pixels.
- the "vertical layout” hint tells the layout routines to use a vertical algorithm. Otherwise, a horizontal algorithm is selected. This hint is only meaningful when applied to parent elements. Other elements are atomic.
- the active portion of the element can respond to various events initiated by a pointing device such as a mouse.
- the element may be moved or resized and its configuration controls may be launched.
- the mouse events used to initiate these tasks can be changed by the user. All elements currently use the same set of events for moving, resizing and configuration. Active elements store their events in a hash table as key/value pairs for easy retrieval. This also allows more complex elements, which inherit the basic active element behaviors, to store their own events without necessarily adding more data items.
- Any element can be moved relative to its parent, even outside the parent's apparent boundaries.
- the default control to move an element is holding the control key (Ctrl) and dragging the element with the left mouse button depressed.
- Any element can be resized, even if the new size extends outside the parent's apparent boundaries.
- the default control to resize an element is holding the shift key (Shift) and dragging the element with the left mouse button depressed. Any element can be configured by the user.
- the default control to launch the active element configuration panel is clicking the right mouse button.
- Any element can launch an activity. This behavior is not restricted to “buttons” or other special elements. Behaviors that can be started by an element are all lumped under the term "activation.” Two sorts of activation are possible. Simple activation is a single event. The default control to activate a simple behavior is clicking the left mouse button. Complex activation is a series of events. An example is making a freestyle drawing in the drawing tool. The default controls for the series of events are:
- a simple event editor tool 170 is shown in Fig. 7.
- the event editor tool 170 is provided as part of the active element configuration panel. It displays a list 171 showing the events available for this element. Alternate mouse events or modifiers can be selected. To construct an event editor, the lists of editable events, mouse events and modifiers must be provided.
- Each active element has a list of associated properties. In the preferred embodiment, these properties are the shape property, the border property, the color property, the image property, the size hints property, and the event property. Active elements store their properties in a hash table as key/value pairs for easy retrieval. This also allows more complex elements, which inherit the basic active element behaviors, to store their own properties without necessarily adding more data items. Each property wraps up one or more bits of information.
- the shape property stores one shape as described previously.
- An element has exactly one shape property. To construct an element, its shape type must be provided (box, oval, etc.). If the shape is a triangle, its direction must be provided (up, down, etc.). If the shape is custom, the style (slant, point, etc.) and direction (in, out) for each edge must be provided.
- the border property stores a list of simple borders as described above. An element has at most one border property. If no borders are set, the border property is removed.
- the list of borders is stored outermost first. To construct an element with borders, its list of border types must be provided (plain, etched raised, etc.) with a color (or null) for each. For any plain borders, a width in pixels must be provided. However, an element need not have any borders. In fact, the list can be empty.
- the color property stores a single Java Color object, also described above.
- An element has at most one color property for the active shape background. If the color is null (fully transparent), the property is removed. To construct an element with background colors, its background color must be provided as red, green, blue and transparency values (0-255). An element need not have background colors. It can be null.
- the image property stores a single Java TexturePaint object plus a name describing the image. Images are compared for equality by comparing their names. An element has at most one image property for the active shape background. If it displays no image, the property is removed.
- the image property also provides the method for converting an image obtained from a graphics file to a Java TexturePaint object.
- the image file is loaded by a Java Imagelcon object.
- TexturePaint object is created from the Bufferedlmage.
- the TexturePaint object has the ability to automatically tile itself to fit any area it is asked to fill. It is ideally suited for painting an image into the background of an element.
- the size hints property stores one or more of the size hints.
- An element has at most one size hints property, which can contain any of the hints described above. If all the hints are false or zero, the property is removed.
- To construct an element with size hints all of the values (true boolean or positive integer values) described under size hints above that are desired must be provided. An element need not have size hints. All of them can be false or zero, as appropriate.
- the event property stores a single event.
- An element has a hash table of events, including at least move (move start, move and move end), grow (grow start, grow and grow end) and configure. Many elements also have simple (activate) or complex (activate start, activate and activate end) activation events. Any elements which can contain text also define events to get the focus and perform selection (select start, select and select end).
- the event property must store everything needed by the logic, i.e. software, it invokes. To construct an element with events, at least the following values must be provided for each event: its name, key, event identifier and action. It may also have event modifiers and an associated object. In the preferred embodiment, every element in the present invention has events. The move, grow and configure events are supplied automatically, but this is not required by the code.
- the event property stores a name, which may be displayed to the user in the event editor if the user elects to change the event controls.
- the event property has a key, which the present invention uses to find the event in the element's hash table.
- the event property has an event identifier, stating which of seven mouse actions has occurred. Event properties can be used to sense when the mouse is clicked, pressed or released and when the mouse is dragged (movement with a button depressed).
- the event property has an event identifier, stating any control key(s) that must accompany the event. Control keys include shift, control and alt. Some systems also provide meta and/or altgraph.
- the event property stores which active element owns the event, since that information is often needed by the logic the event launches. For example, when a button is clicked, its color is briefly changed as feedback to the user. The code needs the button's identity so that this can occur.
- the event property stores the name of an action (the logic) to perform if the event occurs. The input to such a logic is always the event property. The logic must obtain any other information it needs from items stored in the event property or directly available from the database (system- wide values).
- the event property also stores an associated object. Not all events use this item. For example, when a button is clicked to close a window, the logic must have access to both the button itself (to change its color, as above) and to the identity of the window to be closed. The window identity is stored as the associated object.
- the event property stores the Java MouseEvent that triggered the event. In some cases, such as moving an element, freestyle drawing or marking a text selection, the exact coordinates at which the mouse was last placed are used by the code in responding to the event. These can be obtained from the MouseEvent.
- Active elements which can display text are separated from simple active elements. These are called label active elements. They possess all the properties of simple active elements, plus a few new ones. The reason for the separation is that text processing is expensive, and it makes sense to streamline the process as much as possible. There is no other reason than speed for separating elements capable of displaying text from other elements.
- the text is managed by a property, and the property is stored in the same hash table as all the other properties discussed above. The distinction between simple and text-capable elements is used only to better explain the present invention and can be eliminated, if desired.
- the minimum size of a label element must be calculated.
- the one-line size of the prompt text is obtained. This is the size of the entire text up to the first "hard" line break, if any.
- the label element can have a "prompt,” which contains text to be displayed to the user. The text is not editable under normal conditions, but becomes editable if the user launches the element configuration panel. The text in the prompt can be in any style or combination of styles, and can be long or short.
- the label element can have a justification, which can be leading, trailing or centered. Label elements have some additional events to which they respond. The set of mouse events is expanded, and keystroke events are added.
- Prompts are only editable when the element configuration panel is displayed.
- Label elements require a Java listener to await keystrokes. Keystrokes are only processed if the label is currently editable. However, the listener remains engaged all the time. Events are captured when a key is "typed” or “released.” Key "press" events are ignored.
- the computer When a typing, or printable, key is typed, the computer generates one or more key pressed events, a key typed event, and a key released event.
- a key combination such as Shift-A (for capital 'a') is typed
- the computer When a key combination, such as Shift-A (for capital 'a') is typed, the computer generates one or more key pressed events for each key, a key typed event and a key released event for each key.
- the actual character typed is trapped from the key typed event, using the Java KeyEvent object's getKeyChar() method. It is stored in a holding buffer for a moment.
- key released events When key released events are received, if the key released is waiting in the typing buffer, it is processed, along with any keys ahead of it in the buffer. During rapid typing, it is possible to get a confusing series of key released events. This technique ensures that keystrokes are not lost and that they come out in the order they went in. Otherwise, key released events are treated as part of a keystroke-driven selection process.
- Text can be selected using keyboard keys, if desired.
- the arrow keys, home and end keys and page up and down keys are used to navigate around text. To move the text cursor, starting from the current cursor position:
- Control-home moves to the beginning of the text
- Control-end moves to the end of the text
- No keys move the cursor past the end of the document or prior to the beginning.
- the user holds down the shift key and navigates using the motion keys.
- the selection is highlighted in a pale color (by default, a pale magenta).
- the shift key is released, the selection is "completed.” Any further operation of arrow keys deselects the current selection and just repositions the cursor.
- Text can also be selected using a pointing device such as a mouse. For many users, this is the normal method. Label elements have complex activation events called select start, select and select end (driven by default by left mouse press, left mouse drag and left mouse release). Text is highlighted in a pale color. When the mouse is released, the selection is "completed".
- Label elements use two new property types, plus several helper classes used to style text and store layout information. Label elements have at most one justification property, which stores whether the text will be justified to the leading edge, trailing edge or center. Center justification is the default. If this value is chosen, the property is removed. "Leading” and “trailing" are sensitive to the preferred direction of the text. In right-to-left languages, "leading" will justify to the right edge and “trailing" will justify to the left edge. To construct an element with justification, the edge to use (center, leading, trailing) must be provided, in the preferred embodiment, an element need not have a justification. Center is used by default.
- a simple justification editor is provided as part of the active element configuration panel. It allows the user to select leading, trailing or centered justification for the label element. To construct a justification editor, the list of available justifications (center, leading, trailing) must be provided. Label elements have exactly one text property, which by default contains an empty text string used as the prompt. To construct an element with a prompt, the text string to display must be provided. Often, the text style for each character is also supplied. The details for text styles are discussed later. An element need not have a prompt. An empty string is used by default. A text property with no text styles provided, or with text styles for only some of its characters, is still valid. The system default text style is used for any characters lacking text style values.
- the text when selected, in label active elements and text active elements can be manipulated and various characteristics of the text determined by the present invention.
- a supplied style can be applied to each character in the current text selection.
- the character position of every "hard" line break in a text string can be identified by searching through the string for ' ⁇ n' characters.
- the size of a box needed to layout the given text in N lines, where N is provided, can be computed. It uses the one-line layout size as a basis and iterates on successively larger box sizes until all the text fits. The layout actually has to be performed to do this.
- the size of a box needed to layout given text in one line can be computed.
- Style ranges can be computed by organizing sequential runs of the same text style into style range objects. Only styles that differ from the default style are stored. This is done as a convenient space-saving measure. Word breaks can also be computed using a Java Breaklterator object to obtain the positions of every word break in a text string.
- the visible characters can be counted. This method counts all the characters in a list of layouts. This count of characters visible can be used to estimate how far to scroll on page up or up arrow commands.
- Styled text can be created. This method creates a Java AttributedString from the given text string, replacing all "hard" line breaks with a single space each. The locations of the line breaks are stored. The original text is not modified. The text styles appropriate to each character then are applied. There is a major speed efficiency available by applying one style to a group of sequential characters, rather than repeatedly applying it to each individual character.
- a style list can be created from a list of style ranges. This method converts a list of style ranges into a list of text styles, one per character.
- Finding a caret position is also possible. This method finds which character position a given x, y point lies over. It uses FindCaretLayoutGivenPoint in the process to obtain the layout containing the point, and returns both the layout number and the character position. The software can also find a caret position given an x-coordinate. This method finds which character position a given x-coordinate lies over, given the layout in which the x-coordinate lies. The present invention also allows the software to find carets after layout. After text has been laid out, this method uses FindCaretLayoutGivenCaretPos to discover which layout the caret position (and, if there is a selection, the other end of the selection) lies in.
- Text in the present invention can also be acted upon using various keys from the keyboard defining their operation.
- this method deletes it using DeleteSelection.
- the cursor is placed where the selection used to begin. Otherwise, if the cursor is not at the beginning of the text, this method backs the cursor up one character and deletes a character using DeleteCharacter.
- the control-end key scrolls the text so the end of the text is visible on screen. This is estimated in the present invention, otherwise the process would be iterative.
- the control-home key scrolls the text so the beginning of the text is visible on screen.
- the delete key deletes a current selection, if there is a current selection, using DeleteSelection. The cursor is placed where the selection used to begin. Otherwise, if the cursor is not at the end of the text, this method deletes a character using DeleteCharacter.
- the down arrow key moves the cursor, if the cursor is not on the last line of the text, down to the next line at approximately the same horizontal position. If the next line of text is currently off screen, it is scrolled on screen first. If the element's shape is non-rectangular, the text is shifted down by the number of characters in an average line. The end key moves the cursor to the end of the text on screen. The home key moves the cursor to the beginning of the text on screen. The left arrow key moves the cursor to the previous character if the cursor is not at the beginning of the text. If the cursor is at the beginning of a line, it moves to the end of the preceding line. If the preceding line is off screen, it is scrolled on screen first. If the element's shape is non-rectangular, the text is shifted up by the number of characters in an average line.
- the page down key scrolls the text down by a page if the end of the text is not visible on screen.
- the first character of the new page will be the character after the last character displayed on the previous screen.
- the page up key scrolls the text up by approximately a page if the beginning of the text is not visible on screen.
- the last character of the new page will be near the character before the first character displayed on the previous screen. This is estimated in the present invention, otherwise the process would be iterative.
- the right arrow key moves the cursor to the next character if the cursor is not at the end of the text. If the cursor is at the end of a line, it moves to the beginning of the next line. If the next line is off screen, it is scrolled on screen first. If the element's shape is non-rectangular, the text is shifted down by the number of characters in an average line.
- the scroll down one line method handles scrolling down by a line in the general case, where the text may be laid out in an arbitrary shape. It uses the mean characters on screen per line (total characters / total lines) to decide how far to scroll.
- the scroll up one line method handles scrolling up by a line in the general case, where the text may be laid out in an arbitrary shape. It uses the mean characters on screen per line (total characters / total lines) to decide how far to scroll.
- the up arrow key moves the cursor up to the previous line at approximately the same horizontal position, if the cursor is not on the first line of the text. If the previous line of text is currently off screen, it is scrolled on screen first.
- the text is shifted up by the number of characters in an average line.
- the insert character method inserts one character from the text. It also inserts the style for that character into the style list, advises the undo logger of the change in that text property, and, if a text scroller is in use, adjusts the size of its slider.
- Layout text across a shape is a helper method that lays out one line of text across an arbitrary shape. Rectangular shapes do not need to invoke it.
- the following values are provided: the text property, the shape, a Java LineBreakMeasurer object holding the styled text, a Java Rectangle object specifying how tall the next bit of text is, a list of line break positions, which of those line segments is currently in progress, and the justification to apply.
- a list of rectangles across the shape is obtained from the shape's getHorizRects() method. For each rectangle, an attempt is made to layout some text in it. This is done by using the Java LineBreakMeasurer object's nextLayout() method with the width of the rectangle and the position of the next line break. Only layouts containing at least one full word are used.
- a layout is stored as a TextLayoutStore, which also keeps track of character positions and physical display coordinates.
- the tallest layout is tracked to know how far to advance when all the rectangles are completed. If a line break has been reached, the counter advances to the next text segment. When all rectangles are complete, the y-value is moved to below the tallest layout obtained. If no layouts are obtained, it moves down one pixel. The list of layouts and current line segment number are returned.
- Layout text within a given shape method turns styled text into a list of layouts which fit within the given shape.
- the text property, shape and justification are provided.
- AttributedCharacterlterator is obtained containing the styled text.
- a Java LineBreakMeasurer is created from it.
- a rectangle describing the bounds of the shape is obtained.
- the text property is asked for a list of its line breaks. Text is laid out a line at a time, looping through the line breaks. It is important to note that it is normal for one "line” of text (commonly a single paragraph) to span many "lines" of layout.
- the next layout is obtained from the Java LineBreakMeasurer object's nextLayout() method using the width of the bounding rectangle and the position of the next line break.
- the layout must contain at least one word.
- the layout "hangs off' the bottom of the bounding rectangle by more than half its height, then the method is done. If the shape is itself rectangular, the layout can be stored as is, using a TextLayoutStore object to keep track of its starting position and coordinates. The character position is updated and then the method goes on to the next line. If the shape is non-rectangular, the existing layout is used to estimate the height required, the Java LineBreakMeasurer is backed up to its previous starting point, and the LayoutTextAcrossShape method is used to obtain layout(s) across the shape. All TextLayoutStore objects created and stored are returned. Multi-line selection is also possible with the graphic user interface of the present invention.
- This method marks a multi-line selection, using repeated calls to MarkSingleLineSelection to do the work. It marks from the start position to the end of the layout in which the start lies, any full lines, and from the end position to the beginning of the layout in which the end lies.
- a single-line selection can also be marked.
- This method builds a rectangle which surrounds all the characters in a single layout marked for selection. When the text is painted, the rectangle will be filled with the selection color. Text can also be painted. This method draws the text. First it loops through all the layouts stored, drawing them at the stored coordinates (the Java TextLayout object can be drawn directly). If the element is editable and there is a text selection, the selection is filled with the selection color. Finally, if the element is editable, its text cursor is painted (in bi-directional languages such as Arabic, there may be two cursors under some conditions). The present invention also allows for examining a current keystroke received. If the current keystroke received is a backspace, it is handled using HandleBackspaceKey.
- a key code processing method handles processing of the arrow keys, home and end keys and page up and down keys, by invoking the appropriate method above.
- a "start on word boundary" method moves the starting character position at the top of the page (if necessary) to ensure it lies at the beginning of a word.
- a particular helper class called "text layout store” stores a single Java TextLayout object plus additional information needed to display it.
- the TextLayout object contains a single line of text.
- a multi-line document requires a list of TextLayout objects to display itself.
- the layout store keeps track of the coordinates at which the layout should be displayed, the width and height of the actual text, the character position within the whole text at which this layout starts.
- This class can also figure out the x-coordinates of each character in the text it has laid out. This information is only computed if needed. Handling up and down arrow keys and marking selections require this level of detail.
- the layout is used to obtain the cursor shape at each character position in turn. The x-coordinates of the positions are saved.
- the text style helper class stores the information needed to create a single text style, in the form of a hash table of key/value pairs.
- the keys are Java TextAttribute constants.
- the values are of various types, as appropriate for each attribute.
- the text style object is in a form which can be used directly by the Java AttributedString object, which can apply the style to one or more sequential characters.
- To construct a text style at least the font family (Arial, Courier, etc.) and size (in points) must be provided. As necessary, the font weight (bold or not), posture (italic or not), strike through (on or off), underline style (one of six, or off), superscript or subscript level, foreground and background colors may also be provided.
- the font family is supplied as a string, such as "Arial” or "Courier.” Since the list of font faces available varies from computer to computer, the present invention obtains the list of available fonts from the computer.
- the family attribute expects a Java String value.
- a text style must have a family attribute. Java expresses font size as a decimal value in points (a point is 1/72 inch). Most font faces support variable size. Some only support specific integer font sizes (for example, 8-, 10- , 12- and 16-point are common).
- the size attribute expects a positive Java Float value.
- a text style must have a size attribute. Java expresses font weight as a decimal value with a practical range of 0.25 to 2.75. Traditional "bold" is assigned the value 2.0.
- Normal is assigned the value 1.0. Values less than 1.0 would appear "lighter" than normal.
- the present invention treats boldness as a Boolean attribute (on for bold, off for normal).
- the text style object converts the value.
- the weight attribute expects a Java Float value between 0.25 and 2.75. If the value is 1.0, the attribute is removed.
- Java expresses font posture as the arc tangent of the skew angle from +90 degrees (tilted right, value +infinity) to 0 degrees (normal) to -90 degrees (tilted left, value -infinity).
- Traditional "italic” is assigned the value 0.2.
- "Normal” is assigned the value 0.0. Values less than 0.0 would appear "tilted" to the left.
- the present invention treats italics as a Boolean attribute (on for italic, off for normal).
- the text style object converts the value.
- the posture attribute expects a Java Float value. If the value is 0.0, the attribute is removed.
- Java expresses strike through as a Boolean attribute, true if on, false if off.
- the strike through attribute expects a Java Boolean value. If the value is false, the attribute is removed.
- Java expresses underline as an integer attribute. There are six styles of underline provided by Java: standard (at the Roman baseline), single (1 -pixel, below the descenders), double (2-pixel), gray, dashed and dotted.
- the underline attribute expects a Java Integer value (the TextAttribute class provides constants for the six values). If the value is not among the six constants, the attribute is removed.
- Java expresses superscript and subscript as a single integer attribute, using positive values for superscripts, negative values for subscripts and zero for normal positioning.
- the Java mechanism does not currently either scale or offset the text to create a superscript or subscript.
- the text style class of the present invention provides a work around to create superscripts and subscripts. However, it is not completely satisfactory. For example, the text background color does not track with it properly. Future development will probably resolve this problem.
- the scale factor to apply to the font size is 2/3 raised to the "level" power, where level is the magnitude of the superscript or subscript value (i.e. 1 , 2, 3, etc., values above 3 generally result in superscripts too small to read).
- the font is transformed by scaling it by a factor in both dimensions and translating it by offset in height (use -offset for superscripts).
- Java uses Java Color objects for the foreground and background color attributes. If the color is fully transparent (null), the attribute is removed.
- the style range helper class stores a text style and a starting and ending character position. The start position is the first character to which the style applies. The end position is one past the last character to which the style applies. Style ranges are used when a text property is stored, to compact the style information.
- a simple text style editor 180 shown in Figure 8A, is provided as part of the active element configuration panel. It allows the user to change all the attributes of the font and to view a sample of the result.
- lists of options such as font family, font size, font weight, font posture, underlining, strike through, superscript and subscript, and foreground and background colors, as described below must be provided.
- the text style editor 180 provides a Font family selection list 182.
- a list of the available font families is provided. The user can select one by clicking on the desired font.
- names of all the available fonts must be provided.
- a scroller 183 for font size allows the user to adjust the font size up or down a point at a time using buttons.
- the user can toggle the font weight, i.e. bold, on or off by clicking on a "bold" radio button 184.
- the user can toggle the font posture, i.e. italics, on or off by clicking on an "italic" radio button 185.
- Underlining is also provided. The user can select one of six underlining styles or no underline by clicking on the desired style shown at 186.
- names of the styles of underlining, plus “None,” must be provided.
- For strike through the user can toggle strike through on or off by clicking on a "strike through” radio button 187.
- Superscripts and subscripts can also be designated by the text editor 180.
- the user can select normal, superscript or subscript positioning by clicking on the position desired at 188.
- Text editor 180 also provides the user with the option to modify the font foreground or background color.
- the buttons 189 and 190 for these colors launch the color editor described earlier.
- Text elements extend label elements by adding the concept of an editable text field to the label element's prompt.
- Text elements thus have two text properties available in which to store text, in text elements, the "prompt" takes the role of providing feedback to the user about what is desired and the text field receives typing input from the user or displays a value for editing.
- the text field and prompt interact with each other. When any text is available in the text field, the text field is displayed. When the text field is empty, the prompt is displayed. Under normal conditions, the text field is editable by the user, the prompt is not.
- the minimum size of a text element must be calculated. The longer of the text field and the prompt text is used, as an approximation, to avoid doing this twice.
- the one-line size of the text is obtained. If multiple lines are specified in its size hints, a multi-line size is then estimated. The width of the element's borders is added all around. Any exact size specified in its size hints overrides this minimum.
- the text element has a "text field,” which contains text to be edited by the user. If the user launches the element configuration panel, the prompt becomes editable and is displayed instead of the text field. The text field will reappear when configuration is completed.
- the text in the text field can be in any style or combination of styles, and can be long or short.
- an element with a text field, at least the text string to display must be provided. Often, the text style for each character is also supplied. The details for text styles are covered below. An element need not have a text field. An empty string is used by default. A text property with no text styles provided, or with text styles for only some of its characters, is still valid.
- the system default text style is used for any characters lacking text style values.
- Button elements are specializations of label elements. They are typically used to launch various activities. Like label elements, they can display text but they are not required to.
- the minimum size of a button is based on the minimum size calculated by its label ancestor, which ensures any text can be displayed. It cannot be less than a fixed minimum, currently 16 pixels, in each dimension. This ensures the button is big enough to operate.
- the border width is added all around. Any exact size specified in its size hints overrides this minimum.
- Simple buttons add the concept of an "armed" state to the behaviors of their label ancestor.
- buttons are armed when the user presses it and disarmed when the user releases it. This state is monitored by the button's paint method. The background is changed to a slightly darker color when the button is armed, and restored when it is disarmed. If the button's background is painted with an image, no visual feedback is currently provided. Simple buttons use the activate start and activate end events to invoke arm and disarm behavior and the associated repainting. With rare exceptions, simple buttons also have an activate event, specified by the programmer, to indicate what action to take when they are pressed. By default, button activation uses a left mouse click. Radio buttons extend simple buttons by adding an on/off selection state. In the present invention, these buttons serve several purposes. In groups, they provide traditional "radio button" functionality, i.e.
- buttons in the group can be on at any time.
- Such groups are used for offering a set of mutually exclusive choices. Standing alone, a radio button serves the purposes of a traditional "check box,” displaying different borders when selected and unselected. Finally, in a group with a scroller, they provide "combo box” or “scrolled list” functionality.
- radio buttons use an underlying Java JRadioButton object (not displayed) to store the selection state. This allows the use of the Java ButtonGroup object to manage exclusivity in groups of buttons.
- Parent elements have the responsibility of managing one or more child elements. Parent elements extend simple active elements. Their children can be any simple element, or any element that extends simple element behavior. So parents can have other parents as their children. This is the basis for the hierarchy of elements that builds up application screens.
- the parent-child relationship in the present invention does not imply containment.
- a child can be moved, by the user or the developer, outside the boundaries of its parent. Children move and grow with their parent, but do not need to be contained by it (some of this behavior is constrained by the layout algorithms). Children can also overlap each other. This behavior is also somewhat constrained by the layout algorithms.
- To construct a parent element the list of its children must be provided. A parent does not need to have any children. This list can be empty. Parent elements keep a list of their children. Each child has a name, used by its immediate parent for identification purposes. The developer must ensure the names for all children of one parent are unique. No "global" uniqueness is required.
- the purpose of the names is to allow code to address a specific child in a maintainable, human-readable way.
- the list of children controls the order in which they get painted. This is only important if the children overlap, in which case the last ones will appear "on top.”
- the layout of the children involves several steps.
- the first step is finding out how big the entire hierarchy of elements "wants" to be. In practice, this involves evaluating the minimum size required for each element and piecing the whole together. Good values can be obtained for most simple elements, including labels and text fields with a small amount of text. Problems arise with "large” text fields. There is no “right” answer for what size they need to be. It is possible to have a one-line high layout, very, very wide, or a one-word wide layout, very, very tall, or anything in between. When there is only one such field, size hints can handle the problem. They allow the developer to allocate "all remaining" space to a particular element. Once the required size is known, the actual layout is performed.
- Grid layouts are used for automatically generating "table" views in the present invention, and are useful in a number of custom layouts as well. Grid layouts organize their children into a two-dimensional "list of lists.” Size hints determine whether the sublists are rows or columns (i.e. is the layout horizontal or vertical), and which element is at the end of each row or column. The rows or columns do not need to have the same number of elements, nor does the size of the grid need to be specified in advance.
- the layout strategy is that all elements in the same column will be the same width. All elements in the same row will be the same height. This is true in either horizontal or vertical layouts. The only difference between them is whether sequential elements go in the same row (horizontal) or column (vertical). Arrays of column widths and row heights are calculated, using the desired minimum size of each element as a basis and finding the widest element in each column and the tallest element in each row. The columns will commonly each have a different width. The rows will sometimes each have a different height. Size hints can designate one column to absorb all excess width if desired, and one row to absorb all excess height. The actual layout is straightforward once the column widths and row heights have been calculated. The grid is intended to allow widths exceeding the available screen space by wrapping each row onto two or more lines, retaining all other grid behaviors described above.
- Button groups extend grid elements to provide exclusivity. All children of a button group must be radio button elements. Exactly one child must be selected all the time. There is no state with all children deselected. To implement this sort of behavior, radio buttons in a plain grid layout are used. The developer must then manage both selection and deselection.
- Overlays provide a way of displaying several alternatives in series. Exactly one of the alternatives is displayed at a time. Typically the children of an overlay element are each parent elements of some sort, but that is not a requirement. The overlay provides methods to set which child is currently in view. Controls which allow the user to select from the available alternatives must be provided externally. Overlay elements can provide "wizard" or "tabbed panel” behavior. The minimum size of an overlay will be the size of the largest of its children. To construct an overlay element, the current child to display must be provided.
- Scrollers serve two purposes. One is to allow traversal of material too large to fit in the available space.
- the present invention has vertical scroll bars for grid elements and for label or text elements to fill that need.
- the second is to allow the user to choose from a range of numeric values without typing.
- the present invention uses both horizontal and vertical sliders and scrolled labels for that purpose.
- Scrollers are customized parent elements whose children work together to create the appearance of a traditional scroll bar, slider, etc. Unlike traditional windowing environments, scrollers of the present invention can be freely changed by the user.
- the individual pieces 201-204 shown in Fig. 8A
- the scroller can be dragged away from the item it controls and still function. Some of these behaviors are affected by the layout algorithms.
- the vertical grid scroller creates the appearance of a traditional scroll bar. It has up and down buttons, a slider, and a trough in which the slider appears to sit. To be useful, it must be associated with a grid element whose size hints indicate how many rows are to be displayed, and the grid must contain more than that many rows.
- the scroller can collapse its slider and trough if the available height is insufficient. Only the up and down buttons remain. For example, a list restricted to one item in height paired with a collapsed scroller works something like a standard combo box. Assuming these conditions are met, the scroller allows the user to slide the grid view up and down, bringing rows into the view from off screen.
- the vertical text scroller 200 creates the appearance of a traditional scroll bar. It has up and down buttons 201 and 202, a slider 203, and a trough 204 in which the slider appears to sit. To be useful, it must be associated with a label or text element containing more text than will fit within its boundaries. On layout, the scroller can collapse its slider and trough if the available height is insufficient, only the up and down buttons remain.
- the scroller allows the user to slide the text view up and down, bringing lines into the view from off screen. Clicking the up or down buttons scrolls the text by one line, until the beginning or end of the text is reached. Dragging the slider with the mouse button depressed scrolls the text freely between its limits. Like the horizontal text scroller, the trough is not active at this time. Clicking in it has no effect.
- Horizontal and vertical sliders allow the user to adjust numeric values between fixed limits without typing, and without knowing the actual values. The numeric limits are assigned to the ends of the slider. The user drags the slider between them using the mouse. Values range linearly between the limits.
- the slider is composed of a trough and a knob. Only the knob is active.
- Scrolled labels behave like a list of values with up and down buttons. The value is changed each time a button is clicked. They are suitable for fixed ranges of integer values. To construct a scrolled label, its minimum, maximum and current values must be provided.
- the Drawing Tool 210 of the present invention is constructed using the methods previously described, i.e. creating active elements for each component of the drawing tool.
- the drawing tool 210 allows the user to assemble a collection of shapes. Individual shapes can be easily manipulated in various ways. The collection of shapes can also be moved and resized. A finished drawing can be named and saved. When the drawing is reloaded, the shapes can again be manipulated individually.
- the save format is very compact (equations for the shapes, plus color and border width information) and does not lose accuracy compared to the original drawing. To construct a drawing tool, no special information is required. To reconstruct a drawing, the list of shapes to display must be provided. Details for the shapes are discussed below.
- Shapes are stored in the drawing tool as Java Shape objects. They are stored in the database as coordinates from the Java Pathlterator associated with the shape. To reconstruct a shape, the following information must be provided: the type of shape (oval, triangle, etc.), its border width, its rotation angle, its center and border colors, its Java winding rule, and the list of Java segment types and coordinates which define the shape.
- Each shape has a border around it, initially one pixel wide. The current width of the border is stored for each shape.
- Each "solid" shape has a center color and a border color. They may be the same if desired. Lines and scribbles only have the border color.
- the color editor tool used here was described earlier. Like other colors in the present invention, colors in the drawing tool can be opaque or partially transparent. To set the center color, use the color editor to select the color desired, then click on the box 215 labeled "center.” The border color is set similarly by clicking on the box 216 labeled "border.” The border and center colors are stored for each shape. A simple click or click-and-drag model is used for all the actions in the drawing tool, which makes it fairly easy to use.
- the user selects the "set colors” button 217. When the user then clicks on a shape, its center and border colors are changed to the currently selected center and border colors. To get the colors used by a shape, the user selects the "get colors” button 218. When the user then clicks on a shape, its center and border colors become the currently selected center and border colors.
- 220 allows the user to push the shape in back of all other overlapping shapes. This is implemented in the code by moving the shape to the beginning of the shape list.
- a delete button 221 is coded so that when a user selects button 221 and then selects a shape, the shape is deleted from the drawing.
- a move button 222 is coded to allow the use to move a shape around the screen.
- Button 222 is coded to cause a shape to follow a pointing device cursor on which the user clicks and drags. When the user clicks and drags a shape, it follows the mouse cursor around the screen.
- Drawing tool shapes are confined to the drawing tool center area 221, but can be dragged off the edge of it and out of sight. The "pan” feature described below can be used to shift the shapes until the missing one reappears. Once it reappears, then it can be moved back where it belongs.
- a resize button 223 is included to allow the user to resize a shape.
- the user clicks and drags a shape it is resized following the mouse cursor around the screen. If the shape has been rotated, the direction of resize may not be very intuitive.
- Resize is implemented along the axes of the shape itself, independent of rotation, so as not to skew the angles in box, rounded box or right triangle shapes.
- a shape can be rotated using a rotate button 224.
- the code is written such that when the user clicks and drags a shape, it spins around its approximate center. The user can rotate it freely in either direction as much as desired.
- the rotation angle is stored with each shape.
- each shape can also be changed with button 225.
- button 225 When the user clicks and drags a shape after selecting button 225, its border width can grow or shrink.
- the current border width is stored with each shape. Borders are drawn centered on the outline of the shape. In the drawing tool of the present invention, several actions affect all the shapes at once.
- the pan all button 226, when activated, causes all the shapes to follow the pointing device cursor around the screen when the user clicks anywhere in the drawing area.
- the initial click does not have to be anywhere particular.
- the zoom button 227 when activated, causes all the shapes to grow or shrink together following the pointing device cursor around the screen when the user clicks anywhere in the drawing area.
- the initial click does not have to be anywhere particular.
- the old drawing is erased.
- the user To load a drawing to the screen, the user must supply a drawing name to text field 240 and then selects button 229.
- the drawing name When the drawing name is supplied, the drawing is loaded into the drawing area 211 of drawing tool 210 and is added to whatever appears on the screen. If the old drawing is to be removed first, select new drawing before loading.
- the user To save a drawing, the user must supply a drawing name to text field 240 and then selects button 230. When the user supplies a drawing name and saves it, the drawing will be stored.
- the present invention can generate a single-record view of an object, or a multi-record tabular view of a group of like objects semi-automatically.
- a multi-record view 250 is like a table. Each object occupies one row 252. Each field 254 within the object occupies one column. A header row 256 lists the field names. To construct a multi-record view, the list of records to display must be provided. For each record, the fields to display and their formatted values must be provided. Sorting takes place on the field contents themselves, not the formatted values which may actually be displayed.
- the multi-record view allows a user to sort on any column.
- the header row 256 consists of active buttons 257 labeling each column. Clicking one of the buttons sorts the table according to the contents of that column. The sorts are "intelligent.” Since the underlying data are true Java objects, numbers and dates sort just as correctly as text strings. Clicking the same button again reverses the sense of the sort, from increasing to decreasing or back again.
- the multi-record view also provides the ability to display single-record view of any row.
- the left-most column contains a button 258 for each row. Clicking the button opens a single-record display of the object in that row.
- a single-record view 270 is like a two-column table.
- the left column 272 contains the field names and the right column 274 contains the data.
- Simple fields containing text strings, numbers, dates, etc. are displayed as text fields for editing.
- the single- record views also contain buttons to display related objects.
- To construct a single-record view the list of fields to display and their formatted values must be provided. If any of the fields are themselves objects within the present invention, a method exists to request the list of fields for that embedded object in turn. If the displayed object is itself a field within objects of other types, those object types must be provided to construct the single-record view.
- the single-record view displays push button connections to them, as shown in Fig.
- Any embedded object can be expanded.
- Fields that contain other objects are displayed as radio buttons 280 and 300. Pressing such a button 300 expands the embedded field as a single- record view 302 contained within and indented relative to the initial single-record view. If the expanded field itself contains other objects 304, those objects can also be expanded. Both indentation and slight color coding help to isolate such expanded fields.
- One button in the single-record view allows the user to display a multi-record view of all objects of the same type as the current object.
- Other buttons 306 may appear in the single-record view if the current object is a field within other objects. All "related" objects can be displayed, i.e. objects which contain this specific object in one of their fields.
- the present invention uses certain "constants” that may be made available to the user to configure, depending on the developer's inclination and the application.
- the TIMER_DELAY “constant” is the delay time used by label elements for the layout and repaint timer. Its default value is 250 milliseconds. The timer keeps layout and repaint activities from bogging down a rapid typist. No matter how rapidly changes are supplied, layout only occurs every 250 milliseconds.
- the EMBEDDED NDENT "constant" is how far embedded objects are indented from their parent in single-record views. The default value is 20 pixels per level. So if a MoneyMovement object contains an Account object, the Account object will be indented by 20 pixels. If that Account itself contains a Currency object, the Currency object will be indented 40 pixels, and so forth.
- the FACTO R_PER_PIXEL “constant” is the logarithmic scale factor used for the drawing tool "zoom all” capability. The default value is 0.01/pixel. As the user drags the pointer device in the "bigger” direction during zoom (east and/or south, the +x and +y directions), the sizes of the shapes double after the first 100 pixels. After the next 100 pixels they double again, and so on. If the pointing device moves in the "smaller” direction (west and/or north), the sizes halve after the first 100 pixels.
- the BORDER_FACTOR_PER_PIXEL “constant” is the linear border scale factor used to change the drawing tool edge width. Its default value is 0.1/pixel. As the user drags the pointing device in the "bigger" direction (east and/or south, the +x and +y directions), the border width increases by 10 pixels for every 100 pixels of drag. If the pointing device moves in the "smaller” direction (west and/or north), the width decreases by 10 pixels for every 100 pixels of drag.
- the DRAWING_COLOR “constant” is the color displayed by the drawing tool when it first starts up.
- the TEXT_CARET_COLOR “constant” is the color used to display the caret in editable text.
- the MAX_LABEL_WIDTH “constant” is the maximum size the layout algorithm is willing to assign to a text field or label.
- the default value is 250 pixels.
- the upper limit avoids problems with large text, which has no natural default size.
- the MIN_BTN_SIZE “constant” is the minimum size allowed for a button element.
- the default value is 16 pixels.
- the lower limit ensures buttons are "big enough" to push.
- the MIN_BORDER “constant” is the minimum size border that parent elements leave around their children during layout.
- the default value is 2 pixels.
- the MINJNNER “constant” is the minimum size allowed for the interior, active shape of an element.
- the default value is 4 pixels.
- the SELECT_COLOR “constant” is the color used to highlight text when it has been selected.
- the BUTTON_COLOR “constant” is the color used to outline radio buttons when they are "on” or selected.
- the DEFAULT_STYLE “constant” is the default text style used when no specific style is provided.
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- Human Computer Interaction (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Stored Programmes (AREA)
- Processing Or Creating Images (AREA)
- User Interface Of Digital Computer (AREA)
- Digital Computer Display Output (AREA)
- Devices For Executing Special Programs (AREA)
Abstract
Priority Applications (6)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
CA002359997A CA2359997A1 (fr) | 1999-11-12 | 2000-11-13 | Interface utilisateur graphique |
IL14431400A IL144314A0 (en) | 1999-11-12 | 2000-11-13 | Graphical user interface |
JP2001536685A JP2003529818A (ja) | 1999-11-12 | 2000-11-13 | グラフィックユーザインタフェース |
NZ512939A NZ512939A (en) | 1999-11-12 | 2000-11-13 | Graphical user interface having only one window with all elements being active (changable properties) |
EP00978675A EP1259880A2 (fr) | 1999-11-12 | 2000-11-13 | Interface utilisateur graphique |
AU16113/01A AU1611301A (en) | 1999-11-12 | 2000-11-13 | Graphical user interface |
Applications Claiming Priority (2)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US16488499P | 1999-11-12 | 1999-11-12 | |
US60/164,884 | 1999-11-12 |
Publications (2)
Publication Number | Publication Date |
---|---|
WO2001035217A2 true WO2001035217A2 (fr) | 2001-05-17 |
WO2001035217A3 WO2001035217A3 (fr) | 2002-09-19 |
Family
ID=22596510
Family Applications (2)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
PCT/US2000/031231 WO2001035216A2 (fr) | 1999-11-12 | 2000-11-13 | Systeme informatique a composants toute categorie |
PCT/US2000/031351 WO2001035217A2 (fr) | 1999-11-12 | 2000-11-13 | Interface utilisateur graphique |
Family Applications Before (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
PCT/US2000/031231 WO2001035216A2 (fr) | 1999-11-12 | 2000-11-13 | Systeme informatique a composants toute categorie |
Country Status (9)
Country | Link |
---|---|
EP (2) | EP1259880A2 (fr) |
JP (2) | JP2003529818A (fr) |
AU (2) | AU1606201A (fr) |
CA (2) | CA2359997A1 (fr) |
IL (2) | IL144314A0 (fr) |
NZ (1) | NZ512939A (fr) |
RU (2) | RU2001122576A (fr) |
WO (2) | WO2001035216A2 (fr) |
ZA (1) | ZA200106526B (fr) |
Cited By (1)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
CN117893637A (zh) * | 2024-03-15 | 2024-04-16 | 杭州广立微电子股份有限公司 | 一种数据处理方法及装置 |
Families Citing this family (34)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
CA2836758C (fr) | 2003-05-23 | 2017-06-27 | Roger D. Chamberlain | Systeme de stockage et de traitement de donnees intelligent utilisant des dispositifs fpga |
US9715678B2 (en) | 2003-06-26 | 2017-07-25 | Microsoft Technology Licensing, Llc | Side-by-side shared calendars |
US7707255B2 (en) | 2003-07-01 | 2010-04-27 | Microsoft Corporation | Automatic grouping of electronic mail |
US9015621B2 (en) | 2004-08-16 | 2015-04-21 | Microsoft Technology Licensing, Llc | Command user interface for displaying multiple sections of software functionality controls |
US8255828B2 (en) | 2004-08-16 | 2012-08-28 | Microsoft Corporation | Command user interface for displaying selectable software functionality controls |
US7895531B2 (en) | 2004-08-16 | 2011-02-22 | Microsoft Corporation | Floating command object |
US7703036B2 (en) | 2004-08-16 | 2010-04-20 | Microsoft Corporation | User interface for displaying selectable software functionality controls that are relevant to a selected object |
US8146016B2 (en) | 2004-08-16 | 2012-03-27 | Microsoft Corporation | User interface for displaying a gallery of formatting options applicable to a selected object |
US7747966B2 (en) | 2004-09-30 | 2010-06-29 | Microsoft Corporation | User interface for providing task management and calendar information |
US8239882B2 (en) * | 2005-08-30 | 2012-08-07 | Microsoft Corporation | Markup based extensibility for user interfaces |
US8627222B2 (en) | 2005-09-12 | 2014-01-07 | Microsoft Corporation | Expanded search and find user interface |
US9727989B2 (en) | 2006-06-01 | 2017-08-08 | Microsoft Technology Licensing, Llc | Modifying and formatting a chart using pictorially provided chart elements |
US7921046B2 (en) | 2006-06-19 | 2011-04-05 | Exegy Incorporated | High speed processing of financial information using FPGA devices |
US7840482B2 (en) | 2006-06-19 | 2010-11-23 | Exegy Incorporated | Method and system for high speed options pricing |
US7660793B2 (en) | 2006-11-13 | 2010-02-09 | Exegy Incorporated | Method and system for high performance integration, processing and searching of structured and unstructured data using coprocessors |
US8326819B2 (en) | 2006-11-13 | 2012-12-04 | Exegy Incorporated | Method and system for high performance data metatagging and data indexing using coprocessors |
US8484578B2 (en) | 2007-06-29 | 2013-07-09 | Microsoft Corporation | Communication between a document editor in-space user interface and a document editor out-space user interface |
US8762880B2 (en) | 2007-06-29 | 2014-06-24 | Microsoft Corporation | Exposing non-authoring features through document status information in an out-space user interface |
US7444347B1 (en) | 2007-11-16 | 2008-10-28 | International Business Machines Corporation | Systems, methods and computer products for compression of hierarchical identifiers |
US10229453B2 (en) | 2008-01-11 | 2019-03-12 | Ip Reservoir, Llc | Method and system for low latency basket calculation |
US9588781B2 (en) | 2008-03-31 | 2017-03-07 | Microsoft Technology Licensing, Llc | Associating command surfaces with multiple active components |
US9665850B2 (en) | 2008-06-20 | 2017-05-30 | Microsoft Technology Licensing, Llc | Synchronized conversation-centric message list and message reading pane |
US8490026B2 (en) * | 2008-10-27 | 2013-07-16 | Microsoft Corporation | Painting user controls |
US8397222B2 (en) | 2008-12-05 | 2013-03-12 | Peter D. Warren | Any-to-any system for doing computing |
EP2370946A4 (fr) | 2008-12-15 | 2012-05-30 | Exegy Inc | Procédé et appareil de traitement à grande vitesse de données de profondeur de marché financier |
US9046983B2 (en) | 2009-05-12 | 2015-06-02 | Microsoft Technology Licensing, Llc | Hierarchically-organized control galleries |
US10037568B2 (en) | 2010-12-09 | 2018-07-31 | Ip Reservoir, Llc | Method and apparatus for managing orders in financial markets |
US11062238B2 (en) * | 2011-08-11 | 2021-07-13 | Cerner Innovation, Inc. | Recreating a time-ordered sequence of events |
US10121196B2 (en) | 2012-03-27 | 2018-11-06 | Ip Reservoir, Llc | Offload processing of data packets containing financial market data |
US9990393B2 (en) | 2012-03-27 | 2018-06-05 | Ip Reservoir, Llc | Intelligent feed switch |
US10650452B2 (en) | 2012-03-27 | 2020-05-12 | Ip Reservoir, Llc | Offload processing of data packets |
US11436672B2 (en) | 2012-03-27 | 2022-09-06 | Exegy Incorporated | Intelligent switch for processing financial market data |
US8997008B2 (en) | 2012-07-17 | 2015-03-31 | Pelicans Networks Ltd. | System and method for searching through a graphic user interface |
US9897986B2 (en) | 2013-10-29 | 2018-02-20 | Regal Beloit America, Inc. | System and method for enabling a motor controller to communicate using multiple different communication protocols |
Citations (3)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US4555775A (en) * | 1982-10-07 | 1985-11-26 | At&T Bell Laboratories | Dynamic generation and overlaying of graphic windows for multiple active program storage areas |
EP0274087A2 (fr) * | 1987-01-05 | 1988-07-13 | Computer X, Inc. | Interface homme-machine |
US5652850A (en) * | 1995-06-07 | 1997-07-29 | Ast Research, Inc. | Panel creation engine using templates to automatically configure user interface screeen displays |
Family Cites Families (1)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
CN1204515C (zh) * | 1997-04-22 | 2005-06-01 | 格雷格·赫瑟林顿 | 自由格式数据处理的方法和设备 |
-
2000
- 2000-11-13 CA CA002359997A patent/CA2359997A1/fr not_active Abandoned
- 2000-11-13 AU AU16062/01A patent/AU1606201A/en not_active Abandoned
- 2000-11-13 WO PCT/US2000/031231 patent/WO2001035216A2/fr not_active Application Discontinuation
- 2000-11-13 RU RU2001122576/09A patent/RU2001122576A/ru not_active Application Discontinuation
- 2000-11-13 NZ NZ512939A patent/NZ512939A/en unknown
- 2000-11-13 RU RU2001122574/09A patent/RU2001122574A/ru not_active Application Discontinuation
- 2000-11-13 WO PCT/US2000/031351 patent/WO2001035217A2/fr not_active Application Discontinuation
- 2000-11-13 IL IL14431400A patent/IL144314A0/xx unknown
- 2000-11-13 IL IL14431900A patent/IL144319A0/xx unknown
- 2000-11-13 CA CA002360067A patent/CA2360067A1/fr not_active Abandoned
- 2000-11-13 JP JP2001536685A patent/JP2003529818A/ja active Pending
- 2000-11-13 AU AU16113/01A patent/AU1611301A/en not_active Abandoned
- 2000-11-13 EP EP00978675A patent/EP1259880A2/fr not_active Withdrawn
- 2000-11-13 JP JP2001536684A patent/JP2003514300A/ja active Pending
- 2000-11-13 EP EP00978614A patent/EP1247174A2/fr not_active Withdrawn
-
2001
- 2001-08-08 ZA ZA200106526A patent/ZA200106526B/en unknown
Patent Citations (4)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US4555775A (en) * | 1982-10-07 | 1985-11-26 | At&T Bell Laboratories | Dynamic generation and overlaying of graphic windows for multiple active program storage areas |
US4555775B1 (en) * | 1982-10-07 | 1995-12-05 | Bell Telephone Labor Inc | Dynamic generation and overlaying of graphic windows for multiple active program storage areas |
EP0274087A2 (fr) * | 1987-01-05 | 1988-07-13 | Computer X, Inc. | Interface homme-machine |
US5652850A (en) * | 1995-06-07 | 1997-07-29 | Ast Research, Inc. | Panel creation engine using templates to automatically configure user interface screeen displays |
Cited By (2)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
CN117893637A (zh) * | 2024-03-15 | 2024-04-16 | 杭州广立微电子股份有限公司 | 一种数据处理方法及装置 |
CN117893637B (zh) * | 2024-03-15 | 2024-06-11 | 杭州广立微电子股份有限公司 | 一种数据处理方法及装置 |
Also Published As
Publication number | Publication date |
---|---|
EP1259880A2 (fr) | 2002-11-27 |
RU2001122576A (ru) | 2003-09-20 |
CA2359997A1 (fr) | 2001-05-17 |
WO2001035217A3 (fr) | 2002-09-19 |
AU1606201A (en) | 2001-06-06 |
RU2001122574A (ru) | 2005-09-20 |
AU1611301A (en) | 2001-06-06 |
WO2001035216A2 (fr) | 2001-05-17 |
NZ512939A (en) | 2004-06-25 |
CA2360067A1 (fr) | 2001-05-17 |
JP2003514300A (ja) | 2003-04-15 |
EP1247174A2 (fr) | 2002-10-09 |
IL144319A0 (en) | 2002-05-23 |
JP2003529818A (ja) | 2003-10-07 |
IL144314A0 (en) | 2002-05-23 |
WO2001035216A3 (fr) | 2002-08-08 |
ZA200106526B (en) | 2004-07-19 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
WO2001035217A2 (fr) | Interface utilisateur graphique | |
JP3866302B2 (ja) | プロセッサーベースの装置の操作方法 | |
US6891551B2 (en) | Selection handles in editing electronic documents | |
US7895536B2 (en) | Layer editor system for a pen-based computer | |
US5986657A (en) | Method and apparatus for incorporating expandable and collapsible options in a graphical user interface | |
US5644737A (en) | Method and system for stacking toolbars in a computer display | |
US6348935B1 (en) | Programmable tree viewer graphical user interface with integrated control panel | |
US6941507B2 (en) | Insertion point bungee space tool | |
US5528259A (en) | Method and system for multi-dimensional scrolling of displayed data collections in a data processing system | |
US6057836A (en) | System and method for resizing and rearranging a composite toolbar by direct manipulation | |
US7870501B2 (en) | Method for hollow selection feedback | |
JPH0756840A (ja) | プロセッサーベースの装置の操作方法 | |
EP0650129B1 (fr) | Méthode, système et support lisible par ordinateur pour le formatage automatique d'un texte sélectionné par l'utilisateur | |
JPH0756841A (ja) | プロセッサーベースの装置の操作方法 | |
US20080109751A1 (en) | Layer editor system for a pen-based computer | |
US6636244B1 (en) | Pointing device selection method | |
EP0483777A2 (fr) | Interface graphique tridimensionnel | |
JPH0721754B2 (ja) | グラフィカル・ユーザ・インターフェース | |
CA2233819A1 (fr) | Imagerie informatisee utilisant des composantes graphiques | |
JPH06301505A (ja) | コンピュータ制御ディスプレイ・システム | |
JP2003303047A (ja) | 画像入力及び表示システム、ユーザインタフェースの利用方法並びにコンピュータで使用可能な媒体を含む製品 | |
JPH0689324A (ja) | フォーム確立ツールキットおよびフォーム確立方法 | |
US7703038B1 (en) | Methods and apparatus for creating a quick canvas | |
EP0541237A1 (fr) | Modification de champ d'entrée des données dans une interface utilisateur graphique | |
Myers | Gilt Reference Manual: A Simple Interface Builder for Garnet |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
AK | Designated states |
Kind code of ref document: A2 Designated state(s): AE AL AM AT AU AZ BA BB BG BR BY CA CH CN CR CU CZ DE DK DM EE ES FI GB GD GE GH GM HR HU ID IL IN IS JP KE KG KP KR KZ LC LK LR LS LT LU LV MA MD MG MK MN MW MX NO NZ PL PT RO RU SD SE SG SI SK SL TJ TM TR TT TZ UA UG US UZ VN YU ZA ZW |
|
AL | Designated countries for regional patents |
Kind code of ref document: A2 Designated state(s): GH GM KE LS MW MZ SD SL SZ TZ UG ZW AM AZ BY KG KZ MD RU TJ TM AT BE CH CY DE DK ES FI FR GB GR IE IT LU MC NL PT SE TR BF BJ CF CG CI CM GA GN GW ML MR NE SN TD TG |
|
121 | Ep: the epo has been informed by wipo that ep was designated in this application | ||
ENP | Entry into the national phase |
Ref document number: 2359997 Country of ref document: CA Ref document number: 2359997 Country of ref document: CA Kind code of ref document: A |
|
WWE | Wipo information: entry into national phase |
Ref document number: 2000978675 Country of ref document: EP |
|
ENP | Entry into the national phase |
Ref document number: 2001 536685 Country of ref document: JP Kind code of ref document: A |
|
WWE | Wipo information: entry into national phase |
Ref document number: 144314 Country of ref document: IL Ref document number: 512939 Country of ref document: NZ Ref document number: PA/A/2001/007109 Country of ref document: MX |
|
WWE | Wipo information: entry into national phase |
Ref document number: IN/PCT/2001/803/KOL Country of ref document: IN |
|
WWE | Wipo information: entry into national phase |
Ref document number: 2001/06526 Country of ref document: ZA Ref document number: 200106526 Country of ref document: ZA |
|
REG | Reference to national code |
Ref country code: DE Ref legal event code: 8642 |
|
AK | Designated states |
Kind code of ref document: A3 Designated state(s): AE AL AM AT AU AZ BA BB BG BR BY CA CH CN CR CU CZ DE DK DM EE ES FI GB GD GE GH GM HR HU ID IL IN IS JP KE KG KP KR KZ LC LK LR LS LT LU LV MA MD MG MK MN MW MX NO NZ PL PT RO RU SD SE SG SI SK SL TJ TM TR TT TZ UA UG US UZ VN YU ZA ZW |
|
AL | Designated countries for regional patents |
Kind code of ref document: A3 Designated state(s): GH GM KE LS MW MZ SD SL SZ TZ UG ZW AM AZ BY KG KZ MD RU TJ TM AT BE CH CY DE DK ES FI FR GB GR IE IT LU MC NL PT SE TR BF BJ CF CG CI CM GA GN GW ML MR NE SN TD TG |
|
WWP | Wipo information: published in national office |
Ref document number: 2000978675 Country of ref document: EP |
|
WWW | Wipo information: withdrawn in national office |
Ref document number: 2000978675 Country of ref document: EP |