Abstract:
A slide show, integrated into an email application, displays images such as those included as an attachment to an email message. The user can view the slide show without exiting the email application. Slide show navigation controls are provided. An index sheet mode can be activated wherein a number of thumbnails are displayed, allowing easy navigation to any image within the slide show. Transition animations can be provided for clarifying operations such as activating and dismissing the index sheet.

Description:
CROSS-REFERENCE TO RELATED APPLICATIONS 
     This application is a continuation of U.S. patent application Ser. No. 11/319,906 filed Dec. 27, 2005, which claims the benefit of U.S. Provisional Application No. 60/642,153 filed Jan. 7, 2005, each of which is incorporated by reference in its entirety. 
     The present invention is related to the following utility patent applications, the disclosures of which are incorporated herein by reference: 
     U.S. patent application Ser. No. 10/877,968 for “Unified Interest Layer for User Interface,” filed Jun. 24, 2004; 
     U.S. patent application Ser. No. 10/465,855 for “Computer Interface Having a Virtual Single-Layer Mode for Viewing Overlapping Objects,” filed Jun. 20, 2003; 
     U.S. patent application Ser. No. 10/689,687 for “Computer Interface Having a Virtual Single-Layer Mode for Viewing Overlapping Objects,” filed Oct. 22, 2003. 
    
    
     FIELD OF THE INVENTION 
     The present invention relates generally to displaying images within the context of an application such as an email application, and more particularly to improved techniques for navigating within a series of images such as a slide show. 
     BACKGROUND OF THE INVENTION 
     Conventionally, there is no convenient way to browse and view a series of image attachments received via email without leaving that email application. Images can appear inline in the body of the email, but browsing through a series of image attachments is restricted to vertically scrolling the body of the email. The presentation size of these image attachments is also restricted to the size of the email application view window, which is typically small. Existing software applications that allow a user to browse and view images, are not generally integrated into email applications. Additionally, a user may have to download and import the images into such software applications in order to view them, but this takes time and is often not desired when the user just wants to quickly see the images in a received email message. 
     In addition, it is often difficult to navigate within a series of images such as within a slide show. An image may be shown, with arrows for moving forwards and backwards. Such a display does not facilitate instantaneous movement from one image to a second image that is not adjacent to the first. Such a display also fails to provide the user with a sense of the context of the current image within the overall slide show or set of images. There is no easy and convenient way to switch between the full-sized view and a view that reveals context. 
     Image navigation systems and software often provide a series of thumbnails, allowing the user to click on a thumbnail to see a full-sized version of the corresponding image. However, these schemes still provide no easy way to easily switch between a full-sized view and a view that provides context showing where the image fits within the overall slide show. 
     SUMMARY OF THE INVENTION 
     The present invention provides an improved mechanism for navigating within a series of images such as a slide show. 
     According to one aspect of the present invention, image attachments can be easily viewed without leaving an email application. 
     According to one aspect of the present invention, images are presented in a manner that provides for easy switching between full-sized and thumbnail view, and that preserves a sense of context so that the user knows where the image fits within the overall slide show. The user can easily switch between modes, and can easily move to any image within the slide show or image series. 
     According to one aspect of the present invention, the invention provides a full-screen slide show environment, with easy access to instantaneous navigation controls and thumbnails, all accessible directly within an email application. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       The accompanying drawings illustrate several embodiments of the invention and, together with the description, serve to explain the principles of the invention. 
         FIG. 1  is a screen shot depicting an example of an email client application with a slide show button, according to one embodiment of the present invention. 
         FIG. 2  is a screen shot depicting an example of an image being displayed in a slide show, according to one embodiment of the present invention. 
         FIG. 3  is a screen shot depicting an example of an index sheet, according to one embodiment of the present invention. 
         FIG. 4  is a screen shot depicting an example of a transition that takes place after the user has selected a thumbnail from the index sheet, according to one embodiment of the present invention. 
         FIG. 5  is a screen shot depicting a continuation of the example transition of  FIG. 4 , according to one embodiment of the present invention. 
         FIG. 6  is a block diagram depicting an example of a software architecture for implementing the present invention according to one embodiment. 
     
    
    
     One skilled in the art will recognize that these Figures are merely examples of the operation of the invention according to one embodiment, and that other user interface arrangements and modes of operation can be used without departing from the essential characteristics of the invention. 
     DETAILED DESCRIPTION OF THE EMBODIMENTS 
     The present invention is now described more fully with reference to the accompanying Figures, in which several embodiments of the invention are shown. The present invention may be embodied in many different forms and should not be construed as limited to the embodiments set forth herein. Rather these embodiments are provided so that this disclosure will be complete and will fully convey the invention to those skilled in the art. 
     For illustrative purposes, the invention is described in connection with presenting images in an email application for an operating system such as MacOS X from Apple Computer, Inc. Various specific details are set forth herein and in the Figures, to aid in understanding the present invention. However, such specific details are intended to be illustrative, and are not intended to restrict in any way the scope of the present invention. In particular, one skilled in the art will recognize that the invention can be used for navigating among images and/or other non-image elements within any type of software application. In addition, one skilled in the art will recognize that the invention can be used in connection with any input mechanism for selecting, manipulating, and moving on-screen images, including manipulation of an on-screen cursor using a pointing device, keyboard control, voice control, mouse wheel, touch screen control, or the like, or any combination of the above. In addition, the particular screen layouts, appearance, and terminology as depicted and described herein, are intended to be illustrative and exemplary, and in no way limit the scope of the invention. 
     In one embodiment, the present invention is implemented in a conventional personal computer system, such as a Macintosh, (available from Apple Computer, Inc. of Cupertino, Calif.), running an operating system such as MacOS X (also available from Apple Computer, Inc.). The invention may be embodied in software that runs on the personal computer. The invention may be included as add-on software, or it may form part of the operating system itself, or it may be a feature of an application that is bundled with the computer system or sold separately. The various features of the invention as described herein include output presented on a display screen that is connected to the personal computer. In addition, the invention makes use of input provided to the computer system via input devices such as a keyboard, mouse, touchpad, or the like. Such hardware components, including their operation and interactions with one another and with a central processing unit of the personal computer, are well known in the art of computer systems and therefore are not depicted here. Several Figures are presented as screen shots depicting examples of the user interface as it might appear on a display screen or other output device. In addition, the techniques described herein can be implemented in other types of devices, including cell phones, personal digital assistants, television displays, kiosks, or the like. 
     User Experience 
     In one embodiment, the invention operates as follows: 
     Referring now to  FIG. 1 , there is shown a screen shot depicting an example of an email client application displaying a message  100 . The user receives email message  100  that includes one or more image attachments  102 . Slide show button  101  appears in header region  103  of message  100 . In one embodiment, button  101  is only presented if message  100  contains images. In other embodiments, other mechanisms for activating a slide show may be provided, including keyboard commands, menu items, or the like. 
     The user can click on button  101  to initiate a slide show. The computer screen fades to black and then fades into a full screen view of the first image attachment. Referring now to  FIG. 2 , there is shown a screen shot depicting an example of an image  201  being displayed in a slide show, according to one embodiment of the present invention. 
     After a period (for example 3 seconds), the first image  201  fades into the next image attachment in the sequence, and so on until all the images have been viewed. Then, in one embodiment, the slide show repeats. 
     In an alternative embodiment, the slide show is presented within a window rather than occupying the entire screen. In another alternative embodiment, the slide show is presented in semi-transparent form overlaying the normal desktop display. In one embodiment, any or all of the characteristics of the slide show are configurable by the user (for example, whether it repeats, the size of the presentation, delay between one slide and the next, and the like). 
     Semi-transparent toolbar cluster  202  (or dock) appears at the bottom of the screen. It contains a series of buttons that allow the user to interact with the slide show. From left to right they are:
         Back: Go to the previous image.   Play/Pause: Animate the slideshow from one image to the next, or pause on the current frame   Next: Go to the next image   Index Sheet: Show all the images in this slideshow.   Full Screen/Actual Size: Toggle between showing the image at its actual size and showing it scaled up to fit the computer screen   Add to iPhoto: Automatically add the current image to iPhoto   Exit Slideshow: Exit the full screen slideshow presentation and return to the application view.
 
