Patent Application
20140244653
Users of computing devices often use messages (such as email messages, text messages, and voicemail messages) as reminders of actions that the users need to take. For example, users often leave email messages in their email inboxes as reminders to reply to those email messages. Message inboxes, in other words, often double as to-do lists. It is widely acknowledged, however, that message inboxes are not optimal for use as to-do lists. Despite this widespread knowledge, users continue to use message inboxes for this purpose.
A computer system enables a user to manually order messages in a list on a per-message basis. More generally, the system enables data elements of a plurality of types, such as messages, appointments, and tasks, to be combined into a single list, which may be manually ordered by the user on a per-element basis. The system also enables the user to mark any element in a list as complete. The system takes an appropriate action in response to a list element being marked as complete, such as removing the element from the list.
Other features and advantages of various aspects and embodiments of the present invention will become apparent from the following description and from the claims.
Embodiments of the present invention may be used to enable a user to manually reorder data elements in a data set. A “data set,” as that term is used herein, refers to a set of data elements. A “data element,” as that term is used herein, refers to any data structure, in any format, stored on one or more non-transitory computer-readable media. A data element may represent any information, such as a single number (e.g., a single binary number or a single decimal number), an email message, a calendar appointment, or a task (alternatively referred to as a “to-do” or a “reminder”).
A data element has a value. For example, a data element may have a value of the integer 1, a value of the character string “hello,” a value representing the list of integers (1, 2, 3), a value representing the contents of a particular email message, a value representing the contents of a particular calendar appointment, or a value representing the contents of a particular task. The term “contents” herein refers to data and/or metadata. For example, the “contents” of an email message may include any one or more of the following: the body of the email message, the addressee(s) of the email message, the sender of the email message, any attachments to the email message, and the date on which the email message was sent.
The value of a data element may change over time. For example, a particular data element may have a value of 1 at one time, a value of 7 at another time, and a value of 3 at yet another time. The act of changing the value of a data element to a particular value typically is referred to as “assigning” the particular value to the data element.
A data element may have a data type. The data type of a data element may impose restrictions on the range of the data element's values. For example, if a data element has a data type of integer, then the range of the data element's values may include only integers (e.g., a subset of the set of integers). Note that the data types of particular data elements are expressed herein within angled brackets for ease of explanation. Note that particular data type labels used herein, such as integer and character, are intended to be illustrative, not limiting, and do not necessarily correspond to the labels used within any particular programming language or computer program.
The integer data type typically is considered to be a primitive data type, because it cannot be further decomposed into other data types. Other common examples of primitive data types include floating point numbers, Boolean logic values, and characters.
A composite data type (also referred to as a “complex data type” or a “compound data type”) may be composed of at least two component data types, each of which may be a primitive data type or a composite data type. For example, a composite data type may consist of a combination of an integer and a character string. Common examples of composite data types include arrays, records, and unions.
The term “abstract data type” sometimes is used to refer to the data type of a class of data structures that have similar behavior. Common examples of abstract data types include containers, queues, deques, priority queues, lists, maps, multimaps, multisets, sets, stacks, strings, and trees.
In computer science, distinctions sometimes are made between primitive data types which are built in to a particular programming language (such as the <int> type in the C programming language) and primitive data types which are not built in to the programming language but which may be added to programs by programmers using the programming language. Terms such as “built in” data type and “basic” data type may be used to distinguish between primitive data types that are built in to a programming language and those that are not built in to the programming language. These and other distinctions may also be applied to composite data types and abstract data types. No such distinction is made herein, and embodiments of the present invention may be applied to any data type, whether or not it is built in to a particular programming language. In general, the term “data type,” as used herein, should be understood to include primitive data types, composite data types, and abstract data types.
The term “data set,” as mentioned above, refers herein to a set of data elements. A data set may include any number (zero, one, or more) of data elements. A data set may, for example, consist of data elements all having the same data type (e.g., <int> or <char>), or may include some data elements having one data type and other data elements having another data type. More generally, a data set may include any number of data elements, each having any data type.
A data element may be a data set. In other words, the data type of a data element may be a type of data set, such as an array data type or a list data type. For example, a list is a data element and also a data set, because a list data element includes a set of data elements. A data set may include zero, one, or more data elements which themselves are data sets.
Data elements may be added to and/or removed from a data set. The value of a data element in a data set may change over time in any of the ways disclosed herein for individual data elements.
The term “data type” sometimes is used to refer specifically to a data type of a data element within a particular computer program and defined in accordance with a particular programming language. For example, a particular computer program written in the C programming language may include a variable having the name “age” and having a data type of <int>. In this example:
As used herein, the term “data element” includes, but is not limited to, data elements within a computer program as defined by the programming language in which the computer program is written. Similarly, the term “data type” includes, but is not limited to, data types according to the programming language in which the computer program is written. For example, a particular computer program may use the C programming language to create a particular data element having the name “age” and having a data type of array (e.g., <int[ ]>) in the C programming language). This “age” data element may include a plurality of data elements having the name “person.” Each such “person” data element Pn may include two data elements:
For example, assume that the “age” data element contains the following three “person” data elements:
Since the values of the “sequenceID” data elements of the “person” data elements in the “age” data element represent the indices of the “person” data elements within the “age” data element, the set of “sequenceID” data elements for all of the “person” data elements may specify a sequence (ordering) of the “person” data elements within the “age” data element. For example, such a sequence may be derived by applying a sorting function to the “sequenceID” data elements of the “person” data elements to produce an ordering of the “sequenceID” data elements, and then mapping the ordered “sequenceID” data elements to their corresponding “person” data elements to obtain the sequence of the “person” data elements. For example, if the sorting function that is applied to the “sequenceID” data elements in an ascending sort function, then the resulting ordering of the “person” data elements is (PI, P2, P0), whereas if the sorting function that is applied to the “sequenceID” data elements is a descending sort function, then the resulting ordering of the “person” data elements is (P0, P2 P1).
The “age” data element described above may be manifested to a user of the computer program by manifesting (e.g., displaying) the “person” data elements of the “age” data element in the sequence obtained for the “person” data elements. In other words, the computer program may manifest the “age” data structure to the user in the form of a list. Furthermore, the computer program may enable the “age” data structure to exhibit the behavior of a list, such as by allowing new data elements to be inserted into the list and allowing existing elements to be removed from the list. In this example, although the “age” data structure is implemented using a data structure having a data type of array, such a data structure may exhibit the same or similar behavior as a data structure having a data type of list, at least from the perspective of the computer program's user. Such a data structure is an example of a data element having a data type of list, despite the fact that the data element is implemented within the computer program as a data structure having a data type of array, not a data type of list.
In the example just described:
Although data elements in an implemented data set may have a one-to-one correspondence with data elements in a corresponding manifested data set, this is not a requirement of the present invention. Alternatively, for example, two or more data elements in an implemented data set may be manifested to produce a single data element in a corresponding manifested data set. As another example, one data element in an implemented data set may be manifested to produce a plurality of elements in a corresponding manifested data set.
Although all data elements in an implemented data set may be manifested to produce a corresponding manifested data set, this is not a requirement of the present invention. Alternatively, only a subset (i.e., some but not all) of the data elements in an implemented data set may be manifested to produce a corresponding manifested data set. As another example, a first subset (i.e., some but not all) of the data elements in an implemented data set may be manifested to produce a first corresponding manifested data set, and a second subset (i.e., some but not all) of the data elements in the implemented data set may be manifested to produce a second corresponding manifested data set, where the first and second subset may or may not be disjoint, and where the first and second corresponding manifested data sets may have the same or different data types as each other.
Now consider a particular implemented data element X having a particular data type, such as array. A subset Y (i.e., some but not all) of the data elements in implemented data element X may exhibit the behavior of a data element having the same or different data type as the data type of implemented data element X. Such a subset is an example of what is referred to herein as an “effective data element.” For example, such a subset may exhibit the behavior of a data element having a data type of list or a data type of array. A first subset (i.e., some but not all) of the data elements in an implemented data set may exhibit the behavior of a first effective data element (e.g., a first effective data set), and a second subset (i.e., some but not all) of the data elements in the implemented data set may exhibit the behavior of a second effective data element (e.g. a second effective data set), wherein the first and second effective data elements may or may not be disjoint, and where the first and second effective data elements may have the same or different data types as each other. Such characteristics may be generalized to any number of subsets of an implemented data set.
As another example, an effective data element may contain the union of two or more data elements, referred to herein as “constituent data elements” of the effective data element. For example, an effective data element may contain the union of: (1) a first data element (e.g., a first data set) or a subset thereof; and (2) a second data element (e.g., a second data set) or a subset thereof. As just one particular example, a effective data element having a data type of list may contain the union of: (1) all data elements from a first data set having a data type of list; and (2) some, but all not, data elements from a second data set having a data type of list. An effective data element may have the same or different data type than any of its constituent data elements. Any two data constituent data elements of an effective data element may have the same or different data type as each other.
The term “data element” as referred to herein includes implemented data elements, manifested data elements, and effective data elements. Although in the particular example above the implemented data element has a different data type than the corresponding manifested data element, this is merely an example and does not constitute a limitation of the present invention. Alternatively, for example, an implemented data element may have the same data type as a corresponding manifested data element.
A particular implemented data element that is manifested to produce a particular manifested data element is said herein to “correspond” to the particular manifested data element. Therefore any reference herein to a particular implemented data element and a “corresponding” manifested data element, or vice versa, should be understood accordingly. A particular implemented data element may be manifested as one or more manifested data elements. A particular implemented data element, therefore, may correspond to one or more manifested data elements. If a particular implemented data element corresponds to a plurality of manifested data elements, any two such manifested data elements may have the same or different data types as each other. For example, an implemented data element having a data type of array may be manifested as a first manifested data element having a data type of list and be manifested as a second manifested data element having a data type of array.
As used herein, “manifesting” data refers to providing output, to a user, that represents such data. Such output may take any form, such as a visual form and/or an auditory form. For example, such output may include any one or more of the following in any combination: text, graphics, images, video, and audio. As this description makes clear, any output described herein as being “manifested,” may, for example, solely include text, solely include graphics, solely include video, or solely include audio.
References are made herein to the value “of” a data element and to a data element “having” a value. The value of a data element may, however, be a reference (e.g., pointer) to another data element. For ease of illustration, consider a data element X that is implemented using a variable having a data type of <double> in the C programming language. Reference herein to the value “of” data element X may refer to the value of the <double> variable. This value is an example of what is referred to herein as a “direct” value of the <double> variable.
The value of the <double> variable may, however, be treated as a reference to an address of another data element Y having, for example, a data type of <int> in the C programming language. Reference herein to the value “of” data element X may, therefore, refer to the <int> value of data element Y. This value is an example of what is referred to herein as an “indirect” value of the <double> variable. References herein to the value “of” a data element and to a data element “having” a value include both direct and indirect values of the data element. Although in the example above the reference is implemented using a pointer in the C programming language, this is merely an example and does not constitute a limitation of the present invention. More generally, such a reference may be implemented in any manner, including using mechanisms (such as HTML hyperlinks) not provided natively by a computer programming language.
Similarly, references are made herein to data sets “including,” “containing,” or “having” data elements. Any reference herein to a data set X “including,” “containing,” or “having” a data element Y should be understood to mean that data set X may incorporate data element Y, or data derived therefrom (such as a notification of data element Y), by value or by reference. Furthermore, any references herein to “removing” or “deleting” a data element from a data set include implementations in which the data element is erased from the data set and implementations in which the data element is marked as deleted (such as by changing the value of a “deleted” flag associated with the data element) even though the data element otherwise remains unchanged.
The term “data element,” as used herein, includes, but is not limited to, any of the data elements described above. For example, the term “data element,” as used herein, includes data elements having primitive data types, data elements having composite data types, and data elements having abstract data types. As another example, the term “data element,” as used herein, includes implemented data elements and manifested data elements.
Embodiments of the present invention may be used to enable a user to manually reorder data elements in a list. As indicated by the discussion above, a list may be an implemented list data element (e.g., a data element implemented using a primitive list data type in a programming language such as LISP), a manifested data element, or an effective data element.
As is well-known to those having ordinary skill in the art, a list is an ordered sequence of data elements, where the ordering of the data elements may be implemented in any of a variety of ways. For example, a list may be implemented as a linked list, such as a singly-linked list (in which each data element includes a link to its immediate successor or its immediate predecessor) or a doubly-linked list (in which each data element includes a link both to its immediate successor and to its immediate predecessor). These are merely examples and do not constitute limitations of the present invention. Rather, in general, the term “list” herein refers to any data element that exhibits the behavior of a list.
For ease of illustration and explanation, lists will be illustrated and described herein as shown by the generic list 102 in
A “list,” as that term generally is used in computer science, refers to an ordered data set, such that every data element in the data set has precisely one index that is unique within the data set. (The data elements in a list are also referred to herein as “list elements.”) The transitive relation holds over all of the list elements' indices, such that the order of all of the list's elements is unambiguous. For example, consider the list (B, F, A). In this case, the index of element B may be 0, the index of element F may be 1, and the index of element A may be 2. Lists having the properties described in this paragraph are examples of “lists” as that term is used herein.
The indices of a list's elements may be stored explicitly as index values. For example, in the case of the list (B, F, A), above, the index values (0, 1, 2) may be stored in a computer-readable medium in the same data element as the list (B, F, A) (e.g., as a list of tuples ((B, 0), (F, 1), (A, 2))), or in a different data element than the list (B, F, A), but in a way that associates the list (B, F, A) with its indices (0, 1, 2) (such as by storing, in association with each of the indices, a reference to the corresponding list element). A set of indices, stored in any of the ways described, is one example of what is referred to herein as “list sequence data.”
The separate list 122 is an example of an “index set” as that term is used herein, because the order of the list 122's elements 124a-n (namely the order 124a, 124b, 124c, 124d) specifies the order of the elements in the list 102. (Perhaps unfortunately, a list such as the list 122 is sometimes itself referred to in the art as an “index” into the list 102. To avoid confusion, the list 122 will be referred to herein as an “index set.”) The index set 122 is an example of “list sequence data,” as that term is used herein. Therefore, any disclosure herein of properties of an index set is equally applicable to list sequence data more generally.
In the example of
The list 122 (which may include the references 130a-n) may be created and stored, and thereby used to apply the ordering of the list 102 (such as in a process of manifesting the list 102 in the order specified by index set 122) without modifying the list 102 itself. As another example, the index set 122, or data derived therefrom, may be added to the list 102, such as by adding the elements 124a-n and/or references 130a-n into distinct fields within the list elements 104a-n.
As described above, a list has a particular order (also referred to herein as the list's “sequence” or “ordering”). For example, in
For example, if a descending sorting function were applied to the list 102, the resulting order (sequence) of the list 102 may be the following: 104a, 104c, 104n, 104b, in which case the elements 124a-n of the index set 122 would point to elements 104a, 104c, 104n, and 104b, respectively. Note that in the case of list elements having equivalent values (e.g., in the case of list elements 104c and 104n in
As is well-known to those having ordinary skill in the art, the act of applying a sorting function to the list 102 may or may not cause any modification to the list 102 itself. For example, applying a sorting function to the list 102 may involve only modifying the index set 122, but not modifying the list elements 104a-n. The same is true of any modification to the list 102, such as changing the order of a subset of the list 102, adding elements to the list 102, and deleting elements from the list 102.
Performing operations on the list 102 (such as changing the order of some or all of the list 102, adding elements to the list 102, and deleting elements from the list 102) may, however, involve modifying the list 102 itself, such as by moving list elements 104a-n within the list 102, modifying references among list elements in the list 102 (as in the case of a linked list), adding elements into the list 102, deleting elements from the list 102, or creating a new list that reflects the desired changes to the list 102 and deleting the old list 102.
In the particular example of
Furthermore, an index set associated with a “list,” as that term is used herein, may include indices for fewer than all of the list's elements. If an index set associated with a list includes indices for fewer than all of the list's elements, then the order of the list is not uniquely determined, in which case the index set may constitute an input to an ordering procedure that produces (possibly, but not necessarily, deterministically), as output a unique index for all of the list's elements. The resulting unique indices may either replace the input index set or be stored as an additional index set, without causing any modifications to the input index set. Examples of such ordering procedures include:
In the example of
For example, referring to
Each portion within a particular list element may be associated with a corresponding data element portion type. For example, in the embodiment illustrated in
A sorting function may be applied to a particular one of the portion types 134a-c, thereby causing the list 102 to be sorted by the values of the list element portions associated with the particular one of the portion types 134a-c. In database terminology this is referred to as using the particular one of the portion types 134a-c as a primary sort key. For example, if a sorting function is applied to portion type 134a, the sorting function may sort the list elements 104a-n according to the values of list element portions 106a-n (which are associated with portion type 134a). As is well-known to those having ordinary skill in the art, a sorting function may sort the list 102 using any number of portion types in any of a variety of manners, such as by using one of the portion types as a primary sort key and by using another one of the portion types as a secondary sort key. Embodiments of the present invention may use any such sorting technique and are not limited to using any particular sorting technique to sort the list 102 or any other list disclosed herein.
As shown in
Such associations 112a-n and 114a-n may be implemented in any of a variety of forms. For example, any one or more of such associations 112a-n and 114a-n may be stored as a data element on a non-transitory computer readable medium, such as a pointer from one list element portion to another. As another example, any one or more of such associations 112a-n and 114a-n may be implicit and therefore not stored as a data element on a non-transitory computer readable medium, such as in a case in which two associated portions are two fields in a single database record.
Distinct portions of a particular list element may be:
For example, a first portion of a list element (e.g., portion 106a of list element 104a) may be maintained by a first computer program and stored on a first computer-readable medium, while a second portion of the same list element (e.g., portion 108a of list element 104a) may be maintained by a second computer program and stored on a second computer-readable medium.
Although in the example of
As mentioned above, embodiments of the present invention may be used to enable a user to provide manual input that is used to reorder some or all of the elements in a list. Referring to
The system 200 includes list 102 for purposes of example. More generally, the system 200 may be used in connection with any list. The system 200 also includes a list ordering module 202. A user 204 of the system 200 provides list element order input 206 to the system 200. In general, the list element order input 206 specifies an order (e.g., index) of some or all of the elements 104a-n in the list. The list ordering module 202 receives the list element order input 206 (
The list ordering module 202 identifies one or more modifications to the order (e.g., index) of some or all of the elements 104a-n of the list 102 based on and in response to the list element order input 206 (
As shown in
The list element order input 206 provided by the user 204 may take any of a variety of forms. For example, the input 206 may specify, for each of one or more elements 104a-n in the list 102, an index of that element in the list 102. In response to and based on such input, the list ordering module 202 may assign, to each list element specified by the input 206, an index specified by that input, and change the indices of other elements in the list 102 accordingly. For example, consider
Now assume that the user 204 provides input 206 specifying that list element 404a should be assigned an index of 2. For example, referring to
The user 204 may provide input 206 into the cells 418a-d of column 420c to specify the desired new index of one or more of corresponding list elements 404a-d, respectively. More specifically, the user 204 may input a desired index of element 404a in cell 418a; a desired index of element 404b in cell 418b; a desired index of element 404c in cell 418c; and a desired index of element 404d in cell 418d. Although not shown in
The text “2” in cell 418a of
As another example, and as shown in
As even this simple example illustrates, the list ordering module 202 may interpret the user input 206 in any of a variety of ways, and embodiments of the present invention are not limited to any particular such way. Furthermore, the list ordering module 202 may use any of a variety of well-known techniques in the event of an index conflict resulting from the user input 206, such as in the event that the user input 206 specifies or implies the same index for two or more list elements.
The particular method for receiving user input 206 illustrated by column 420c is merely an example and does not constitute a limitation of the present invention. Another example is illustrated by column 420d, which provides up arrows 426a-d and down arrows 428a-d in each of the rows 424a-d corresponding to the list elements 404a-d, respectively. To decrement the index of a particular list element, the user 204 may provide input indicating that the index of the particular list element should be decremented, such as by pressing the up arrow in the row representing the particular list element, in response to which the list ordering module 202 may swap the particular list element with the immediately-preceding list element, thereby producing a modified list. Similarly, to increment the index of a particular list element, the user 204 may provide input indicating that the index of the particular list element should be incremented, such as by pressing the down arrow in the row representing the particular list element, in response to which the list ordering module 202 may swap the particular list element with the immediately-following list element, thereby producing a modified list.
As yet another example, the user interface of
Although not shown in the drawings, in any of the examples above, after the list ordering module 202 has created the modified list 102′ (e.g., modified list 402′) based on the user input 206, the system may manifest the modified list 102′ to the user 204, such as by using the user interface of
The particular techniques disclosed herein for receiving the list element order input 206 from the user 204 are merely examples and do not constitute limitations of the present invention. Rather, embodiments of the present invention may be used in connection with any kind of list element order input 206 provided by the user 204, via any input device, via any user interface, and taking any form.
Embodiments of the present invention may be used to enable a user to manually reorder any of a variety of data. Examples of such data include messages (such as email messages, text messages, fax messages, and social networking messages), calendar appointments, tasks (also referred to as “reminders” or “to-dos”), and notifications of any of the above.
For example, a list (e.g., list 102 or 402) that is reordered by embodiments of the present invention may solely contain data elements created by, modified by, maintained by, or otherwise associated with a particular computer program (e.g., a particular operating system or application program), such as a particular messaging program (e.g., Microsoft Outlook, Apple Mail, Apple Messages, or Skype), a particular calendar program (e.g., Microsoft Outlook or Apple Calendar), a particular task management program (e.g., Microsoft Outlook or Apple Reminders), a particular notification program (e.g., the Apple Notification Center), or a particular account (e.g., a particular Microsoft Windows Live account, a particular Apple iCloud account, a particular Google Gmail or Google Apps account, or a particular Facebook account).
As another example, a list (e.g., list 102 or 402) that is reordered by embodiments of the present invention may solely contain data elements having a particular data type (such as a message (e.g., email or text message) data type, a calendar appointment data type, a task data type, or a notification data type), where such data elements may include data elements created by, modified by, maintained by, or otherwise associated with more than one computer program (e.g., more than one operating system and/or application program), with more than one account, or with both more than one computer program and more than one account.
For example, a list that is reordered by embodiments of the present invention may solely contain messages, where such messages may include both:
For example, a list that is reordered by embodiments of the present invention may solely contain calendar appointments, where such calendar appointments may include both:
For example, a list that is reordered by embodiments of the present invention may solely contain tasks, where such tasks may include both:
For example, a list (e.g., list 102 or 402) that is reordered by embodiments of the present invention may solely contain data elements created by, modified by, maintained by, or otherwise associated with a particular computer program (e.g., a particular operating system or application program), such as a particular messaging program (e.g., Microsoft Outlook or Apple Mail), a particular calendar program (e.g., Microsoft Outlook or Apple Calendar), a particular task management program (e.g., Microsoft Outlook or Apple Reminders), a particular notification program (e.g., the Apple Notification Center), or a particular account (e.g., a particular Microsoft Windows Live account, a particular Apple iCloud account, a particular Google Gmail or Google Apps account, or a particular Facebook account).
As another example, a list (e.g., list 102 or 402) that is reordered by embodiments of the present invention may solely contain data elements having a particular data type (such as a message data type, a calendar appointment data type, a task data type, or a notification data type), where such data elements may include data elements created by, modified by, maintained by, or otherwise associated with more than one computer program (e.g., more than one operating system and/or application program), with more than one account, or with both a computer program and an account.
The computer program that creates a data element is referred to herein as the “native” computer program of the data element. For example, if a particular email program (e.g., Microsoft Outlook or Apple Mail) creates a particular email message, then the particular email program is the “native” computer program of the particular email message. For example, consider the prior art system 500 of
Embodiments of the present invention may be integrated with such a native computer program 506 to reorder lists, such as the list 502, containing data elements created by the native computer program 506. For example, as illustrated by the system 520 of
For example, embodiments of the present invention may be integrated with a particular email program (e.g., Microsoft Outlook or Apple Mail) by modifying such an email program to include the functionality disclosed herein. More generally, the approach illustrated by
As another example, embodiments of the present invention may be implemented in one or more computer programs that interoperate with a native computer program to perform the functions disclosed herein. For example, as illustrated by the system of
The distinct list management module 522 may, for example, be implemented to interoperate with the native computer program 506 using any one or more of the following techniques:
Embodiments of the present invention may use any such mechanism(s) to perform any one or more of the following functions:
In the example of
Although in the example of
Although only one list 532 managed by the distinct list management module 522 is shown in
The same data element may be included in more than one list managed by the distinct list management module 522. For example, the distinct list management module 522 may manage two lists, each of which contains the same set of data elements, but where the two lists have different elements and/or different orders.
Referring to
The method 600 creates a new list (
The method 600 may, for example, be used to recreate all or a portion of the native list 502 in the list 532. For example, the method 600 may be used to recreate all or a portion of an email inbox or folder of a particular user, all or part of a calendar of a particular user, all or part of a task list of a particular user, or all of part of a notifications list of a particular user. The method 600 may, for example, apply a filter to the native list 502 to incorporate into the list 532 only those data elements in the native list 502 that satisfy the filter.
The user input may specify such a list element in any of a variety of ways. For example, the user 204 may select the specified native list element and issue a command to add the native list element to the list 532 (such as by clicking on an “add to activity list” button, or by dragging a manifestation of the native list element onto a manifestation of the list 532), in response to which the specified native list element may be added to the list 532 at some index, such as the top or bottom of the list 532. As another example, the user 204 may provide list element order input 206 (
The user input received in operation 622 may be received by, for example, the modified list management module 508′ or the distinct list management module 522. The native list element may be added to the list 532 by, for example, the modified list management module 508′ or the distinct list management module 522. For example, operations 622 and 624 may be performed in any of the following ways:
In certain embodiments of the systems 520 and 530 of
An example of such list sequence data is shown in
The indices 538a-n in the list 532 of
A list that is ordered by an embodiment of the present invention may be manifested in any of a variety of ways. For example, referring to
The list manifestation module 702 enters a loop over each list element E in the ordered list 102′, in the order of the list elements 104a-n in the ordered list 102′, as specified by list sequence data associated with the ordered list 102′ (
The order of the list element manifestations 714a-n may correspond to the order of the corresponding list elements 104a-n in any of a variety of ways. For example, the list manifestation module 702 may spatially manifest the list element manifestations 714a-n in a manner that corresponds to the order of the corresponding list elements 104a-n, such as by spatially arranging the list element manifestations 714a-n sequentially from top to bottom, from bottom to top, from left to right, or from right to left. As another example, the list manifestation module 702 may temporally manifest the list element manifestations 714a-n in a manner that corresponds to the order of the corresponding list elements 104a-n. For example, the list manifestation module 702 may manifest the first list element in the list 102′ (e.g., list element 104a) during a first time period, manifest the second list element in the list 102′ (e.g., list element 104b) during a second time period having a start time that is later in time (or at least no earlier in time) than the start time of the first time period, manifest the third list element in the list 102′ (e.g., list element 104c) during a third time period having a start time that is later in time (or at least no earlier in time) than the start time of the second time period, and manifest the nth list element in the list 102′ (e.g., list element 104n) during an nth time period having a start time that is later in time (or at least no earlier in time) than the start time of the (n−1)th time period.
As a particular example of the above, the list manifestation module 702 may manifest each of the list elements 104a-n in a temporal sequence, such that at most one (e.g., exactly one) of the list elements' manifestations 714a-n is manifested (e.g., displayed) at any particular time. In such a case, no two of the manifestations 714a-n are manifested (e.g., displayed) contemporaneously. Upon satisfaction of some predetermined criterion (such as receiving some predetermined input from the user 204, such as pressing a “Complete,” “OK,” “Next,” or “Delete” button, or the lapse of a timer or occurrence of a predetermined time), the list manifestation module 702 may terminate the currently-manifested manifestation (e.g., by erasing or otherwise removing its display) and manifest the next list element in the list 102′. Such a technique may be used, for example, to enable each element in the list 102′ to be manifested one at a time, in the order of the list 102′, and to enable the user 204 to control the timing of the manifestation of the next element in the list 102′. Similar techniques may be used to enable the user 204 to navigate backwards through the list 102′. Similar techniques may be used to enable the list manifestation module 702 to display fewer than all but greater than one of the list elements 104a-n at a time, and to enable the user 204 to navigate through such subsets of the list 102′ in either direction.
The list manifestation 712, and the individual list element manifestations 714a-n may take any of a variety of forms. For example, the list manifestation 712 may be displayed as a list, table, or other visual element which indicates the order of the list 102′. Each of the list element manifestations 714a-n may, for example, contain manifestations of any of the data in the list elements 104a-n, including list sequence data.
For example, referring to
In the particular example of
Although the example illustrated in
The particular columns 904a-d shown in
More generally, each of the list manifestations shown herein (such as those shown in
A list maintained by an embodiment of the present invention (such as the list 532) may be associated with a view property set that differs from a view property set associated with the list by the native computer program associated with some or all of the elements in the list. As a result, the native computer program may manifest the list according to a first view property set, while an embodiment of the present invention may manifest the list according to a second view property set that differs from the first view property set. These two manifestations may be manifested contemporaneously. As just one particular example, the native computer program 506 may manifest the list 502 in order of the time of receipt of email messages in the list 502, whereas the distinct list management module 522 may manifest the list 532 (which may contain some or all of the email messages in the native list 502) in an order manually specified by the user 204. Both such manifestations may, for example, be manifested (e.g., displayed) contemporaneously, e.g., in separate windows. Such an embodiment enables users to retain the benefits of conventional sort orders (e.g., temporal sort orders), while also obtaining the benefit of the manual sort orders of embodiments of the present invention.
The list manifestation 712 (e.g., the table 900) may be integrated into a manifestation generated by the native computer program 506. For example, if the native computer program 506 includes the ability to display email messages in a table having columns 904a-c (
Alternatively, for example, the list manifestation 712 may be produced by a computer program, such as the distinct list management module 522 of
Some list elements in a particular list may have a corresponding user-specified index, while other list elements in the particular list may have no corresponding user-specified index (or, equivalently, have a null corresponding user-specified index). Embodiments of the present invention may sort list elements by user-specified index in such a case in any of a variety of ways. For example, when sorting a list containing elements with a corresponding user-specified index and elements without a corresponding user-specified index, embodiments of the present invention may:
Although the list manifestation 900 of
The table 910 contains a plurality of rows 912a-d representing a plurality of data elements. In the example of
Although the table 910 does not include a “manual order” (i.e., user-specified index) column and does not include the user-specified indices of any of the list elements 104a-n, the list element manifestations 912a-d in
Similarly, as illustrated by
In any of the embodiments of the list manifestation 712 disclosed herein, such as the table 900 of
Embodiments of the present invention may replace or supplement existing list orders (e.g., sort orders provided by native computer programs) with user-specified (i.e., manual) list orders. For example, referring to
The native order field 1004d of the list elements 1002a-d contains list sequence data (e.g., sequence IDs) associated with the list elements 1002a-d. The native order field 1004d may alternatively be implemented in any of the ways described herein for list sequence data. For example, the contents of the native order field 1004d need not be stored as part of the list 1000, but may instead, for example, be stored separately, such as in data associated with a view (e.g., manifestation) of the list 1000. However, the native order field 1004d is shown as part of the list 1000 in
The native computer program 506 may assign values to the native order field 1004d of the list elements 1002a-d in any of a variety of ways. For example, if the user 204 issues a command to the native computer program 506 to sort the list 1002d by the date field 1004c, then the native computer program 506 may sort the list 1002d by the date field 1004c and assign values to the native order field 1004d of the list elements 1002a-d to specify an order of the list elements 1002a-d which orders the list elements 1002a-d by date.
Embodiments of the present invention may add, to a native list such as the list 1000, list sequence data which specifies a user-specified (i.e., manual) order of the list 1000. For example, referring to
The manual order field 1004e of the list elements 1002a-d contains list sequence data (e.g., sequence IDs) associated with the list elements 1002a-d. The manual order field 1004e may alternatively be implemented in any of the ways described herein for list sequence data. For example, the contents of the manual order field 1004e need not be stored as part of the list 1010, but may instead, for example, be stored separately, such as in data associated with a view (e.g., manifestation) of the list 1010. As a particular example, the list 1000 (i.e., columns 1004a-d in
As
One implication of this feature of embodiments of the present invention is that such embodiments may enable the user 204 to switch between manifestations of a list in which the list is ordered automatically and manifestations of the list in which the list is ordered manually. For example, consider again the manifestation 900 of
Although such a manifestation does not order the list elements 902a-d by manual order, and may not even manifest the contents of the manual order column 1004e (e.g., the manifestation may omit column 904d of
Similarly, the combination of automatic order data in the native order column 1004d of the list 1010 and the manual order data in the manual order column 1004e of the list 1010 may be used to produce multiple contemporaneous manifestations of the list 1010, including at least one manifestation which manifests the list elements 1002a-d in the order specified by the native order column 1004d and at least one manifestation which manifests the list elements 1002a-d in the order specified by the manual order column 1004e. Such an embodiment thereby allows the user 204 to obtain the benefits of automatic and manual ordering contemporaneously.
Although the list 1010 in
As described herein, embodiments of the present invention may generate manifestations of lists, such as the manifestations 900 (
The system 1100 includes a list operation module 1106, which may, for example, be implemented in any of the ways described herein in connection with the modified list management module 508′ and the distinct list management module 522. The system 1100 also includes a list 1108, which may, for example, be any of the lists disclosed herein (e.g., list 102′, list 502, or list 532). The user 204 provides input 1102 specifying a particular list element in the list 1108 (
The user 204 also provides input 1104 specifying an operation to perform on the particular list element (
In response to receiving inputs 1102 and 1104, the list operation module 1106 performs the specified operation on the particular list element (
Similarly, embodiments of the present invention may enable the user 204 to re-sort the list 1108 based on any sort key(s). Referring to
The user 204 provides input 1152 specifying a particular list, e.g., the list 1108 (
The user 204 also provides input 1154 specifying one or more sort keys (
In response to receiving inputs 1152 and 1154, the list operation module 1156 sorts the specified list 1108 based on the specified sort key(s) (
The systems and methods of
As another example, if the operation to be performed on the particular list element in
Although the description of the systems and methods of
Although the systems and methods of
Although the systems and methods of
As the example just described indicates, new list elements may be added to lists maintained by embodiments of the present invention. For example, the user 204 may manually add a new list element to a list maintained by an embodiment of the present invention. As another example, a native computer program may cause a new list element to be added to a list maintained by an embodiment of the present invention. In such cases, the newly-added list element may lack any user-specified (i.e., manual) order with respect to the list. Some or all of the other elements in the list may, however, have one or more user-specified orders with respect to the list. In other words, existing elements in the list may be associated with list sequence data associated with the list, whereas the newly-added list element may not be associated with any list sequence data associated with the list.
Embodiments of the present invention may handle such a situation in any of a variety of ways. For example, embodiments of the invention may not take any special action to assign a manual order to such new list elements. As a result, such new list elements may be treated in the manner disclosed elsewhere herein. The user 204 may subsequently assign one or more manual sort orders to such new list elements in any of the ways disclosed herein.
As another example, embodiments of the present invention may automatically assign a manual order to an element in response to the element being added to a list. Such automatic assignment may be performed in any of a variety of ways. For example, embodiments of the present invention may assign a lowest manual order in the list to the new element (i.e., a manual order that is less than the manual order of all other elements in the list), or assign a highest manual order in the list to the new element (i.e., a manual order that is greater than the manual order of all other elements in the list). As another example, when a new element is added to a list, embodiments of the present invention may prompt the user to specify a manual order for the element in the list, in response to which the user may specify such an order in any of the ways disclosed herein, in response to which embodiments of the present invention may assign the user-specified order to the element in the list. The user may or may not be required to specify such a manual order for the element in the list. Any of these techniques for automatically assigning a manual order to an element newly added to a list may be performed, for example, only if the list currently is sorted (e.g., manifested) in manual order.
Embodiments of the present invention may be used to enable the user 204 to mark any element in a list as “complete.” For example, embodiments of the present invention may be used to enable the user 204 to mark a message (e.g., an email message or text message), an appointment, or a task as complete. This feature may be combined with the ability to enable the user 204 to manual order a list. For example, embodiments of the present invention may enable the user 204 to manually order a list of any of the kinds disclosed herein in any of the manners disclosed herein, and then to mark one or more elements in the manually-ordered list as complete. Embodiments of the present invention take an appropriate action in response to a list element being marked as complete, such as removing the element from the list. In this way, embodiments of the present invention may be used to transform messages, calendar appointments, and other non-actionable data elements into actionable data elements that may be used productively as tasks and, if desired, integrated into a single list with tasks maintained by native task management programs.
For example, referring to
The particular list elements 1002a-d in
Assume for purposes of example that the native email program that created the email messages represented in the list 1020 of
Certain native data elements, however, such as native tasks, may already be associated with a complete field or similar field by their associated native computer program. When a component of the present invention adds such a data element to the list 1020, such a component may or may not associate the complete field 1004f with such a data element. For example, the component may associate the complete field 1004f with the data element, as a result of which the data element will be associated with two complete fields (i.e., the native complete field and the complete field 104f). Alternatively, for example, the component may not associate the complete field 1004f with the data element, as a result of which embodiments of the present invention may use the data element's existing complete field to perform the functions disclosed herein in connection with the complete field 1004f. As these examples imply, a single list generated by an embodiment of the present invention may include both: (1) elements associated with the complete field 1004f; and (2) elements not associated with the complete field 1004f, but associated with a complete field from their associated native computer program.
When adding a new element to a list, a component (such as the modified list management module 508′ or the distinct list management module 522) may determine whether the element already is associated with a complete field (whether or not the name of such a field is “complete”), by which is meant a field that indicates whether an activity associated with the element is complete. If the component determines that the element already is associated with a complete field, then the component may not associate the element with the complete field 1004f. If the component does not determine that the element already is associated with the complete field, then the component may associate the element with the complete field 1004f.
A list element and associated complete field 1004f (or other mechanism for marking the list element as complete) is referred to herein as an “activity data element,” which represents what is referred to herein as an “activity.” For example, in
Furthermore, embodiments of the present invention may be used to enable a user to manually order activity data elements representing activities. Embodiments of the present invention, in other words, may be used to enable users to manually prioritize activities.
Embodiments of the present invention may use any of a variety of techniques to enable a user to process activity data elements. One example of a system 1300 for enabling a user to process activity data elements is shown in
The system 1300 may include the elements of the system 700 of
An example list manifestation 920 that may be produced by
The system 1300 also includes a list completion module 1304, which may be implemented in any of the ways disclosed herein for other components of embodiments of the present invention (such as the modified list management module 508′ and the distinct list management module 522). The user 204 provides input 1302 specifying that a particular one of the elements in the list 102′ should be marked as complete (e.g., that the value of the list element's complete field 1004f should be changed from “not complete” to “complete”).
The completion input 1302 may take any of a variety of forms. For example, in
In response to receiving the user input 1302, the list completion module 1304 marks the specified list element as complete (
The list completion module 1304 may also perform a completion action in connection with the particular list element that was marked as complete in operation 1404 (
Certain systems, such as the Google Gmail email system, associate an “archived” field with each list element. In the example of Gmail, email messages in which the value of the archived field is “not archived” are displayed in the user's inbox, whereas email messages in which the value of the archived field is “archived” are not displayed in the user's inbox. Embodiments of the present invention may, for example, provide the complete field 1004f in addition to the archived field provided natively by a system such as Gmail. As a result, a Gmail email message may be archived and complete, archived and not complete, not archived but complete, or not archived and not complete. As just one example of how such combinations may be experienced by the user 204 in embodiments of the present invention, email messages that are archived and complete may not appear in the user's inbox or in manifestations of lists produced by embodiments of the present invention; email messages that are archived and not complete may not appear in the user's inbox but appear in manifestations of lists produced by embodiments of the present invention; email messages that are not archived but complete may appear in the user's inbox but not appear in manifestations of lists produced by embodiments of the present invention; and email messages that are not archived and not complete may appear in the user's inbox and in manifestations of lists produced by embodiments of the present invention.
Operation 1406 may include both selecting a completion action to perform from among a plurality of completion actions, and performing the selected completion action. The list completion module 1304 may select the completion action to perform in connection with a particular list element in any of a variety of ways. For example:
As the examples above illustrate, different completion actions may be associated with different lists, activity types, and/or list elements.
Although not shown in
One benefit of allowing the user 204 to both manually order the list 102′ and to pre-specify completion actions is that the user may separate out the processes of: (1) selecting an order in which to process activities; (2) selecting the completion action to perform in connection with activities; and (3) processing the activities themselves. For example, the user 204 may:
Such a process is likely to be less cognitively demanding on the user 204, and therefore is likely to be more efficient, than the conventional method of processing activities, in which the user 204: (1) selects a list element to process (possibly by reviewing some or all of the list elements for importance); (2) processes (e.g., reads and/or responds to) the selected list element; (3) selects a completion action to perform on the list element; (4) performs the completion action on the list element manually (such as by manually moving the list element to a folder or manually deleting the list element); and (5) returns to step (1) for another element in the list. Such a process is suboptimal for a variety of reasons. For example, it requires the user 204 to switch repeatedly among several different types of actions (e.g., prioritizing, processing, completing) for each list element, rather than performing actions of the same type together for multiple list elements (such as selecting the priority of all list elements without interruption). As another example, it causes the user 204 to review the same list elements multiple times, such as when the user 204 scans some or all of the list 102′ each time the user 204 tries to find the list element with the highest priority in the list. In contrast, embodiments of the present invention may be used to reduce the cognitive switching costs imposed on the user 204 by enabling the user 204, for example, to prioritize the list 102′ once and then process the list 102′ in its prioritized (i.e., manually sorted) order, thereby eliminating or reducing the need for the user 204 to prioritize the list 102′ again, and thereby enabling the user 204 to focus on processing the list elements once the user 204 has prioritized them.
The results of any operations performed by the system and method of
Embodiments of the present invention have a variety of advantages, such as the following. One advantage of embodiments of the present invention is that various conventional techniques for automatic sorting (e.g., by date, time, subject, sender, category, folder, or tag/label) do not fit the needs of users in all situations. In particular, such conventional sorting techniques may provide a list order that is of general use to the user, but that does not order each and every list element in the order that is most useful to the user. For example, the user may apply an intuitive set of criteria to prioritize a list of activities, and the user may either not be capable of expressing those criteria in a form that can be used by a program to sort the list automatically according to those criteria (e.g., as a set of sort keys), or it might be prohibitively time-consuming for the user to define and input such criteria to a program, particular if such criteria change frequently and rapidly over time. This flaw in existing automatic sorting techniques is evidenced by the fact that users continue to use means outside of their native computer programs, such as word processing documents, spreadsheets, and even paper notes, to keep track of the actual order in which the user desires to attend to a set of activities, such as responding to emails, attending calendar appointments, and completing a set of tasks.
In contrast, embodiments of the present invention let the user apply his or her own intuitive criteria to prioritize a list of activities directly, quickly, and easily, simply by manually specifying the order of elements in the list. In particular, embodiments of the present invention enable the user to prioritize activities on a per-activity basis, meaning that the user may specify, for each element in a list of activities, a list position that is guaranteed to be unique relative to any other element in the list of activities. Such per-activity manual ordering includes per-activity manual ordering of activities of different types within the same list. For example, embodiments of the present invention enable the user to manually order a list containing two types of activities (e.g., email messages and calendar appointments) such that the list contains an element of the first activity type, followed immediately by an element of the second activity type, followed immediately by an element of the first activity type. As this example illustrates, embodiments of the present invention are not limited to grouping activities by activity type, native computer program, or in any other way. Rather, embodiments of the present invention enable the user to manually position any list element of any activity type and any native computer program at any position in the list relative to any other list element of any activity type and any native computer program.
In contrast, systems which allow the user to specify a temporal deadline or target completion time for a particular list element, such as “today” or “Feb. 1, 2013 at 05:00 AM,” do not guarantee that such identifiers represent a unique position in the list relative to other list elements. As the examples herein illustrate, the index that is associated with any particular element in a list does not (or at least need not) represent a time. Instead, such an index represents a position of the particular element relative to one or more other elements in the list. Such indices are more useful to users than times in situations in which the user's goal is to process list elements in a particular order, not to complete the processing of any particular list element by any particular time.
Yet another advantage of embodiments of the present invention is that they enable users to combine different types of activities (e.g., message activities, appointment activities, and task activities) into a single list that may be manually ordered and in which activities of any type may be marked by the user as complete. This represents an improvement over the common current practices employed by many users of using an email inbox, a calendar, and a task list as three separate lists of activities to be performed. In contrast, embodiments of the present invention enable users to maintain a single manually-sortable, actionable activity list, even if the native computer programs that created the underlying data elements do not provide manually sorting and/or completion of data elements.
Yet another advantage of embodiments of the present invention is that they may be used in connection with dynamic lists, such as an email inbox, to which additional elements are added while the user is processing the list. One reason that conventional email inboxes work particularly poorly as task lists is that such inboxes continue to receive new email messages while the user attempts to process existing email messages in the inbox with the goal of clearing the inbox of all email messages, especially because most users choose to sort their inboxes in reverse chronological order, thereby causing newly-received email messages to be inserted automatically at the top of the inbox, thereby breaking the user's concentration and increasing the likelihood that the user will process email messages in order of their receipt, rather than in order of their true importance to the user. One way in which embodiments of the present invention mitigate or avoid this problem is by enabling users to display a list in its manually sorted order, rather than in an automatically sorted order, such as in order of receipt date. Furthermore, new list elements (e.g., email messages) may automatically be inserted into the list below the list element with the lowest current manual sort order, thereby decreasing the likelihood that the user will be distracted by new list elements. Yet another way in which embodiments of the present invention mitigate or avoid this problem is by enabling manually-ordered lists to be displayed in a separate display area (e.g., window), thereby reducing likelihood that the addition of list elements to an automatically-sorted display area (e.g., the user's email inbox) will distract the user.
Yet another advantage of embodiments of the present invention is that they enable users to continue using their existing native computer programs if desired. For example, a user who prefers to use Microsoft Outlook to send and receive email may continue to do so when using embodiments of the present invention, because embodiments of the present invention may be implemented to interoperate with Microsoft Outlook using the techniques disclosed herein. Embodiments of the present invention, therefore, may be used to supplement, rather than replace, users' existing preferred native computer programs. As a result, users may obtain the benefits of manual ordering and activity completion without forfeiting the benefits of their existing preferred native computer programs.
It is to be understood that although the invention has been described above in terms of particular embodiments, the foregoing embodiments are provided as illustrative only, and do not limit or define the scope of the invention. Various other embodiments, including but not limited to the following, are also within the scope of the claims. For example, elements and components described herein may be further divided into additional components or joined together to form fewer components for performing the same functions.
Any of the functions disclosed herein may be implemented using means for performing those functions. Such means include, but are not limited to, any of the components disclosed herein, such as the computer-related components described below. With respect to any embodiments disclosed herein as modifications and/or additions to existing computer programs, those having ordinary skill in the art will appreciate how to implement such embodiments alternatively in systems which do not require such modifications and/or additions.
Although certain embodiments disclosed herein are described as modifications or additions to existing (e.g., native) computer programs, these are merely examples and do not constitute a limitation of the present invention. Embodiments of the present invention may, for example, be implemented as wholly standalone computer programs that do not require modifications to or communication with existing computer programs to perform the functions disclosed herein.
The techniques described above may be implemented, for example, in hardware, one or more computer programs tangibly stored on one or more computer-readable media, firmware, or any combination thereof. The techniques described above may be implemented in one or more computer programs executing on (or executable by) a programmable computer including any combination of any number of the following: a processor, a storage medium readable and/or writable by the processor (including, for example, volatile and non-volatile memory and/or storage elements), an input device, and an output device. Program code may be applied to input entered using the input device to perform the functions described and to generate output using the output device.
Each computer program within the scope of the claims below may be implemented in any programming language, such as assembly language, machine language, a high-level procedural programming language, or an object-oriented programming language. The programming language may, for example, be a compiled or interpreted programming language.
Each such computer program may be implemented in a computer program product tangibly embodied in a machine-readable storage device for execution by a computer processor. Method steps of the invention may be performed by one or more computer processors executing a program tangibly embodied on a computer-readable medium to perform functions of the invention by operating on input and generating output. Suitable processors include, by way of example, both general and special purpose microprocessors. Generally, the processor receives (reads) instructions and data from a memory (such as a read-only memory and/or a random access memory) and writes (stores) instructions and data to the memory. Storage devices suitable for tangibly embodying computer program instructions and data include, for example, all forms of non-volatile memory, such as semiconductor memory devices, including EPROM, EEPROM, and flash memory devices; magnetic disks such as internal hard disks and removable disks; magneto-optical disks; and CD-ROMs. Any of the foregoing may be supplemented by, or incorporated in, specially-designed ASICs (application-specific integrated circuits) or FPGAs (Field-Programmable Gate Arrays). A computer can generally also receive (read) programs and data from, and write (store) programs and data to, a non-transitory computer-readable storage medium such as an internal disk (not shown) or a removable disk. These elements will also be found in a conventional desktop or workstation computer as well as other computers suitable for executing computer programs implementing the methods described herein, which may be used in conjunction with any digital print engine or marking engine, display monitor, or other raster output device capable of producing color or gray scale pixels on paper, film, display screen, or other output medium.
Any data disclosed herein may be implemented, for example, in one or more data structures tangibly stored on a non-transitory computer-readable medium. Embodiments of the invention may store such data in such data structure(s) and read such data from such data structure(s).
| Number | Date | Country | |
|---|---|---|---|
| 61768500 | Feb 2013 | US |
