Case 1:13-cv-00919-LPS Document 311-8 Filed 03/10/21 Page 1 of 201 PageID #: 29247
`Case 1:13-cv-00919—LPS Document 311-8 Filed 03/10/21 Page 1 of 201 PageID #: 29247
`
`EXHIBIT 64 PART 4
`
`EXHIBIT 64 PART 4
`
`

`

`Case 1:13-cv-00919-LPS Document 311-8 Filed 03/10/21 Page 2 of 201 PageID #: 29248
`
`CHAP T ER 16
`
`Find
`
`The full complement of slots in the finder frame resulting from your searches
`varies according to the finder proto it's based on. A finder frame based on the
`ROM_SoupFinder proto returns a finder containing a cursor with which to
`retrieve found items from the application soup. A finder frame based on the
`ROM_ CompatibleFinder proto results in a frame containing an array of the
`actual found items.
`
`The ROM_CompatibleFinder proto is meant to serve as a guideline for creating
`a finder that works on a data storage set that does not use soups. The methods
`included must be overridden to fit the data type in which your application data
`is stored.
`
`Several methods and slots are included by both system protos; they include:
`n The selected array stores selected items from the Find overview in an
`internal format All you can do is pass the array to the Length function to
`determine the number of selected items.
`n The Count method returns an integer with the total number of found items.
`n The Re sync method resets the finder to the first found item.
`n The ShowFoundltem method displays the overview data item that resides in
`the overview's items array.
`n The ShowOrdinal Item method displays an item based on the ordinal number
`or symbol (' f irst, ' prev, or ' next) passed to it.
`
`Whenever possible, you should store your application's data in soups and use the
`ROM _SoupFinder proto to support the Find service, as shown in the following
`code fragment:
`
`if cursor:Entry() then begin
`myFinder :_ {
`proto: ROM SoupFinder,
`owner: self,
`title:"My Application",
`findType:'text, //other possible values are
`//IdateBef ore, 'date0n, and IdateAfter
`f indWords : [searchedForTheseStrings] ,
`cursor: myCursor,};
`
`Table 16-1 provides quick reference descriptions of the ROM_SoupFinder
`methods. Most should not be overridden, but those that may be are indicated.
`
`16-12
`
`Using the Find Service
`
`ARENDI-DEFS00004248
`
`

`

`Case 1:13-cv-00919-LPS Document 311-8 Filed 03/10/21 Page 3 of 201 PageID #: 29249
`
`CHAP T ER 16
`
`Find
`
`Table 16-1
`
`Overview of ROM SoupFinder methods
`
`Description
`
`Override?
`
`Method
`
`Reset
`
`Zero0ne0rMore
`
`ShowEntry
`
`SelectItem
`
`IsSelected
`
`ForEachSelected
`
`FileAndMove
`
`Resets cursor to first found entry. In
`general you should use Re sync to reset
`a finder.
`
`Returns 0 if no found entries, 1 for one
`found entry, or other number for more.
`
`Causes the finding application to display
`entry, which is passed to it as an argument.
`Does not close the Find overview.
`
`Marks the item, passed in as an argument,
`as selected. If this method is set to n 1 a
`checkbox does not appear in front of
`the item.
`
`Returns true if the item, passed in as an
`argument, is selected.
`
`Calls the callback function, passed in as an
`argument, with each selected item. The
`function has one argument: the entry from
`the cursor.
`
`File and/or move the selected items. Has
`four arguments: IabelsCbanged, newLabel,
`storeChanged, newStore. If IabelsChanged
`or storeChanged, is true newLabel and
`newStore indicate the new label and store.
`If overridden you must check for selected
`items as in
`
`if selected then // do work;
`
`No
`
`No
`
`No
`
`No
`
`No
`
`No
`
`Yes, but
`should call
`inherited
`method to
`do work.
`
`Yes, but
`crumple
`effect still
`occurs.
`
`Yes
`
`Delete
`
`Deletes all selected items from
`writeable stores.
`
`GetTarget
`
`Returns cursor for routing.
`
`Note
`The ROM_SoupFinder and ROM_CompatibleFinder
`methods Make Found Item and AddFoundItem are internal
`methods, which should not be called or overridden under any
`circumstances.
`
`Using the Find Service
`
`16-13
`
`ARENDI-DEFS00004249
`
`

`