Index Sheet
       

     The Index Sheet button provides quick access to a screen depicting thumbnails. This may be overlaid on the existing desktop, as an opaque screen or a semi-transparent one. In one embodiment, the index sheet can be activated by moving the cursor to a predefined corner of the screen. The index sheet allows a user to easily see the context of the current image within the slide show, and also allows the user to quickly jump to any other image in the slide show. 
     Referring now to  FIG. 3 , there is shown a screen shot depicting an example of an index sheet  301 , according to one embodiment of the present invention. 
     When the user presses the Index Sheet button in cluster  202  (or otherwise activates the index sheet), the current image  201  animates and scales smaller. At the same time all the other images in the slideshow also animate and scale smaller behind the current image. As the images scale smaller, they align along a position in a grid that reflects the order of the slideshow presentation, as shown in  FIG. 3 . The first image appears as a thumbnail  302 A in the upper left, the next image appears as a thumbnail  302 B to the right of the first image, and so on. The spread-out view of all the image thumbnails  302 A through  302 J forms index sheet  301 ; it is organized in a rectangular grid akin to a photographic contact sheet that shows a number of images on a single page. In one embodiment, all images are scaled to the same size, or to approximately the same size except for deviations resulting from different aspect ratios. In one embodiment, the size of the thumbnails  302  is selected according to the number of images and the size of the available viewable area. In one embodiment, if there are too many images to show all thumbnails  302  within the viewable area, a scrolling arrangement or other arrangement for viewing subsets of the thumbnails  302  is used. In one embodiment, the size is specified by a user. 
     In one embodiment, thumbnails  302  are arranged according to the image sequence within the slide show. In one embodiment, the presentation is according to filename (alphabetically), or chronological order by date modified or date created, or size, or some other ordering mechanism. In one embodiment, the user can dynamically select the order. 
     The user can roll over any thumbnail  302  (in other words, cause the on-screen cursor to hover over the image) to reveal its title  303  and/or to see other information about the image. In one embodiment, such information is shown in a semi-transparent manner superimposed on thumbnail  302  itself, as shown in the example of  FIG. 3 . In other embodiments, any other technique for displaying such information can be used. Any type of information can be displayed, including for example title, size, date created, date modified, or the like. 
     Clicking on a thumbnail  302  advances the slide show to that image and exits Index Sheet mode; the selected image animates and scales to full screen size while all the other images appear to scale to full screen size behind the selected image. Alternatively, the non-selected images may shrink until they are invisible, or they may fade to invisibility, or simply disappear as the selected image expands to fill the screen. Alternatively, they may simply appear to move behind the selected image. 
       FIGS. 4 and 5  depict an example of the transition between index sheet  301  and a full-screen display of image  201 A. In  FIG. 4 , thumbnails  302 A through  302 J have begun to shift position behind selected image  201 A, which has enlarged to full size. In  FIG. 5 , thumbnails  302 A through  302 J have moved so that they are almost completely hidden by selected image  201 A; they are also stacked on top of one another. 
     One skilled in the art will recognize that any other transition effect (or no transition effect) can be implemented without deviating from the essential characteristics of the present invention. 
     Add to iPhoto 
     At any point in the slide show presentation, the user can press the Add to iPhoto button to automatically add the currently viewed image to a photo management application (such as iPhoto, available from Apple Computer of Cupertino, Calif.) without exiting the slide show presentation. In one embodiment, the software displays an animation showing the currently viewed image being sucked into the Add to iPhoto button. This feature allows a user to browse a large series of images, and to easily choose which images he or she would like to import and keep for future use. 
     The present invention provides a slide show that is accessible from and works within an email application. As such, it does not require the user to leave the email environment in order to view their image attachments in an effective, versatile, full-screen, and pleasant way. In other embodiments, the features described above are provided within other types of applications, such as a file management application, presentation software, word processing software, or the like. 
     Architecture 
     In one embodiment, the above-described functionality is implemented as a standalone framework, so that any application or client can generate a user experience such as that described above. The present invention can be implemented in connection with images, PDF documents, text documents, or any other items or elements that can be presented visually. 
     In one embodiment, the invention is implemented as an application programming interface (API) in objC and/or C, using a known technology such as ImageIO to load images of multiple formats. Image formats include, for example, TIFF, JPEG, PNG, GIF, or the like. Image inputs can be provided in any of a number of forms that either contain or point to images. Examples include file paths, URLs, NSFileWrappers, NSImages, CGImageRefs, or the like. 
     In one embodiment, the invention includes a dynamically created user interface that adapts to environmental conditions and/or client feature sets. For example, in one embodiment, an Add to iPhoto button may be made available only if 1) the client application includes functionality for exporting images to iPhoto (i.e., if such an operation makes sense given the nature of the application), and 2) the iPhoto application is installed; otherwise, the Add to iPhoto button is not shown. In other environments or clients, the user interface may include other elements that are appropriate to those environments. For example, when the slide show of the present invention is being used in connection with an image viewer or search function, an Add to Mail button can be provided within the button cluster; when activated, this button would launch an email application and create a new email message with the selected image(s) attached. One skilled in the art will recognize that in other contexts, other buttons and operations would be applicable. 
     In one embodiment, the present invention displays various types of transitions. For example, when switching from one image to the next (in play mode, or in response to a user command), a distinctive transition may be shown; similarly, when switching from full-sized image mode to thumbnail mode, another transition may be shown. In one embodiment, these transitions are user-configurable. In one embodiment, they are implemented using a known video animation technology, assuming that the hardware video card supports such technology. In one embodiment, multiple transitions are available and can be applied in any combination. 
     In one embodiment, a particular type of transition and visual effect is used when switching from full-sized image mode to thumbnail mode and vice versa. An affine transform (translate/scale) is applied to position each image during the index transform and in index sheet mode. In one embodiment, the thumbnail display is presented in a semi-transparent window so that underlying elements (such as the desktop or the full-sized image that was being displayed) are visible through the thumbnail display. One skilled in the art will recognize that such visual enhancements are optional, and that the present invention can be implemented using many different types of visual techniques. 
     In one embodiment, the Add to iPhoto function is performed using AppleScript. The system of the invention keeps track of the images that a user wants to add to iPhoto. Upon quitting or closing the slide show, iPhoto is automatically launched, and the selected images are added to iPhoto under the direction of an AppleScript script. 
     Referring now to  FIG. 6 , there is shown a block diagram depicting an example of a software architecture for implementing the present invention according to one embodiment. Slideshow framework  600  is software code that implements the invention. Any client application can call upon and interface with framework  600 ; examples of such applications include an email application  601 , search application (such as Apple&#39;s Spotlight)  602 , viewer application (such as Apple&#39;s Preview)  603 , or file management component of an operating system (such as Apple&#39;s Finder)  604 . 
     Also shown is an example of code  605  that can be used by the calling application to invoke the slide show feature. Also shown is an example of code  606  in framework  600  for interfacing with the calling application. 
     Examples of header files for use in connection with an implementation of the present invention is as follows: 
     
       
         
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
           
               
                   
                   
               
             
             
               
                   
                 Slideshow.h 
               
             
          
           
               
                   
                 #import &lt;AppKit/AppKit.h&gt; 
               
               
                   
                 #import &lt;ApplicationServices/ApplicationServices.h&gt; 
               
               
                   
                 @class SlideshowPrivateVars; 
               
               
                   
                 // Slideshow data source 
               
               
                   
                 //---------------------------------------------------- 
               
             
          
           
               
                   
                 -------------- 
               
             
          
           
               
                   
                 @interface NSObject(SlideshowDataSource) 
               
               
                   
                 // required 
               
               
                   
                 − (int)numberOfObjectsInSlideshow; 
               
               
                   
                 − (id)slideshowObjectAtIndex: (int)index; 
               
               
                   
                 // optional 
               
               
                   
                 − (NSString*)slideshowObjectNameAtIndex: (int)index; 
               
               
                   
                 − (BOOL)canExportObjectAtIndexToiPhoto: (int)index; 
               
               
                   
                 − (void)exportObjectsToiPhoto: (NSIndexSet*)indexSet; 
               
               
                   
                 @end 
               
               
                   
                 // Slideshow 
               
               
                   
                 //---------------------------------------------------- 
               
             
          
           
               
                   
                 -------------- 
               
             
          
           
               
                   
                 @interface Slideshow : NSResponder 
               
               
                   
                 { 
               
             
          
           
               
                   
                 @private 
               
               
                   
                 SlideshowPrivateVars * mPrivateData; 
               
             
          
           
               
                   
                 } 
               
               
                   
                 + (Slideshow*)sharedSlideshow; 
               
               
                   
                 + (void)addImageToiPhoto: (id)image; 
               
               
                   
                 // To start the Slideshow for images: 
               
               
                   
                 // − either use setDataSource/startSlideshow 
               
               
                   
                 − (void)setDataSource: (id)dataSource; 
               
               
                   
                 − (void)startSlideshow: (id)sender; 
               
               
                   
                 // or use runSlideshowWithDataSource (preferred way) 
               
               
                   
                 − (void)runSlideshowWithDataSource: (id)sender 
               
             
          
           
               
                   
                 options: (NSDictio- 
               
             
          
           
               
                   
                 nary*)slideshowOptions; 
               
             
          
           
               
                   
                 // To start the Slideshow for a PDF: 
               
               
                   
                 − (void)runSlideshowWithPDF: (NSURL*)pdfURL 
               
             
          
           
               
                   
                 options: (NSDictio- 
               
             
          
           
               
                   
                 nary*)slideshowOptions; 
               
             
          
           
               
                   
                 − (void)stopSlideshow: (id)sender; 
               
               
                   
                 − (void)noteNumberOfItemsChanged; 
               
               
                   
                 − (void)reloadData; 
               
               
                   
                 − (int)indexOfCurrentObject; 
               
               
                   
                 − (void)setAutoPlayDelay: (float)seconds; 
               
               
                   
                 @end 
               
               
                   
                 // slideshow option keys: 
               
               
                   
                 //---------------------------------------------------- 
               
             
          
           
               
                   
                 -------------- 
               
             
          
           
               
                   
                 extern NSString *const SlideshowDontAutoShowMenuBar; 
               
             
          
           
               
                   
                 // boolean 
               
             
          
           
               
                   
                 extern NSString *const SlideshowStartIndex; 
               
             
          
           
               
                   
                 // number 
               
             
          
           
               
                   
                 extern NSString *const SlideshowAutoPlayDelay; 
               
             
          
           
               
                   
                 // number (in seconds) 
               
             
          
           
               
                   
                 extern NSString *const SlideshowPDFDisplayBox; 
               
             
          
           
               
                   
                 // PDFDisplayBox (see PDFKit) 
               
             
          
           
               
                   
                 extern NSString *const SlideshowPDFDisplayMode; 
               
             
          
           
               
                   
                 // PDFDisplayMode (see PDFKit) 
               
             
          
           
               
                   
                 extern NSString *const SlideshowPDFDisplaysAsBook; 
               
             
          
           
               
                   
                 // boolean 
               
             
          
           
               
                   
                 extern NSString *const SlideshowDebugMode; 
               
             
          
           
               
                   
                 // boolean (if YES - only capture main display) 
               
             
          
           
               
                   
                 // notifications a data source may register for: 
               
               
                   
                 //---------------------------------------------------- 
               
             
          
           
               
                   
                 -------------- 
               
             
          
           
               
                   
                 extern NSString *const SlideshowDidStopNotification; 
               
               
                   
                 extern NSString *const SlideshowDidChangeNotification; 
               
               
                   
                   
               
             
          
         
       
     
     
       
         
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
               
             
               
             
               
               
             
               
             
               
               
             
               
             
               
               
             
               
             
               
               
             
               
             
               
               
             
           
               
                   
               
             
             
               
                 Export2iPhoto.h 
               
             
          
           
               
                   
                 #import &lt;Cocoa/Cocoa.h&gt; 
               
               
                   
                 @class Export2iPhotoPrivateVars; 
               
               
                   
                 @interface Export2iPhoto : NSObject 
               
               
                   
                 { 
               
             
          
           
               
                   
                 @private 
               
               
                   
                 Export2iPhotoPrivateVars * mPrivateData; 
               
             
          
           
               
                   
                 } 
               
               
                   
                 + (BOOL)canExportToiPhoto; 
               
               
                   
                 + (BOOL)isPhotoFile: (id)file 
               
             
          
           
               
                   
                 allowConversion: (BOOL)allowFormatConversion; 
               
             
          
           
               
                   
                 + (BOOL)exportFile: (id)file;   
                 // 
               
             
          
           
               
                 file can be: NSFileWrapper 
               
             
          
           
               
                   
                 // 
               
             
          
           
               
                 NSURL 
               
             
          
           
               
                   
                 // 
               
             
          
           
               
                 NSString 
               
             
          
           
               
                   
                 // 
               
             
          
           
               
                 NSImage 
               
             
          
           
               
                   
                 // 
               
             
          
           
               
                 NSArray of any of the above... 
               
             
          
           
               
                   
                 @end 
               
               
                   
                   
               
             
          
         
       
     
                                                                                                                                                                                                                                                                                                                                                                                           SlideshowCarbon.h                #ifndef _SLIDESHOWCARBON —             #define _SLIDESHOWCARBON —             #if PRAGMA_ONCE           #pragma once           #endif           #include &lt;ApplicationServices/ApplicationServices.h&gt;           #ifdef _cplusplus           extern “C” {           #endif           // callbacks                typedef CALLBACK_API_C( UInt32 ,    SlideshowNumberO-            fURLsProc )( );                typedef CALLBACK_API_C( CFURLRef ,    SlideshowCopyURLA-            tIndexProc )(UInt32 index);                typedef CALLBACK_API_C( Boolean,    SlideshowCanExpor-            tURLAtIndexProc )(UInt32 index);                typedef CALLBACK_API_C( void,    SlideshowDidSwit-            chToIndexNotificationProc )(UInt32 index);                typedef CALLBACK_API_C( void,    SlideshowDidEndNo-            tificationProc )(UInt32 index);                typedef struct SlideshowCallbacks           {                SlideshowNumberOfURLsProc   sNum-            berOfURLsProc;                SlideshowCopyURLAtIndexProc   sCo-            pyURLAtIndexProc;                SlideshowCanExportURLAtIndexProc   sCa-            nExportURLAtIndexProc;                SlideshowDidSwitchToIndexNotificationProc   sDidS-            witchToIndexNotificationProc;                SlideshowDidEndNotificationProc   sEnd-            NotificationProc;                } SlideshowCallbacks;           // Slideshow C APIs           OSStatus SlideshowRunWithOptions(CFDictionaryRef            options,                SlideshowCallbacks            callbacks);                OSStatus SlideshowStop( );           // slideshow option keys:           //----------------------------------------------------            --------------                extern const CFStringRef kSlideshowDontAutoShowMenu-            Bar;   // boolean                extern const CFStringRef kSlideshowStartIndex;            // number                extern const CFStringRef kSlideshowAutoPlayDelay;            // number (in seconds)                extern const CFStringRef kSlideshowDebugMode;            // boolean (if YES - only capture main display)                #ifdef _cplusplus           }           #endif           #endif /* _SLIDESHOWCARBON_ */                        
Application Programming Interface for objC Client
 
     The following is a description of an application programming interface for accessing the functionality of the present invention via an objC client: 
     SlideshowDataSource Informal Protocol 
     When a client wants to use the slide show functionality, the client adopts the following informal SlideshowDataSource protocol, using the following two methods: 
     
       
         
               
               
             
               
               
             
           
               
                   
               
             
             
               
                 − (int)numberOfObjectsInSlideshow; 
                 This method is called by the 
               
               
                   
                 Slideshow framework to find 
               
               
                   
                 out the total number of images 
               
               
                   
                 the client wants to display. 
               
               
                 − (id)slideshowObjectAtIndex: 
                 Called by the Slideshow 
               
               
                 (int)index; 
                 framework, this method is used 
               
               
                   
                 to get an image for a given 
               
               
                   
                 index. 
               
               
                   
                 In one embodiment, the ‘image’ 
               
               
                   
                 returned can be of one of the 
               
               
                   
                 following types: 
               
             
          
           
               
                   
                 NSString (path to image 
               
               
                   
                 file on disk) 
               
               
                   
                 NSURL 
               
               
                   
                 NSFileWrapper 
               
               
                   
                 NSImage 
               
               
                   
                 CGImageRef 
               
               
                   
                   
               
             
          
         
       
     
     In one embodiment, the following additional methods are available as well: 
     
       
         
               
               
             
           
               
                   
               
             
             
               
                 − (NSString*)slideshowObjectNameAtIndex: 
                 This method is called by the Slide- 
               
               
                 (int)index; 
                 show framework if the image re- 
               
               
                   
                 turned by slideshowObjectAtIndex is 
               
               
                   
                 of type NSImage or CGImageRef— 
               
               
                   
                 these two variants do not contain an 
               
               
                   
                 image name. 
               
               
                   
                 If the client does return an NSImage 
               
               
                   
                 or a CGImageRef and does not im- 
               
               
                   
                 plement slideshowObjectNameAtIndex, 
               
               
                   
                 Slideshow displays a generic (Image 
               
               
                   
                 #) name in the index mode. 
               
               
                 − (BOOL)canExportObjectAtIndexToiPhoto: 
                 If a client implements this method, 
               
               
                 (int)index; 
                 Slideshow calls canExportObjectAtIn- 
               
               
                   
                 dexToiPhoto to enable/disable the 
               
               
                   
                 ‘Export to iPhoto’ button. If the 
               
               
                   
                 client does not implement this meth- 
               
               
                   
                 od -or- iPhoto is not installed -or- 
               
               
                   
                 an old (incompatible version) of 
               
               
                   
                 iPhoto is installed, the ‘Export to 
               
               
                   
                 iPhoto’ button is not shown in the 
               
               
                   
                 UI. 
               
               
                 − (void)exportObjectsToiPhoto: (NSIndex- 
                 If the user has used the ‘Add to 
               
               
                 Set*)indexSet; 
                 iPhoto’ action, Slideshow calls the 
               
               
                   
                 client with an NSIndexSet that con- 
               
               
                   
                 tains all indices of the images that 
               
               
                   
                 should be exported to iPhoto. 
               
               
                   
               
             
          
         
       
     
     The following methods are also provided in the Slideshow API: 
     
       
         
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
           
               
                   
               
             
             
               
                 + (Slideshow*)sharedSlideshow; 
                 This class method returns an in- 
               
               
                   
                 stance of a Slideshow that can be 
               
               
                   
                 used to display images or PDFs. 
               
               
                 + (void)addImageToiPhoto: (id)image; 
                 A handy way to add images to iPho- 
               
               
                   
                 to. 
               
               
                   
                 It takes as parameter: 
               
             
          
           
               
                   
                 NSString (path to image 
               
               
                   
                 file on disk) 
               
               
                   
                 NSURL 
               
               
                   
                 NSFileWrapper 
               
               
                   
                 NSImage 
               
               
                   
                 CGImageRef 
               
               
                   
                 NSArray (array of any of 
               
               
                   
                 the above) 
               
             
          
           
               
                 − (void)setDataSource: (id)dataSource; 
                 One of two ways to start a Slide- 
               
               
                 − (void)startSlideshow: (id)sender; 
                 show: setDataSource followed by 
               
               
                   
                 startSlideshow. 
               
               
                 − (void)runSlideshowWithDataSource: 
                 A second way to start the Slideshow. 
               
               
                 (id)sender options: (NSDictionary*) 
                 Parameters: 
               
             
          
           
               
                 slideshowOptions; 
                 dataSource 
               
               
                   
                 options: 
               
             
          
           
               
                   
                 SlideshowDontAutoShowMenuBar 
               
               
                   
                 SlideshowStartIndex 
               
               
                   
                 SlideshowAutoPlayDelay 
               
             
          
           
               
                 − (void)runSlideshowWithPDF: 
                 Used to start a slideshow with a 
               
               
                 (NSURL*)pdfURL options: (NSDictionary*) 
                 PDF. 
               
               
                 slideshowOptions; 
                 Parameters: 
               
             
          
           
               
                   
                 NSURL of the PDF 
               
               
                   
                 options 
               
             
          
           
               
                   
                 SlideshowPDFDisplayBox 
               
               
                   
                 SlideshowPDFDisplayMode 
               
               
                   
                 SlideshowPDFDisplaysAsBook 
               
             
          
           
               
                 − (void)stopSlideshow: (id)sender; 
                 Used to abort/stop a slideshow. 
               
               
                 − (int)indexOfCurrentObject; 
                 Allows the client to find out the in- 
               
               
                   
                 dex of the currently displayed im- 
               
               
                   
                 age. 
               
               
                 − (void)setAutoPlayDelay: (float)seconds; 
                 Allows the client to set the auto- 
               
               
                   
                 play-delay. 
               
               
                 SlideshowDidStopNotification 
                 Notification the client may register 
               
               
                   
                 for. Called when the Slideshow stops 
               
               
                   
                 (the user did press the cancel button 
               
               
                   
                 or hit escape) 
               
               
                 SlideshowDidChangeNotification 
                 Notification the client may register 
               
               
                   
                 for. Called when the Slideshow 
               
               
                   
                 changes from one image to another 
               
               
                   
                 (either in auto-play or in manual 
               
               
                   
                 previous/next or via index sheet). 
               
               
                   
               
             
          
         
       
     
     In one embodiment, Export2iPhoto is provided as a helper class used to export images to a photo management application such as iPhoto. It can also be used outside of a running Slideshow. The following methods are provided in the Export2iPhoto API: 
                                               + (BOOL)canExportToiPhoto   Returns YES if iPhoto is installed.           It checks also for the correct version           of iPhoto.       + (BOOL)isPhotoFile:   Returns YES if a given image can be       (id)file allowConversion:   exported to iPhoto. If the image is in       (BOOL) allowFormatConversion;   a format that iPhoto does not handle           directly, the caller has the option to           do a format conversion first.       + (BOOL)exportFile: (id)file;   Exports the given file(s) to iPhoto           It takes as parameter:                NSString (path to image           file on disk)           NSURL           NSFileWrapper           NSImage           CGImageRef           NSArray (array of any of           the above)                    
Application Programming Interface for Carbon Client
 
     The following is a description of an application programming interface for accessing the functionality of the present invention via a Carbon client: 
     
       
         
               
               
             
               
               
             
               
               
             
           
               
                   
               
             
             
               
                 OSStatus 
                 C API to start the Slideshow with the 
               
               
                 SlideshowRunWithOp- 
                 specified options: 
               
             
          
           
               
                 tions(CFDictionaryRef 
                 kSlideshowDontAutoShowMenuBar 
               
               
                 options, 
                 kSlideshowStartIndex 
               
               
                 SlideshowCallbacks 
                 kSlideshowAutoPlayDelay. 
               
             
          
           
               
                 callbacks); 
                 callbacks is an array of function point- 
               
               
                   
                 ers that specify the number of images, 
               
               
                   
                 image location, . . . 
               
               
                   
                 sNumberOfURLsProc: This callback is 
               
               
                   
                 called by the Slideshow framework to 
               
               
                   
                 find out the total number of images the 
               
               
                   
                 client wants to display. 
               
               
                   
                 sCopyURLAtIndexProc is called to get the 
               
               
                   
                 image (CFURLRef) at a given index (re- 
               
               
                   
                 quired). 
               
               
                   
                 sCanExportURLAtIndexProc 
               
               
                   
                 This callback is called to find out if the 
               
               
                   
                 image at a given index can be exported 
               
               
                   
                 to iPhoto. 
               
               
                   
                 sDidSwitchToIndexNotificationProc 
               
               
                   
                 This callback is called to notify client 
               
               
                   
                 that the user switched to a different im- 
               
               
                   
                 age. 
               
               
                   
                 sEndNotificationProc 
               
               
                   
                 This callback is called to notify the 
               
               
                   
                 client that the user has ended the 
               
               
                   
                 Slideshow. 
               
               
                 OSStatus 
                 This callback is called by the client to 
               
               
                 SlideshowStop( ); 
                 stop the Slideshow (in case the client 
               
               
                   
                 quits, the computer is shut down, or the 
               
               
                   
                 like.) 
               
               
                   
               
             
          
         
       
     
     In one embodiment, the present invention employs techniques described in pending U.S. patent applications cross-referenced above. 
     In particular, in one embodiment the present invention uses transition effects, user control techniques, and semi-transparency effects, similar to those described in the above-referenced patent applications. 
     In the above description, for purposes of explanation, numerous specific details are set forth in order to provide a thorough understanding of the invention. It will be apparent, however, to one skilled in the art that the invention can be practiced without these specific details. For example, the present invention can be applied in any type of application, and for displaying any type of data, including image and non-image files. The particular layouts and user interface elements described herein and illustrated in the Figures are examples only. 
     Reference in the specification to “one embodiment” or “an embodiment” means that a particular feature, structure, or characteristic described in connection with the embodiment is included in at least one embodiment of the invention. The appearances of the phrase “in one embodiment” in various places in the specification are not necessarily all referring to the same embodiment. 
     Some portions of the detailed description are presented in terms of algorithms and symbolic representations of operations on data bits within a computer memory. These algorithmic descriptions and representations are the means used by those skilled in the data processing arts to most effectively convey the substance of their work to others skilled in the art. An algorithm is here, and generally, conceived to be a self-consistent sequence of steps leading to a desired result. The steps are those requiring physical manipulations of physical quantities. Usually, though not necessarily, these quantities take the form of electrical or magnetic signals capable of being stored, transferred, combined, compared, and otherwise manipulated. It has proven convenient at times, principally for reasons of common usage, to refer to these signals as bits, values, elements, symbols, characters, terms, numbers, or the like. 
     It should be borne in mind, however, that all of these and similar terms are to be associated with the appropriate physical quantities and are merely convenient labels applied to these quantities. Unless specifically stated otherwise as apparent from the discussion, it is appreciated that throughout the description, discussions utilizing terms such as “processing” or “computing” or “calculating” or “determining” or “displaying” or the like, refer to the action and processes of a computer system, or similar electronic computing device, that manipulates and transforms data represented as physical (electronic) quantities within the computer system&#39;s registers and memories into other data similarly represented as physical quantities within the computer system memories or registers or other such information storage, transmission or display devices. 
     The present invention also relates to an apparatus for performing the operations herein. This apparatus may be specially constructed for the required purposes, or it may comprise a general-purpose computer selectively activated or reconfigured by a computer program stored in the computer. Such a computer program may be stored in a computer readable storage medium, such as, but is not limited to, any type of disk including floppy disks, optical disks, CD-ROMs, and magnetic-optical disks, read-only memories (ROMs), random access memories (RAMs), EPROMs, EEPROMs, magnetic or optical cards, or any type of media suitable for storing electronic instructions, and each coupled to a computer system bus. 
     The algorithms and modules presented herein are not inherently related to any particular computer or other apparatus. Various general-purpose systems may be used with programs in accordance with the teachings herein, or it may prove convenient to construct more specialized apparatuses to perform the method steps. The required structure for a variety of these systems will appear from the description below. In addition, the present invention is not described with reference to any particular programming language. It will be appreciated that a variety of programming languages may be used to implement the teachings of the invention as described herein. Furthermore, as will be apparent to one of ordinary skill in the relevant art, the modules, features, attributes, methodologies, and other aspects of the invention can be implemented as software, hardware, firmware or any combination of the three. Of course, wherever a component of the present invention is implemented as software, the component can be implemented as a standalone program, as part of a larger program, as a plurality of separate programs, as a statically or dynamically linked library, as a kernel loadable module, as a device driver, and/or in every and any other way known now or in the future to those of skill in the art of computer programming. Additionally, the present invention is in no way limited to implementation in any specific operating system or environment. 
     It will be understood by those skilled in the relevant art that the above-described implementations are merely exemplary, and many changes can be made without departing from the true spirit and scope of the present invention. Therefore, it is intended to cover all such changes and modifications that come within the true spirit and scope of this invention.