`Case 1:13-cv-00919-LPS Document 311-8 Filed 03/10/21 Page 4 of 201 PageID #: 29250
`
`CHAP T ER 16
`
`Find
`
`If your application does not store data as soup entries, you can use the
`ROM_ CompatibleFinder proto as the framework from which to create your
`finder frame. Although ROM_CompatibleFinder provides most of the services
`that ROM_SoupFinder does, it does not respond to messages sent by the system
`when the user files, deletes, or moves items in the Find overview. The following
`methods have the same definitions in the ROM_CompatibleFinder as they have
`in the ROM_SoupFinder. If you use ROM_CompatibleFinder proto, in most
`cases, you must define the following methods to work on your data structures:
`
`n FileAndMove
`
`n Delete
`
`n IsSelected
`
`n SelectItem
`
`n ForEachSelected
`
`n GetTarget
`
`The commonality of definition between these methods causes problems in some
`cases. For instance, when used with the ROM_ CompatibleFinder proto, the
`ForEachSelected method must be overridden because it is expected to return
`an array of soup entries.
`
`The ROM_CompatibleFinder proto has the two following methods which are
`not found in the ROM_SoupFinder proto:
`
`n ShowFakeEntry
`
`n ConvertToSoupEntry
`
`When you use the ROM_CompatibleFinder proto, you should define a
`ShowFakeEntry method that makes sure your application is open, and calls your
`ShowFoundItem method.
`
`The convenience method, ConvertToSoupEntry, returns a soup entry when
`given a data item as a parameter.
`
`I mplementing Search Methods
`
`Your application conducts searches in response to messages that it receives from
`the system. You must supply a search method for each message that your application
`supports. These methods are usually defined in your application's base view;
`they include:
`n Find
`
`n DateFind
`
`n FindTargeted
`
`n DateFindTargeted
`
`16-14
`
`Using the Find Service
`
`ARENDI-DEFS00004250
`
`

`

`Case 1:13-cv-00919-LPS Document 311-8 Filed 03/10/21 Page 5 of 201 PageID #: 29251
`
`CHAP T ER 16
`
`Find
`
`Although the implementation of a search method is for the most part application
`specific, some general requirements apply to all search methods. This section
`describes these requirements and advises you of potential problems your search
`methods may need to handle.
`Your search method must be able to search for data in internal RAM as well as in
`RAM or ROM on a PCMCIA card. Using union soups, which allow you to treat
`multiple soups as a single soup regardless of physical location, to store your data
`makes it easier to solve this problem.
`As a search method proceeds through the application data, it must test items
`against criteria specified in the Find slip and collect the ones meeting the test
`criteria. It also needs to call the setMessage method to provide a status string
`that the system displays to the user while the search is in progress. Each of the
`code examples included later in this section shows how to do this.
`When the search is completed, it must append its finder frame to the system-
`supplied results array. This task is described in detail in "Returning Search
`Results" (page 16-21).
`If your application registers for participation in Global finds, your search methods
`may be invoked when your application is not open. Thus, your search methods
`must not rely on your application being open when they are invoked.
`
`Using the StandardFind Method
`
`You can use the system-supplied StandardFind method to search for text in
`soup-based application data. This method makes the necessary calls to display the
`status message, gather matching data items, and to append the finder frame that
`contains the cursor with which to fetch found items to the system's results
`array. The parameters are described in detail in "StandardFind" (page 13-13) in
`Newton Programmer's Reference.
`
`You must call the GetUnionSoupAlways function, saving the result, before
`calling StandardFind. Note that your Find method must be defined in your
`application's base view. Its use is illustrated in the following code example:
`
`MyApplicationBase.Find :_
`func(what, results, scope, statusView)
`begin
`
`The following assignment forces the existence of
`a union soup. Always all GetUnionSoupAlways
`//(saving the result in a local variable) before
`// calling StandardFind.
`
`local temp := GetUnionSoupAlways (kMySoupName);
`:StandardFind(what, kMySoupName, results,
`statusView, nil);
`
`end;
`
`Using the Find Service
`
`16-15
`
`ARENDI-DEFS00004251
`
`

`

`Case 1:13-cv-00919-LPS Document 311-8 Filed 03/10/21 Page 6 of 201 PageID #: 29252
`
`CHAP T ER 16
`
`Find
`
`Using Your Own Text-Searching Method
`
`The following code example illustrates the kinds of tasks you must perform when
`the StandardFind method is not used. (However, it is strongly suggested that
`you use the StandardFind method to implement your Find routine, if possible.)
`This example searches for text in soup-based application data using the
`ROM_SoupFinder proto:
`
`This routine MUST be named Find; it is called by
`the system when the user chooses Find.
`MyApplicationBase.Find :_
`func(what, results, scope, statusView)
`begin
`local myFinder;
`
`Report status to the user;
`note use of GetAppName and Unicode ellipsis.
`if statusView then
`statusView:SetMessage("Searching in " &
`GetAppName(kAppSymbol)& $\u2026);
`
`Presume our soup def is registered,
`however, app may be closed so get our own soup.
`local mySoup:= GetUnionSoupAlways("My Soup");
`
`Make sure a member soup exists so query won't
`fail (GetMember creates the soup if necessary).
`mySoup:GetMember(GetDefaultStore());
`
`//Retrieve entries with strings beginning with "what".
`local myCursor := mySoup: Query({text: what});
`
`// Append finder to system-supplied results array
`if cursor:Entry() then
`begin
`
`myFinder
`
`{
`
`proto: ROM SoupFinder,
`owner: self,
`title:"My Application",
`findType: 'text,
`findWords: :MyStringSplittingFn(what),
`cursor: myCursor,
`
`};
`AddArraySlot(results, myFinder);
`
`end;
`end;
`
`16-16
`
`Using the Find Service
`
`ARENDI-DEFS00004252
`
`

`

`Case 1:13-cv-00919-LPS Document 311-8 Filed 03/10/21 Page 7 of 201 PageID #: 29253
`
`CHAP T ER 16
`
`Find
`
`Finding Text With a ROM_CompatibleFinder
`
`The following example shows how to use the ROM_CompatibleFinder proto to
`search for text in application data that is not soup based. The sample code
`immediately following doesn't contain code that actually searches application data,
`because the implementation of such a search would be specific to the data type
`used to store the application data.
`
`MyAppplicationBase.Find:=
`func(what, results, scope, statusView)
`begin
`local item, foundItems, massagedFoundItems, myFinder;
`
`// Set the message in the Find slip.
`if statusView then
`statusView:SetMessage("Searching in " &
`GetAppName(kAppSymbol) & $\u2026);
`
`MyFindMethod does the actual searching, since
`this is too app-specific to do here. It returns
`an array of all the data items that match 'what.
`foundItems := MyFindMethod(what);
`
`Now we create an array with frames of the form
`mandated for ROM CompatibleFinder.
`_
`massagedFoundItems =
`foreach item in foundItems collect
`{
`
`// Use proto inheritance to protect data
`_proto : item,
`This is seen by the user in the Overview
`(pretend our data is frames w/'name slots)
`: item.name,
`title
`We may add any other slots here our
`methods may want later
`
`};
`
`Construct the finder frame.
`myFinder :_
`{_proto: ROM_CompatibleFinder, // For non-soup data
`owner: self,// View receiving ShowFoundItem message
`title: "My App",
`items: massagedFoundItems,
`findType : 'text,
`findWords: :MyStringSplittingFn(what),
`
`Using the Find Service
`
`16-17
`
`ARENDI-DEFS00004253
`
`

`

`Case 1:13-cv-00919-LPS Document 311-8 Filed 03/10/21 Page 8 of 201 PageID #: 29254
`
`CHAP T ER 16
`
`Find
`
`We may also add slots here...
`
`Append myFinder frame to system's results array
`AddArraySlot(results, myFinder);
`end;
`
`I mplementing the DateFind Method
`
`Date-based searches have a lot in common with their text-based counterparts; in
`fact the only significant difference between these two operations is the search
`criteria. Rather than matching a text string, the DateFind method tests items
`against a time value according to the value of the f indType parameter. This
`parameter indicates whether the search should include results for items dated on,
`after, or before a specified date.
`
`You can simplify the implementation of date-based searches by time-stamping your
`application's data when it is stored. If you store application data as frames that hold
`the time they were created or modified in a particular slot, the DateFind method
`simply tests the value of this slot to accept or reject the entry.
`
`The sample code immediately following shows the implementation of a typical
`DateFind method using the ROM_SoupFinder proto. This code assumes that
`soup entries have a timestamp slot:
`
`MyApplicationBase.DateFind :_
`func(findTime, findType, results, scope, statusView)
`begin
`local myCursor
`local querySpecFrame;
`local querySpec;
`local ourFinder;
`local mySoup;
`constant kOneDay := 60*24;
`
`// report status to the user
`if statusView then
`statusView:SetMessage("Searching in " &
`GetAppName(kAppSymbol) & $\u2026);
`
`// Get the soup
`mySoup:= RegUnionSoup(kAppSymbol, kSoupDef);
`
`16-18
`
`Using the Find Service
`
`ARENDI-DEFS00004254
`
`

`

`Case 1:13-cv-00919-LPS Document 311-8 Filed 03/10/21 Page 9 of 201 PageID #: 29255
`
`CHAP T ER 16
`
`Find
`
`querySpecFrame :=
`
`{
`
`dateBefore
`
`{
`indexPath : 'timeStamp,
`endKey: findTime,
`
`dateAfter
`
`{
`indexPath : 'timeStamp,
`beginKey: findTime,
`
`dateOn
`
`{
`indexPath : 'timeStamp,
`beginKey: kOneDay *
`(findTime div kOneDay)
`endKey: kOneDay + kOneDay *
`(findTime div kOneDay)
`
`};
`local querySpec := querySpecFrame.(findType);
`
`}
`
`// Get the cursor.
`myCursor := mySoup:Query(querySpec);
`
`Set up finder frame and add it to the results
`array.
`if myCursor:Entry() then
`begin
`ourFinder
`
`{
`
`proto: ROM SoupFinder,
`owner: self,
`title: "My Application",
`findType: findType,
`findWords: [DateNTime(findTime)],
`cursor: myCursor
`
`};
`AddArraySlot(results, ourFinder);
`end;
`end;
`
`Adding Application Data Sets to Selected Finds
`
`You can allow users to choose data sets in an application to search by adding the
`AppFindTargets method and either or both of the FindTargeted or
`DateFindTargeted methods. This functionality is useful when you want to
`
`Using the Find Service
`
`16-19
`
`ARENDI-DEFS00004255
`
`

`

`Case 1:13-cv-00919-LPS Document 311-8 Filed 03/10/21 Page 10 of 201 PageID #: 29256
`
`CHAP T ER 16
`
`Find
`
`limit a Find operation to certain data sets of an application. For example, a personal
`finance program may have a check ledger, an account list, and a credit card charges
`list. Another example is an online sales catalog program that could allow users to
`separately search different catalogs. Even though a single application is receiving
`the Find message, a Selected find operation from the Find slip allows the user to
`designate any or all of the associated data sets for the Find operation.
`
`To enable multiple data sets in a find operation, first add the method
`AppFindTargets to your application's base view. This method must return an
`array of frames that specify the data sets for the application. These data set frames
`consist of a name and target pair of slots for each data set, in the following form:
`
`[ {name : "userVisibleText" , target: thisDataForYourUse} , { ... } ]
`
`The name slot of the data set frame holds the string to be displayed in the picker
`which displays when the Find slip's Selected button is tapped. The target slot, of
`the data set frame, can be set to anything; it is passed to your FindTargeted (or
`DateFindTargeted) method. There may be any number of these data set frames
`included.
`
`An example AppFindTargets method may be defined as follows:
`
`MyApplicationBase.AppFindTargets: func()
`begin
`
`[{name:"Check Book", target:'check},
`{name:"Accounts", target: 'accounts},
`{name "Credit Cards", target:'credit}];
`
`end;
`
`You must then add the search methods to your finder frame. These methods
`leverage from the built-in Find and DateFind methods, adding the data set you
`refer to in the target slot as an additional parameter. You define a
`FindTargeted method as shown in the following example:
`
`MyApplicationBase.FindTargeted:
`func (what,sysResultArray,scope, statusView,target)
`// N.B. Scope for Selected find is always 'globalFind
`begin
`local mySoup;
`Assume the target parameter is the name of the
`soup to search... (We provided this value in
`base.AppFindTargets.)
`
`Must include the following line... See "Using the
`StandardFind Method."
`local temp := GetUnionSoupAlways(target)
`:StandardFind( what, target, sysResultArray,
`statusView, 'text);
`
`end;
`
`16-20
`
`Using the Find Service
`
`ARENDI-DEFS00004256
`
`

`

`Case 1:13-cv-00919-LPS Document 311-8 Filed 03/10/21 Page 11 of 201 PageID #: 29257
`
`CHAP T ER 16
`
`Find
`
`Note
`Applications implementing these methods must also implement
`the usual Find and DateFind methods since afind operation
`may be dispatched as other than a Selected find.
`
`Returning Search Results
`
`After constructing the finder frame, your search method needs to append it to the
`system-supplied results array. Each element in this array is afinder frame. In
`the case of a finder based on the ROM SoupFinder, the array the frame has a
`cursor for obtaining the items found in the search. In the case of a finder based on
`the ROM_CompatibleFinder proto, your finder frame contains an array of the
`found items themselves. You need to use the global function AddArraySlot to
`append your finder frame to the results array.
`
`The following example shows a line of code that would be placed at the end of
`your application's search method to store the results of the search. In this code
`fragment, the results parameter is the system-supplied array passed to the Find
`method, and the myFinder parameter is the finder frame resulting from the
`search. The following call to AddArraySlot places the finder frame, myFinder,
`at the end of the results array:
`
`AddArraySlot(results, myFinder);
`
`Note that the system's results array is cleared when the Find slip closes.
`
`I mplementing Find Overview Support
`The messages described in this section are sent to your application when the user
`taps buttons in the Find overview. These include:
`n the FindSoupExcerpt message
`n the ShowFoundltem message
`If your finder frame is based on ROM_CompatibleFinder, you do not need to
`write a FindSoupExcerpt method, but you must also write a ShowFakeEntry
`method to call your ShowFoundltem method.
`
`The FindSoupExcerpt Method
`
`If you use the ROM_SoupFinder proto to construct a finder frame, your
`application must supply a FindSoupExcerpt method. This methods must extract
`the name of a found item when it is given the soup entry and the finder frame, and
`return it to the system as a string to display in the Find overview.
`
`Using the Find Service
`
`16-21
`
`ARENDI-DEFS00004257
`
`

`

`Case 1:13-cv-00919-LPS Document 311-8 Filed 03/10/21 Page 12 of 201 PageID #: 29258
`
`CHAP T ER 16
`
`Find
`
`Your FindsoupExcerpt method may also extract extra information if the finder
`frame has been set up to hold additional data. For example, if the date associated
`with each found item was saved, you could use this information to build more
`descriptive titles for overview items.
`
`The following example shows the implementation of a simple
`FindsoupExcerpt method:
`
`myApplication.FindSoupExcerpt:=
`func(entry, myFinder)
`begin
`//We simply return the string in our entry's name slot
`entry.name;
`
`end
`
`For a complete description of the FindsoupExcerpt method, see
`"FindSoupExcerpt" (page 13-19) in Newton Programmer's Reference.
`
`If you are using the ROM_CompatibleFinder proto, this finder must contain the
`strings that a ROM_SoupFinder's FindsoupExcerpt method would return. For
`more information see the description of the items array in
`"ROM_ CompatibleFinder" (page 13-7) in Newton Programmer's Reference.
`
`The ShowFoundltem Method
`
`This method locates the specified item in your application's data and displays it,
`performing any scrolling or highlighting that is appropriate. A typical
`ShowFoundltem method may need to
`n open a view appropriate for displaying the target
`n set the cursor or the target slot to reference the target
`n scroll the contents of the display view to make the target visible
`n highlight the target in the display view
`The implementation of a ShowFoundltem method depends on which finder proto
`you use. This section describes an example ShowFoundltem method suitable for
`use with the ROM_SoupFinder proto.
`
`If you've based your finder frame on the ROM _SoupFinder proto, the
`ShowFoundltem method is passed two arguments: the soup entry that
`the user tapped in the Find overview, and the finder frame your application
`added to the results array of finder frames.
`
`The system expects your application's ShowFoundltem method to look like the
`following example:
`
`ShowFoundltem: func(myEntry, myFinder) begin . . end
`
`16-22
`
`Using the Find Service
`
`ARENDI-DEFS00004258
`
`

`

`Case 1:13-cv-00919-LPS Document 311-8 Filed 03/10/21 Page 13 of 201 PageID #: 29259
`
`CHAP T ER 16
`
`Find
`
`In the body of this method, you need to do whatever is necessary to display the
`soup entry myEntry. Typically, you first send a Close message to the Overview
`and then open the view that displays the entry. The following code fragment shows
`the implementation of atypical ShowFoundltem method.
`
`// For use with ROM_SoupFinder proto
`myApplication.ShowFoundItem:=
`func(entry, myFinder)
`begin // close my overview if it's open
`if currentView = my0verview then begin
`myOverView:Close();
`myDisplayView:Open();
`// open view that displays the entry
`end;
`scroll, highlight, etc. as necessary
`to display the entry
`myDisplayView:DisplayEntry(entry, cursor);
`
`end
`
`Your application is always open when the ShowFoundltem message is sent to it.
`For example, this message is sent when the user scrolls between found items from
`within the Find slip. The system also invokes this method when the user taps an
`item in the Find overview. In this case, the system opens your application, if
`necessary, before sending the ShowFoundltem message to it.
`
`Note that if no items are found this message is never sent.
`
`Using ShowFoundltem with ROM_CompatibleFinder
`If you are using afinder based on ROM_CompatibleFinder, you still need to
`implement a ShowFoundltem in your application's base view. Your finder also
`needs to override the ShowFakeEntry method. Your ShowFakeEntry method
`needs to call your ShowFoundltem method, making sure that your application is
`open first. Your ShowFoundltem method should accept an element of the finder's
`items array as its first parameter, instead of a soup entry. It should perform the
`same actions as a ShowFoundltem method that expects a soup entry, as described
`in "The ShowFoundItem Method" (page 16-22).
`
`The following example demonstrates a typical ShowFakeEntry method:
`
`myFinder
`
`{
`
`proto : ROM CompatibleFinder,
`ShowFakeEntry : func (index)
`begin
`local myApp;
`if myApp := GetRoot.(kAppSymbol) then
`
`Using the Find Service
`
`16-23
`
`ARENDI-DEFS00004259
`
`

`

`Case 1:13-cv-00919-LPS Document 311-8 Filed 03/10/21 Page 14 of 201 PageID #: 29260
`
`CHAP T ER 16
`
`Find
`
`begin
`myApp:Open();
`myApp:ShowFoundItem (items[index], self);
`end;
`end,
`
`} R
`
`eplacing the Built-in Find Slip
`
`Applications can replace the system-supplied Find slip with a customized version,
`which is called when the application is frontmost. To implement a custom Find slip
`that displays in your application, include a method named CustomFind in the
`application's base view. This CustomFind method must open the Find slip you
`constructed and do anything else that's appropriate, including displaying found items.
`
`Reporting Progress to the User
`
`It is strongly recommended that your status messages be consistent with those that
`the built-in Newton applications display while a Find operation is in progress; for
`example, you can use a message such as "Searching in appName."
`
`Your search method is passed a status View parameter which is the view the system
`is using to report progress. You can display a string in this view, by calling its
`SetMessage method. Figure 16-10 depicts a typical status message from the Find
`service.
`
`Figure 16-10 Typical status message
`
`Searching haystack for needles_
`¤ Lookfor needles
`
`I
`
`Find M
`
`16-24
`
`Using the Find Service
`
`ARENDI-DEFS00004260
`
`

`

`Case 1:13-cv-00919-LPS Document 311-8 Filed 03/10/21 Page 15 of 201 PageID #: 29261
`
`CHAP T ER 16
`
`Find
`
`The following code fragment shows how to use the statusView parameter to
`display a progress message to the user:
`
`MyAppplicationBase.Find:=
`func(what, results, scope, statusView)
`begin
`if statusView then
`statusView:SetMessage("Searching in" &
`GetAppName(kAppSymbol)&
`$/u2026);
`
`end;
`
`There are several ways to obtain the application name string that replaces the
`appName variable; they are listed here in order of recommended use:
`n You can retrieve this string from the appName slot in your application's base view.
`n You can retrieve this string from the title slot in your finder frame.
`n You can retrieve this string by calling GetAppName (kAppSymbol) ;
`
`Registering for Finds
`
`Applications registered with the Find service participate in Global finds; they also
`participate in selective finds when specified by the user.
`
`You do not need to register with the Find service to support Local finds. Global
`and Local find support use the same mechanism, which relies on the Find and
`ShowFoundltem methods that your application supplies. A Global find is simply
`a series of Local finds initiated by the system in applications that have registered
`for participation in Global finds.
`
`Use the RegFindApps function to register your application with the Find service
`and its counterpart, the UnRegFindApps function, to reverse the effect. You
`should call these functions from your application part's Instal lScript and
`RemoveScript functions.
`
`Using the Find Service
`
`16-25
`
`ARENDI-DEFS00004261
`
`

`

`Case 1:13-cv-00919-LPS Document 311-8 Filed 03/10/21 Page 16 of 201 PageID #: 29262
`
`CHAP T ER 16
`
`Find
`
`Summary
`
`Finder Protos
`
`// Use to find soup entries.
`mySoupFinder:= {
`proto: ROM SoupFinder,
`owner:self, // View that gets ShowFoundItem message
`usually your app's base view
`title: "My Application",// Displayed in Find overview
`// usually inherited from owner
`cursor:myCursor,// Returned by search method's query
`findType:'text// Must use this value for text search
`findWords: [search strings] // Array of words to match
`selected: [] , // Internal array of selected items
`Count: func(),//Returns # found items; don't override
`Delete: func(), // Deletes all selected items
`FileAndMove: func
`(labelsChanged, newLabel, storeChanged, newStore) ,
`// Files and/or moves selected items
`ForEachSelected: func (callbackFunction) , // Calls callback
`// func for each selected found item; dont override
`GetTarget: func(), //Returns target frame; for routing
`IsSelected: func(item), // Returns true if item
`selected; don't override.
`Reset: func(), // Resets cursor; don't override.
`ReSync: func(), // Resets SoupFinder; do not override.
`SelectItem: func(item), // Marks item as selected
`ShowFoundItem: func (item, finder) ,
`ShowEntry: func (entry) , // Displays entry;
`// don't override
`ShowOrdinalItem: func (ordinal) , //Shows found item
`// specified by integer
`ZeroOneOrMore: func(), // Returns number of items;
`don't override
`
`}
`
`16-26
`
`Summary
`
`ARENDI-DEFS00004262
`
`

`

`Case 1:13-cv-00919-LPS Document 311-8 Filed 03/10/21 Page 17 of 201 PageID #: 29263
`
`CHAP T ER 16
`
`Find
`
`myCompatibleFinder:= {// Use to find data stored in
`non-soup data structures
`//Override most to fit your data.
`proto: ROM CompatibleFinder,
`owner:self, // Required. View that gets ShowFoundItem
`message;usually your app's base view.
`title: "My Application",// Displayed in Find overview;
`// usually inherited from owner.
`findType:'text// Can also be 'dateBefore,
`//'date0n, or 'dateAfter.
`f indWords : [ textOrDate]/ / Text or date to find.
`items:[// Array of the items found by your search.
`{_proto: myFoundItem, //Optional; but better
`//to reference data as it
`//gets altered destructively.
`title: "My Application",//String displayed in
`//Find overview.
`
`I
`{ /* and other such frames...
`
`selected: [1 , // Internal array of selected items.
`ConvertToSoupEntry: func(item),//Return a soup entry
`//corresponding to data item.
`Count: func(),//Returns number of found items;
`// don't override.
`Delete: func(), // Deletes all selected items.
`FileAndMove : func (labelsChanged, newLabel,
`storeChanged, newStore) ,
`Files and/or moves selected items
`ForEachSelected: (callbackFunction) , // Calls callback
`function for each selected
`found item; don't override.
`GetTarget: func(), //Returns target frame; for routing
`IsSelected: func(item), // Returns true if item is
`selected; don't override.
`ReSync: func(), // Resets finder to its initial
`state; do not override.
`SelectItem: func(item), // Marks item as selected
`ShowFakeEntry: func(index), // Displays the index(th)
`number found item. Replaces
`ShowFoundItem in compatabile finder.
`
`}
`
`Summary
`
`16-27
`
`ARENDI-DEFS00004263
`
`

`

`Case 1:13-cv-00919-LPS Document 311-8 Filed 03/10/21 Page 18 of 201 PageID #: 29264
`
`CHAP T ER 16
`
`Find
`
`Functions and Methods
`
`RegFindApps(appSymbol)
`
`//registers app. for global &
`//selected finds
`UnRegFindApps(appSymbol) //unregs. app for non-local finds
`status View: SetMessage (msg) //sets string in progress view
`view: StandardFind ( what, soupName, results, status View, indexPatb)
`//searches soups
`
`Application-Defined Methods
`
`appBase: Find ( what, results, scope, status View) //text find
`appBase: FindTargeted ( what, results, scope, status View, target)
`// targeted text find
`appBase: DateFind (findTime, compareHow, results, scope, status View)
`// date find
`appBase: DateFindTargeted ( what, results, scope, status View, target)
`// targeted date find
`appBase:AppFindTargets ()//sets targets for targeted finds
`targetView: FindSoupExcerpt (entry, resultFrame) // returns string
`// to display in find overview
`targetView: ShowFoundItem (foundltem, ruyFinder) //show found
`//item
`
`appBase:CustomFind() //Does all find work
`
`16-28
`
`Summary
`
`ARENDI-DEFS00004264
`
`

`

`Case 1:13-cv-00919-LPS Document 311-8 Filed 03/10/21 Page 19 of 201 PageID #: 29265
`
`C H A P T E R 1 7
`
`Additional System Services
`
`This chapter discusses system services not covered elsewhere in this book. The
`topics covered in this chapter are
`n Providing the capability to undo and redo user actions.
`n Using idler objects to perform periodic operations.
`n Using the notification service to respond to soup, folder, or user configuration
`change messages.
`n Using the alerts and alarms service to display user messages and execute
`callback functions at specified times.
`n Using progress indicators to provide user feedback.
`n Using the power registry to execute callback functions when the Newton is
`powered on or off.
`n Using a custom help book to provide online help to the user.
`If you are developing an application that utilizes any of these objects or services,
`you should familiarize yourself with the material discussed in this chapter.
`
`About Additional System Services
`
`This section briefly describes the undo, idler objects, alerts and alarms, change
`notification, progress reporting, and power registry services. These are discussed in
`greater detail later in this chapter.
`
`Undo
`The Undo service is the mechanism the system provides for undoing and redoing
`the user's most recent action. From within each function or method that must
`support Undo, your application registers a function object that can reverse the
`actions of that function or method. This function object is called an undo action,
`and is called when the user taps the Undo button. The undo action can then register
`
`About Additional System Services
`
`17-1
`
`ARENDI-DEFS00004265
`
`

`

`Case 1:13-cv-00919-LPS Document 311-8 Filed 03/10/21 Page 20 of 201 PageID #: 29266
`
`CHAP T ER 17
`
`Additional System Services
`
`a function object to redo the original function or method. Thus tapping the Undo
`button twice completes an undo/redo cycle.
`
`Undo Compatibility
`
`The user interface standards for version 2.0 of the Newton operating system call for
`the user's second tap on the Undo button to provide a Redo rather than a second
`level of Undo. Your undo action must create an undo action for itself to implement
`this interface. For more information, see the section "Using Undo Actions"
`beginning on page 17-8.
`
`The global function AddUndoAction is obsolete, replaced by the view method of
`the same name that provides similar functionality. Existing code that uses the
`global function can be converted by prefixing a colon to the message selector.
`For example:
`
`AddUndoAction(....)
`
`becomes
`
`:AddUndoAction(...)
`
`Idler Objects
`
`An idler object sends a message to your view periodically to execute the
`viewzdlescript method you provide for that view. Thi