TweetFollow Us on Twitter

Dylan Application
Volume Number:10
Issue Number:9
Column Tag:Apple Technology First Look

Writing An Application In Dylan

Looking ahead to a richer programming experience

By Larisa Matejic, Brown University

Note: Source code files accompanying article are located on MacTech CD-ROM or source code disks.

Conceived and developed in Cambridge, Massachusetts, Dylan holds the promise of a new breed of development environment - dynamic, interactive, object oriented, and aimed at the professional application developer. As of this writing, the Dylan team continues to prepare Dylan for release. We’re pleased to be able to bring you this first look at developing an application in Dylan. Our author has worked with Dylan over the past year or so as an intern with Apple’s Cambridge group, and walks us through using Dylan to construct a QuickTime movie player. While we’ll bring you more articles on things like language specifics and the highly-interactive nature of the development environment later, this article should help you get a feel for putting together an application with Dylan - Ed stb

Dylan is one of the most versatile languages I have encountered. Apple Dylan has a number of features that make it easy and natural to use. Apple Dylan includes a development environment which greatly simplifies programming and debugging. Dylan’s expressive, yet simple syntax lends itself to efficient application development.

In this article, we’ll look at the process of writing a movie player application to explore Dylan’s unique features. We’ll focus on different properties of the Dylan language, as well as Apple Dylan’s cross-language calling mechanism.

The movie player application we’ll build mimics the QuickTime Movie Player application provided in the QuickTime developer’s kit.

QuickTime API

To use QuickTime, we’ll need to import QuickTime function and type definitions into Dylan. In fact, we’ll need to do the same for any Toolbox function or type we use in writing our application.

Dylan makes it easy to interface with C code - simply specify the .h file name and list the names of the functions and types you want to use. Dylan takes care of the rest. Here’s an example of how to import Toolbox function headers and types:


/* 1 */
define interface
  #include "Quickdraw.h",
     import:  {"Picture", "PicHandle",
               "DrawPicture", "KillPicture",
               "CGrafPort", "UnionRect", "GDHandle",
               "GWorldPtr"
              }
end interface;

We can call any of the C functions we import in the scope of our application as if they were written in Dylan.

Dylan Framework API

Dylan Framework provides useful class definitions for writing applications; it consists mainly of Dylan derivatives of Toolbox functionality. Among other things, it handles events, pick correlation (a fancy buzzword), view, and window operations. It originated with MacApp, but is cleaner and written entirely in Dylan.

The next thing is to get QuickTime and the Framework together. For that, we’ll define classes to deal with QuickTime movies. First, a bit about how classes work in Dylan.

Class Definitions

As in other object-oriented languages, each instance of a Dylan class stores information about its state in slots. A slot, equivalent to a data-member or field in other object-oriented languages, is a place to keep data, and each instance gets its own storage (i.e. set of slots). In addition to having its own slots, a class inherits all the slots of its superclasses.

Slots in Dylan are accessed by invoking methods using a simple syntax. For instance, to get the value stored in slot v of some object point, we write: point.v.

We’ll define a class called <movie-view>, which will provide a view onto the QuickTime movie. Note: it’s a convention in Dylan to surround class names by angle brackets.

Our class <movie-view> inherits from the Framework’s <view>. Among other things, it handles mouse events in the view. In other words, <movie-view> is a subclass of <view>, and we’ll add the data and methods we need to work with a QuickTime movie. We include slots particular to <movie-view> in the class definition; it inherits other slots from <view>.


/* 2 */
define class <movie-view> (<view>)
 slot movie :: <Movie>,
 init-value: as(<Movie>, 0),
 init-keyword: movie:;  
 slot show-mc?,
 init-value: #t,
 init-keyword: show-mc?:;
 slot enable-editing?,
 init-value: #t,
 init-keyword: enable-editing?:;
 slot is-playing?,
 init-value: #f;
 slot loop?,
 init-value: #f;
 slot mc :: <MovieController>,
 init-value: as(<MovieController>, 0);
end class;

From the class definition above, we see that the slot movie is of type <Movie>, imported from QuickTime through the define interface. Its initial value is a null pointer, or, more accurately, it is the integer 0 coerced into type <Movie> by the as operator. To specify which movie to associate with a particular <movie-view>, we’ll use the init-keyword at instantiation time. In this case, the init-keyword is movie:.

The next slot in <movie-view> is a boolean called show-mc?, whose value indicates whether to show QuickTime’s movie controller in the <movie-view>. Similarly, the boolean slot enable-editing? indicates whether the movie is read-only.

The next two slots can’t be initialized by use of a keyword by the creator of an instance of <movie-view>. That’s because we chose to not include an init-keyword in their slot definitions. Rather, their values are determined in the initialize routine of the instance of <movie-view>.

The slot is-playing? is used to keep track of when the movie is playing when the movie controller is not present to do that for us.

The slot mc is of the type <MovieController>, a type also imported from QuickTime. This is where we store a pointer to the movie controller object. The movie controller provides an interface to the movie, making it possible to play, stop and edit the movie.

With the QuickTime Movie Player, a movie is associated with a window that contains it, that window’s controls, and the file the movie is stored in. We need to define a class that will provide that window and the file. The Dylan Framework class <document> provides a mechanism for exactly that. We’ll define a subclass of <document> called <movie-document> in the following way:


/* 3 */
define class <movie-document> (<document>)
 slot movie :: <Movie>, 
 init-value: as(<Movie>, 0);
 slot movie-view :: <movie-view>;
end class;

In addition to inheriting all the slots of <document>, <movie-document> has a slot for storing an instance of <movie-view> and a slot for storing a pointer to the movie. The slot movie stores a copy of the pointer to the QuickTime movie already stored in <movie-view>. Having the slot movie present in <movie-document> is a matter of convenience and can be omitted if desired.

Now that we have defined our main classes, we can address how to define methods for these classes to provide the functionality want in this application.

Our app’s File and Edit menus will be standard. We’ll also have a Movie menu with items like Set Movie Poster, Show Movie Poster and Loop. We’ll focus our discussion on implementing the functionality of the items in the File menu, mainly Opening and Closing a movie. The code at the end of the article shows how we implemented the functionality of the rest of the menu items.

We aren’t going to show how to create and add menu items to a menu here. What we will discuss is the functionality needed for the menu callbacks, i.e. the functions that are called as a result of a menu item being selected.

Methods in Dylan

Dylan methods are grouped by name into collections called generic functions. Dylan supports polymorphism through generic functions and method dispatch. When you call a generic function, Dylan determines which method to invoke based on the type of arguments passed to it. This process is called method dispatch.

A method is said to be specialized when it is defined to operate on instances of a specific class. That is, a method is specialized on the type of its parameters. In addition to providing type information to the compiler, specializers make code easier for humans to understand. During method dispatch, a generic function compares all specializers with the arguments it receives to determine which method to invoke. The method whose parameters most closely match the argument types gets invoked.

You don’t need to modify class definitions to modify an object’s behavior. Method definitions in Dylan are separate from the classes they use for specialization. This makes for more flexible code organization. Given that you may not even be able to get to the code where a class is defined, the most effective approach then seems to be adding a method specialized on a specific class. For instance, Dylan lets you add a method on the class <integer> without changing the class itself or affecting other applications.

Next we’ll discuss some of the functions of our movie player app, and Dylan’s modularity will become more apparent. We’ll also show how simple it is to use pre-defined classes and augment them to get the behavior you want.

Opening a Movie File

When the user selects Open from the File menu and chooses a QuickTime movie, we’ll make an instance of <movie-document>, and store the file pointer in the main-file slot.

Since <movie-document> is a subclass of <document>, we can specialize the methods for <document> to incorporate our movie specific functionality.

The initialize method for <document> calls the method open-files, which opens a QuickTime movie file:


/* 4 */
define method open-files (document :: <movie-document>)
 open-movie-file(document.main-file);
end method;

define method open-movie-file (file :: <file>)
  with-stack-structure
 (spec(<FSSpec>),
   begin
        set-fs-spec(file, spec);
         let (err, ref-num) = 
            OpenMovieFile(spec, file.data-permission);
         fail-os-error(err);
         file.data-ref-num := ref-num;
       end);
   end method;

To get the movie data out of the file, we specialize read-from-file, a method of <document>, that is eventually called by initialize.


/* 5 */
define method read-from-file (document :: <movie-document>,
                              file :: <file>) 
  let (err, new-movie,resId) = 
       NewMovieFromFile( file.data-ref-num, "",  0);
  ignore(resId);
  fail-os-error(err);
  document.movie := new-movie;
  close-files(document); 
end method;

Next, in instantiating <document>, initialize calls the method make-windows to open the document in a window on screen.


/* 6 */
define method make-windows (document :: <movie-document>)
 let movie-bounds =
       with-stack-structure(box(<qd-rect>),
                            begin
                              GetMovieBox(document.movie,box);
                              get-rect(box);
                            end);
   let movie-size = point(movie-bounds.width, movie-bounds.height);
  
   document.movie-view := make(<movie-view>, 
                              location: $zero-point, 
                              size: movie-size);
  
   let window = make(<window>,
                        location: point(100, 100),
                        size: movie-size,
                        next-handler: document,
                        target-view: document.movie-view,
                        has-go-away: #t);
  
   add-sub-view(window.root-view, document.movie-view);
   open(window);
  
   set-movie-to-view(document.movie-view, document.movie);  
   make-document-title(document);
end method;

In make-windows we get the movie’s size by calling the QuickTime function GetMovieBox. The Dylan wrapper surrounding the function call itself sets up a temporary local instance of <qd-rect> (a Dylan derivative of a QuickDraw rectangle), fills it with the values returned by GetMovieBox, and removes it from the stack. Then we create an instance of <movie-view> of the same size, followed by an instance of <window> with the same dimensions, and we designate our instance of <movie-view> to be the target view of the window. Then we add our <movie-view> instance to the window’s list of subviews. After opening the window, we call the method set-movie-to-view.


/* 7 */
define method set-movie-to-view (view :: <movie-view>,
                                 new-movie :: <Movie>)
  unless (new-movie = view.movie)
    unless (nil?(view.movie))
      unless(nil?(view.mc))
        DisposeMovieController(view.mc);
      end unless;
      DisposeMovie(view.movie);   
    end unless;
    
    view.movie := new-movie;
    
    with-stack-structure
 (view-rect(<qd-rect>),
        begin
        set-rect(view-rect, view.local-bounds);
        let movie-window = get-window(view);
            let movie-port= as(<CGrafPort>, 
 movie-window.window-ptr);
            SetMovieGWorld(view.movie, movie-port,
                           as(<GDHandle>,0));
            SetMovieBox(view.movie, view-rect);
            if (view.show-mc?)
            view.mc := as(<MovieController>,
                             NewMovieController(view.movie,
 view-rect, $mcTopLeftMovie));
               unless (nil?(view.mc))
                 MCSetControllerBoundsRect(view.mc, view-rect);
                 MCSetControllerPort(view.mc, movie-port);
                 draw(view, view.local-bounds);
                 *controller-list* := add!(*controller-list*,
                                           view.mc);
                 if (view.enable-editing?)
                   MCEnableEditing(view.mc, #t);
                 end if;
               end unless;
            end if;
 end);
  end unless;
end method;

In set-movie-to-view, we use the QuickTime function SetMovieGWorld using the GWorld of the movie’s window (we instantiated it in make-windows). We also call SetMovieBox to let QuickTime know how big a window the movie needs to be displayed in.

The second half of the set-movie-to-view method instantiates a movie controller if the show-mc? slot of view (our instance of <movie-view>) is true. Then we call MCSetControllerBoundsRect with the size of our movie. We next set the GrafPort of the controller to match that of the movie and the window. The draw method draws the current frame (in this case, the first frame) of the movie and the controller on the screen. The variable *controller-list* is global and stores pointers to all movie controllers that are visible at a given time.

In Dylan, it is a convention to begin and end global variable names with asterisks.

In order to include controller events in our event loop, we need to keep a global list of controller pointers. Finally, if editing is enabled, we invoke the MCEnableEditing function.

Closing a Movie File

close-files is a generic function defined on <document>, which we specialize in the following way:


/* 8 */
define method close-files (document :: <movie-document>)
 close-movie-file(document.main-file);
end method;
 
define method close-movie-file (file :: <file>)
 unless (~(file.data-ref-num))
 CloseMovieFile(file.data-ref-num);
 file.data-ref-num := 0;
 end unless;
end method;

Playing a movie

There are two ways for the user to invoke movie playback. If the movie controller is visible, then it handles all the playback functionality. Otherwise, a double-click in the movie region on screen starts playback, a single click pauses it. This is one of the reasons why we subclassed <view> when we defined <movie-view>. <view> is equipped with methods to handle mouse events, which can easily be specialized to add the behavior we want (see the code listing for these).

Now we’ll discuss how to get the movie controller to take care of the playback functionality. We already mentioned that we keep a global list, *controller-list*, of all visible movie controllers that we update as each controller is created or disposed. A movie can have at most one controller, but we can have a number of movies open at once, so we can have more than a single item in *controller-list*.

Next, we create an event filter so a movie controller can be aware of user events. It will filter out events relevant to the movie controller and act upon them.


/* 9 */
define method controller-event-hook (event-rec :: <EventRecord>)
 block(exit)
 for (mc in *controller-list*)
 if (MCIsPlayerEvent(mc, event-rec) ~= 0)
 exit(#t);
 end if;
 end for;
 #f;
 end block;
end method;

The method defined here is called from the event loop each time an event occurs and before it is handled. What our event-hook does is call MCIsPlayer on each movie controller in the list. It informs the event handler that the event was handled if a controller responds with something other than 0. Otherwise the event record is passed back to the event loop to be handled somewhere else. MCIsPlayerEvent is a QuickTime function which examines the event record and handles the event if it determines that the event should be handled by the movie controller. MCIsPlayerEvent returns a 0 if it didn’t handle the event.

Summary

Dylan has a number of features which make it a great language and environment:

• straightforward syntax

• easy access to functions coded in other languages

• design modularity through specialization, inheritance, etc

• a good framework to build on

Although this look at building Dylan applications leaves a lot of territory unexplored, reading the following code may help build your understanding further. There’ll be much more to come in the months ahead.

The Dylan environment lends itself to interactive browsing of code, so it’s unusual to see Dylan code flattened like this, but we’ve got to do something to get it into the magazine.


/* 10 */
// Source container: toolbox-interface.dylan
// Interface to C files
// Files.h
define interface
  #include "Files.h",
      import: {"fsWrPerm"};
end interface;
// Quickdraw.h
define interface
  #include "Quickdraw.h",
      import:  { "CGrafPort",  "GDHandle"},
     
     type: {"CQDProcsPtr" => <machine-pointer>};
  
  end interface;
// Movies.h
define interface
  // import everything from Movies.h, and just a few necessary types from 
other files.
  #include "TextEdit.h",
     define: {"SystemSevenOrLater" => 1},
     import: {"ScrpSTElement"};
  
  #include "Components.h",
     define: {"SystemSevenOrLater" => 1},
     import: {"Component", "ComponentInstance"};
  
  #include "ImageCompression.h",
     import: {"MatrixRecord"};
  
  #include "Movies.h",
define: {"SystemSevenOrLater" => 1};
                                   
  function "PreflightMovie", output-argument: outFlags;
  function "GetMovieGWorld", output-argument: port, 
 output-argument: gdh;
  function "GetMoviePreviewTime", output-argument: previewTime,
 output-argument: previewDuration;
  function "GetMovieSelection", output-argument: selectionTime,
 output-argument: selectionDuration;
  function "GetMovieActiveSegment", output-argument: startTime, 
 output-argument: duration;
  function "GetTrackDimensions", output-argument: width, 
 output-argument: height;
  function "GetMediaHandlerDescription", output-argument: mediaType, 

 output-argument: creatorManufacturer;
  
  function "SampleNumToMediaTime", output-argument: sampleTime, 
 output-argument: sampleDuration;
  function "MediaTimeToSampleNum", output-argument: sampleNum, 
 output-argument: sampleTime,
     output-argument: sampleDuration;
  function "AddMediaSample", output-argument: sampleTime;
  function "AddMediaSampleReference", output-argument: sampleTime;
  function "GetMediaSample", output-argument: size, 
 output-argument: sampleTime, 
     output-argument: durationPerSample,
 output-argument: sampleDescriptionIndex, 
     output-argument: numberOfSamples, output-argument: sampleFlags;
  function "GetMediaSampleReference", 
     output-argument: dataOffset, output-argument: size, 
 output-argument: sampleTime, 
     output-argument: durationPerSample, 
 output-argument: sampleDescriptionIndex, 
     output-argument: numberOfSamples, output-argument: sampleFlags;
  function "GetMediaShadowSync", output-argument: syncSampleNum;
  function "ConvertFileToMovieFile", output-argument: resID;
  function "ConvertMovieToFile", output-argument: resID;
  function "GetTrackDimensions", output-argument: height;
  function "GetMediaHandlerDescription", output-argument: mediaType, 

 output-argument: creatorManufacturer;
  function "GetMediaDataHandlerDescription", 
 output-argument: dhType, output-argument: creatorManufacturer;
  function "SampleNumToMediaTime", output-argument: sampleTime, 
 output-argument: sampleDuration;
  function "MediaTimeToSampleNum", output-argument: *sampleNum, 
 output-argument: sampleTime, output-argument: sampleDuration;
  function "AddMediaSample", output-argument: sampleTime;
  function "AddMediaSampleReference", output-argument: sampleTime;
  function "GetMediaSample", output-argument: size, 
 output-argument: sampleTime, 
     output-argument: durationPerSample, 
 output-argument: sampleDescriptionIndex, 
 output-argument: numberOfSamples,
     output-argument: sampleFlags;
  function "GetMediaSampleReference", output-argument: dataOffset, 
 output-argument: size, 
     output-argument: sampleTime, 
 output-argument: durationPerSample, 
 output-argument: sampleDescriptionIndex,
     output-argument: numberOfSamples, output-argument: sampleFlags;
  function "GetMediaShadowSync", output-argument: syncSampleNum;
  function "ConvertFileToMovieFile", output-argument: resID;
  function "ConvertMovieToFile", output-argument: resID;
  function "GetMediaNextInterestingTime", 
 output-argument: interestingTime, 
 output-argument: interestingDuration;
  function "GetTrackNextInterestingTime", 
 output-argument: interestingTime, 
 output-argument: interestingDuration;
  function "GetMovieNextInterestingTime", 
 output-argument: whichMediaTypes, 
 output-argument: interestingTime,
     output-argument: interestingDuration;
  function "CreateMovieFile", output-argument: resRefNum, 
 output-argument: newmovie;
  function "OpenMovieFile", output-argument: resRefNum;
  function "NewMovieFromFile", output-argument: theMovie, 
 output-argument: resId, output-argument: dataRefWasChanged;
  function "NewMovieFromHandle", output-argument: theMovie, 
 output-argument: dataRefWasChanged;
  function "NewMovieFromDataFork", output-argument: theMovie, 
 output-argument: dataRefWasChanged;
  function "AddMovieResource", output-argument: resId;
  function "GetMovieDefaultDataRef", output-argument: dataRef, 
 output-argument: dataRefType;
  function "FlattenMovie", output-argument: resId;
  function "GetVideoMediaGraphicsMode", 
 output-argument: graphicsMode;
  function "GetSoundMediaBalance", output-argument: balance;
  function "AddTextSample", output-argument: sampleTime;
  function "AddTESample", output-argument: sampleTime;
  function "AddHiliteSample", output-argument: sampleTime;
  function "FindNextText", output-argument: foundTime, 
 output-argument: foundDuration, output-argument: offset;
  function "GetMovieCoverProcs", output-argument: uncoverProc, 
 output-argument: coverProc, output-argument: refcon;
  function "GetMovieStatus", output-argument: firstProblemTrack;
  function "GetMediaDataRef", output-argument: dataRef, 
 output-argument: dataRefType, 
 output-argument: dataRefAttributes;
  function "AddMediaDataRef", output-argument: index;
  function "GetMediaDataRefCount", output-argument: count;
  function "MCGetCurrentTime", output-argument: scale;
  function "MCGetControllerInfo", output-argument: someFlags;
  function "MCGetClip", output-argument: theClip, 
 output-argument: movieClip;
  function "MCDrawBadge", output-argument: badgeRgn;
end interface;
Events.h
define interface
  #include "Events.h",
     import: {"GetMouse",  "TickCount"};
end interface;

Menus.h


/* 11 */
define interface
  #include "Menus.h",
     import: {"MenuHandle"};
end interface;

// source container:  movie-utils.dylan
define variable *controller-list* = #();
define variable *edit-menu* = #();

// this is the event hook called from the event loop to filter out movie 
controller events
define constant controller-event-hook =
     method (event-rec :: <EventRecord>)
       block(exit)
         for (mc in *controller-list*)
           if(MCIsPlayerEvent(mc, event-rec) ~= 0)
             exit(#t);
           end if;
         end for;
         #f;
       end block; 
end method;

// this must be called to initialize QuickTime
define constant init-quicktime =
     method ()
       fail-os-error(EnterMovies());
       *controller-list* := #();
       *event-hooks* := add(*event-hooks*, controller-event-hook); 
     end method;

// recommended to call this upon exiting QuickTime
define constant exit-quicktime =
     method()
       ExitMovies();
     end method;

// opens a movie file
define method open-movie-file (file :: <file>)
  with-stack-structure(spec(<FSSpec>),
                  begin
                    set-fs-spec(file, spec);
                    let (err, ref-num) = 
                      OpenMovieFile(spec, file.data-permission);
                    fail-os-error(err);
                    file.data-ref-num := ref-num;
                  end);
   end method;

// closes a movie file
define method close-movie-file (file :: <file>)
  unless (~(file.data-ref-num))
    CloseMovieFile(file.data-ref-num);
    file.data-ref-num := 0;
  end unless;
end method;

// source container: movie-view.dylan
define class <movie-view> (<view>)
  slot movie :: <Movie>,
     init-value: as(<Movie>, 0),
     init-keyword: movie:;
  slot show-mc?,
     init-value: #t,
     init-keyword: show-mc?:;
  slot enable-editing?,
     init-value: #t,
     init-keyword: enable-editing?:;
  slot is-playing?,
     init-value: #f;
  slot loop?,
     init-value: #f;
  slot mc :: <MovieController>,
     init-value: as(<MovieController>, 0);
end class;

// called as each instance of <movie-view> is instantiated
define method initialize (view :: <movie-view>, #key)
  next-method();
  
  unless (nil?(view.movie))
    set-movie-to-view(view, view.movie);
  end unless;
  
end method;

// when a movie is closed, we need to clean up the relevant structures
define method dispose (view :: <movie-view>)
  
  stop-playing(view);
  
  unless (nil?(view.movie))
    unless(nil?(view.mc))
      *controller-list* := remove!(*controller-list*,view.mc);
      DisposeMovieController(as(<ComponentInstance>,view.mc));
      view.mc := as(<MovieController>, 0);
    end unless;
    DisposeMovie(view.movie);
    view.movie := as(<Movie>, 0);
  end unless;
  
  next-method();
end method;

// this informs the movie about the size of the window it will play inside
// of on screen and intializes the GWorld of the movie to be the current 
one
define method size-setter(view :: <movie-view>, new-size :: <point>)
  next-method();
  
  unless (nil?(view.movie))
    with-stack-structure(r(<qd-rect>),
               begin
                 focus(view);                                        
         // Set the movie to play in our view
                 set-rect(r, view.local-bounds);
                 SetMovieBox(view.movie, r);
                 SetMovieGWorld(view.movie,as(<CGrafPort>, 0),
                             as(<GDHandle>,0));
               end);
  end unless;
end method;

define method start-playing (view :: <movie-view>)
  unless (nil?(view.movie))
    if (view.is-playing?)
      stop-playing(view);
    end if;
    
    GoToBeginningOfMovie(view.movie);
    
    //  Start the movie playing
      StartMovie(view.movie);
    
    //  Mark that we are playing
      view.is-playing? := #t;
    end unless;
  end method;

define method stop-playing (view :: <movie-view>)
  unless (nil?(view.movie) | ~ view.is-playing?)
      StopMovie(view.movie);
      view.is-playing? := #f;
  end unless;
end method;

// this is called in response to an update event (the engine that calls 
it is 
// embedded within the Framework
define method draw (view :: <movie-view>,
                    draw-rect :: <rect>)
  ignore(draw-rect);
 
  unless (nil?(view.movie))
    SetMovieActive(view.movie, #t);  
    UpdateMovie(view.movie);
    MoviesTask(view.movie, $doTheRightThing);
  end unless;
  
  unless (~view.show-mc? | nil?(view.mc))
    MCDraw(view.mc, get-window(view).window-ptr); 
  end unless;

end method;

//sets up a view onto the movie in the window that is to contain the 
movie
define method set-movie-to-view (view :: <movie-view>,
                                 new-movie :: <Movie>)
  
  unless (new-movie = view.movie)
    unless (nil?(view.movie))
      unless(nil?(view.mc))
        DisposeMovieController(view.mc);
      end unless;
      DisposeMovie(view.movie);   
    end unless;
    
    view.movie := new-movie;
    
    with-stack-structure(view-rect(<qd-rect>),
         begin
           set-rect(view-rect, view.local-bounds);
              
           let movie-window = get-window(view);
           let movie-port = as(<CGrafPort>, 
                               movie-window.window-ptr);
                           
           SetMovieGWorld(view.movie, movie-port,
                          as(<GDHandle>,0));
           SetMovieBox(view.movie, view-rect);
                          
           if (view.show-mc?)
             view.mc := as(<MovieController>,
                   NewMovieController(view.movie, 
                                      view-rect,
                                      $mcTopLeftMovie));
             unless (nil?(view.mc))
               MCSetControllerBoundsRect(view.mc, view-rect);
               MCSetControllerPort(view.mc, movie-port);
               draw(view, view.local-bounds);
               *controller-list* := add!(*controller-list*,
                                         view.mc);
               if (view.enable-editing?)
                 MCEnableEditing(view.mc, #t);
               end if;
             end unless;
           end if;
         end);
  end unless;
end method;

// called while waiting for the events to occur (during idle time)
define method do-idle (view :: <movie-view>)
  
  if (view.mc & view.show-mc)
    // hack to have null events sent to the event loop during idle time
    //  next version of the Framework will take care of this 
    with-stack-structure(event-record(<EventRecord>),
              begin
                event-record.EventRecord$what := 0;
                GetMouse(event-record.EventRecord$where);
                event-record.EventRecord$when := TickCount();
                event-record.EventRecord$message := 0;
                event-record.EventRecord$modifiers := #x80;
                MCIsPlayerEvent(view.mc, event-record);
              end);
  else
    
    if (view.is-playing?)
      MoviesTask(view.movie, $doTheRightThing);
      if (IsMovieDone(view.movie))
        stop-playing(view);
      end if;
      
    end if;
  end if;
end method;

// The  following methods are menu callbacks that suport editing 
// functionality of the movie controller

define method do-event (view :: <movie-view>,
                 event :: <menu-event>,
                 id == #"clear")
  
  ignore(event, id);
  unless(nil?(view.mc))
    MCClear(view.mc);
  end unless;
end method;

define method do-event (view :: <movie-view>,
                 event :: <menu-event>,
                 id == #"undo")
  
  ignore(event, id);
  unless(nil?(view.mc))
    MCUndo(view.mc);
  end unless;
end method;

define method do-event (view :: <movie-view>,
                 event :: <menu-event>,
                 id == #"copy")
  
  ignore(event, id);
  unless(nil?(view.mc))
    let selection = MCCopy(view.mc);
    unless(nil?(selection))
      PutMovieOnScrap(selection, $movieScrapOnlyPutMovie);
      DisposeMovie(selection);
         end unless;
  end unless;
end method;


define method do-event (view :: <movie-view>,
                 event :: <menu-event>,
                 id == #"cut")
  
  ignore(event, id);
  unless(nil?(view.mc))
    let selection = MCCut(view.mc);
    unless(nil?(selection))
      PutMovieOnScrap(selection, $movieScrapOnlyPutMovie);
      DisposeMovie(selection);
    end unless;
  end unless;
end method;

define method do-event (view :: <movie-view>,
                 event :: <menu-event>,
                 id == #"paste")
  ignore(event, id);
  unless(nil?(view.mc) | ~IsScrapMovie(as(<Track>,0)))
    MCPaste(view.mc, as(<Movie>,0));
  end unless;
  end method;

// this method highlights the menus correctly
define method do-setup-menus (view :: <movie-view>)
  next-method();
  
  unless(nil?(view.mc) | ~view.enable-editing? 
 | ~view.show-mc | nil?(view.movie)) 
    enable-item(#"copy");
    MCSetUpEditMenu(view.mc, $doTheRightThing,        
                  as(<MenuHandle>,*edit-menu*.toolbox-menu));
  end unless;       
end method;

define method do-event (view :: <movie-view>, 
                        event :: <generic-mouse-down-event>, 
                        id :: <keyword>)
  // when controller not present: double-click to play, single-click 
to stop
  ignore(id);
  if (~view.show-mc | nil?(view.mc))
    if (double-click? (event))
      if (IsMovieDone(view.movie))
        GoToBeginningOfMovie(view.movie);
      end if;
      start-playing(view);
    else
      stop-playing(view);
      next-method();
    end if;
  else
    next-method();
  end if;
end method; 

// source container: movie-document.dylan
define class <movie-document> (<document>)
  slot movie :: <Movie>, 
 init-value: as(<Movie>, 0);
  slot movie-view :: <movie-view>;
end class;

define method main-file-type (document :: <movie-document>)
  ignore(document);
  $MovieFileType;
end method;

//opens up a window containing a view onto the movie
define method make-windows (document :: <movie-document>)
  let movie-bounds =
       with-stack-structure(box(<qd-rect>),
                          begin
                            GetMovieBox(document.movie, box);
                            get-rect(box);
                          end);
  let movie-size = point(movie-bounds.width, 
                         movie-bounds.height);
  
  document.movie-view := make(<movie-view>, 
                              location: $zero-point, 
                              size: movie-size);
  let window = make(<window>,
                    location: point(100, 100),
                    size: movie-size,
                    next-handler: document,
                    target-view: document.movie-view,
                    has-go-away: #t);
  
  add-sub-view(window.root-view, document.movie-view);
  open(window);
  set-movie-to-view(document.movie-view, document.movie);  
  make-document-title(document);
end method;

define method open-files (document :: <movie-document>)
  open-movie-file(document.main-file);
end method;

define method close-files (document :: <movie-document>)
  close-movie-file(document.main-file);
end method;

// gets the movie data in correctly from a file
define method read-from-file (document :: <movie-document>,
                              file :: <file>) 
  let (err, new-movie,resId) 
 = NewMovieFromFile( file.data-ref-num, "",  0);
  ignore(resId);
  fail-os-error(err);
  document.movie := new-movie;
  close-files(document); 
  
end method;

// highlights the menu items in the Movie menu
define method do-setup-menus (document :: <movie-document>)
  next-method();

  enable-item(#"show-poster");
  enable-item(#"set-poster");
end method;

// menu callback for Show Poster menu item - goes to the poster frame
define method do-event (document :: <movie-document>,
                        event :: <menu-event>,
                        id == #"show-poster")
  ignore(event, id);
  
  unless (nil?(document.movie))  
    let movie = document.movie;
    let poster-time = GetMoviePosterTime(movie);
    let movie-time = GetMovieTime(movie, as(<TimeRecord>, 0));
    
    unless (poster-time = movie-time)
      StopMovie(movie);
      SetMovieTimeValue(movie, poster-time);
    end unless;
    
  end unless;
end method;

// menu callback for Set Poster menu item - sets movie poster to be the 
current frame
define method do-event (document :: <movie-document>,
                        event :: <menu-event>,
                        id == #"set-poster")
  ignore(event, id);
  
  unless (nil?(document.movie))  
    let movie = document.movie;
    let new-poster-time = GetMovieTime(movie, as(<TimeRecord>, 0));
    
    SetMoviePosterTime(movie, new-poster-time);
  end unless;
  
end method;

// Source container: movie-player.dylan
define class <movie-player-behavior> (<behavior>)
end class;

define method behavior-setup-menus (behavior :: <movie-player-behavior>, 

                              next :: <list>,
                              main-handler :: <main-handler>)
  ignore(behavior, next, main-handler);
  next-method();
end method;

// callback for Quit menu item
define method behavior-event (behavior :: <movie-player-behavior>, 
                              next :: <list>, 
                              main-handler :: <main-handler>,
                              event :: <menu-event>, 
                              id == #"quit")
  ignore(behavior, next, main-handler, event, id);
  exit-quicktime();
  next-method();
end method;    

define method init-movie ()

// initializes the Framework and QuickTime
  init-framework();
  init-quicktime();
  
 // Set up the menus.
  make(<menu>,
       title: "File",
       install: #t,
       items: list(make(<menu-item>,
                        title: "New",
                        identifier: #"new",
                        command-key: 'N'),
                   make(<menu-item>,
                        title: "Open ",
                        identifier: #"open",
                        command-key: 'O'),
                   make(<separator-item>),
                   make(<menu-item>,
                        title: "Save",
                        identifier: #"save",
                        command-key: 'S'),
                   make(<menu-item>,
                        title: "Save As ",
                        identifier: #"save-as"),
                   make(<separator-item>),
                   make(<menu-item>,
                        title: "Close",
                        identifier: #"close",
                        command-key: 'W'),
                   make(<separator-item>),
                   make(<menu-item>,
                        title: "Quit",
                        identifier: #"quit",
                        command-key: 'Q')));
  *edit-menu* := make-edit-menu(install: #t);

  make(<menu>,
       title: "Movie",
       install: #t,
       items: list( 
                   make(<menu-item>,
                        title: "Go To Poster Frame",
                        identifier: #"show-poster"),
                   make(<menu-item>,
                        title: "Set Poster Frame",
                        identifier: #"set-poster")
                        ));

  add-behavior(*main-handler*, make(<movie-player-behavior>));
  add-document-type(*main-handler*, $MovieFileType, <movie-document>);
  
  #t;
end method;

// this method is called to actually run the application 
define method run-movie ()
  init-movie();
  run();
end method;







  
 

Community Search:
MacTech Search:

Software Updates via MacUpdate

SpamSieve 2.9.38 - Robust spam filter fo...
SpamSieve is a robust spam filter for major email clients that uses powerful Bayesian spam filtering. SpamSieve understands what your spam looks like in order to block it all, but also learns what... Read more
TeamViewer 15.0.8397 - Establish remote...
TeamViewer gives you remote control of any computer or Mac over the Internet within seconds or can be used for online meetings. Find out why more than 200 million users trust TeamViewer! Free for non... Read more
SteerMouse 5.4.3 - Powerful third-party...
SteerMouse is an advanced driver for USB and Bluetooth mice. SteerMouse can assign various functions to buttons that Apple's software does not allow, including double-clicks, modifier clicks,... Read more
Toast Titanium 18.2.1 - The ultimate med...
Roxio Toast Titanium, the leading DVD burner for Mac, makes burning even better, adding Roxio Secure Burn to protect your files on disc and USB in Mac- or Windows-compatible formats. Get more style... Read more
HoudahSpot 5.0.11 - Advanced file-search...
HoudahSpot is a versatile desktop search tool. Use HoudahSpot to locate hard-to-find files and keep frequently used files within reach. HoudahSpot will immediately feel familiar. It works just the... Read more
ClipGrab 3.8.6 - Download videos from Yo...
ClipGrab is a free downloader and converter for YouTube, Vimeo, Facebook and many other online video sites. It converts downloaded videos to MPEG4, MP3 or other formats in just one easy step Version... Read more
ExpanDrive 7.4.0 - Access cloud storage...
ExpanDrive builds cloud storage in every application, acts just like a USB drive plugged into your Mac. With ExpanDrive, you can securely access any remote file server directly from the Finder or... Read more
Adobe Dreamweaver CC 2020 20.0 - Build w...
Dreamweaver CC 2020 is available as part of Adobe Creative Cloud for as little as $20.99/month (or $9.99/month if you're a previous Dreamweaver customer). Adobe Dreamweaver CC 2020 allows you to... Read more
Eye Candy 7.2.3.85 - 30 professional Pho...
Eye Candy renders realistic effects that are difficult or impossible to achieve in Photoshop alone, such as Fire, Chrome, and the new Lightning. Effects like Animal Fur, Smoke, and Reptile Skin are... Read more
Sparkle Pro 2.8.5 - Visual website creat...
Sparkle Pro will change your mind if you thought building websites wasn't for you. Sparkle is the intuitive site builder that lets you create sites for your online portfolio, team or band pages, or... Read more

Latest Forum Discussions

See All

Pre-register for Hello Kitty AR: Kawaii...
Hello Kitty — the cute cat that launched a multi-billion-pound franchise — has been brought to life… sort of. Sanrio has teamed up with the Bublar Group to create a new mobile game that uses AR tech to turn the real world into Hello Kitty’s... | Read more »
Gorgeous and tranquil puzzler Spring Fal...
One-man indie studio SPARSE//GameDev has now launched its tranquil puzzler, Spring Falls. It's described as "a peaceful puzzle game about water, erosion, and watching things grow". [Read more] | Read more »
Black Desert Mobile gets an official rel...
Pearl Abyss has just announced that its highly-anticipated MMO, Black Desert Mobile, will launch globally for iOS and Android on December 11th. [Read more] | Read more »
Another Eden receives new a episode, cha...
Another Eden, WFS' popular RPG, has received another update that brings new story content to the game alongside a few new heroes to discover. [Read more] | Read more »
Overdox guide - Tips and tricks for begi...
Overdox is a clever battle royale that changes things up by adding MOBA mechanics and melee combat to the mix. This new hybrid game can be quite a bit to take in at first, so we’ve put together a list of tips to help you get a leg up on the... | Read more »
Roterra Extreme - Great Escape is a pers...
Roterra Extreme – Great Escape has been described by developers Dig-It Games as a mini-sequel to their acclaimed title Roterra: Flip the Fairytale. It continues that game's tradition of messing with which way is up, tasking you with solving... | Read more »
Hearthstone: Battlegrounds open beta lau...
Remember earlier this year when auto battlers were the latest hotness? We had Auto Chess, DOTA Underlords, Chess Rush, and more all gunning for our attention. They all had their own reasons to play, but, at least from where I'm standing, most... | Read more »
The House of Da Vinci 2 gets a new gamep...
The House of Da Vinci launched all the way back in 2017. Now, developer Blue Brain Games is gearing up to deliver a second dose of The Room-inspired puzzling. Some fresh details have now emerged, alongside the game's first official trailer. [Read... | Read more »
Shoot 'em up action awaits in Battl...
BattleBrew Productions has just introduced another entry into its award winning, barrelpunk inspired, BattleSky Brigade series. Whilst its previous title BattleSky Brigade TapTap provided fans with idle town building gameplay, this time the... | Read more »
Arcade classic R-Type Dimensions EX blas...
If you're a long time fan of shmups and have been looking for something to play lately, Tozai Games may have just released an ideal game for you on iOS. R-Type Dimensions EX brings the first R-Type and its sequel to iOS devices. [Read more] | Read more »

Price Scanner via MacPrices.net

13″ 2.4GHz MacBook Pros available for up to $...
Apple has a full line of Certified Refurbished 2019 13″ 2.4GHz 4-Core Touch Bar MacBook Pros available starting at $1529 and up to $300 off MSRP. Apple’s one-year warranty is included, shipping is... Read more
New at T-Mobile: Switch to T-Mobile, and get...
T-Mobile is offering a free 64GB iPhone 8 for new customers who switch to T-Mobile and open a new line of service. Eligible trade-in required, and discount applied over a 24 month period. The fine... Read more
Xfinity Mobile’s Black Friday Apple savings:...
Take $250 off the purchase of any iPhone at Xfinity Mobile with a new line activation, and transfer of phone number to Xfinity Mobile, through December 8, 2019. This includes Apple’s new iPhone 11... Read more
2019 13″ 1.4GHz MacBook Pros available starti...
Apple has a full line of Certified Refurbished 2019 13″ 1.4GHz 4-Core Touch Bar MacBook Pros available starting at $1099 and up to $230 off MSRP. Apple’s one-year warranty is included, shipping is... Read more
Save up to $350 on a 21″ or 27″ iMac with the...
Apple has Certified Refurbished 2019 21″ & 27″ iMacs available starting at $929 and up to $350 off the cost of new models. Apple’s one-year warranty is standard, shipping is free, and each iMac... Read more
Early Holiday 2019 Sale: B&H again offers...
B&H Photo has 10.2″ iPads on sale again for $30 off Apple’s MSRP, starting at $299, as part of their early Holiday 2019 sale. Overnight shipping is free to many addresses in the US: – 10.2″ 32GB... Read more
Apple iMacs on sale today at B&H Photo fo...
B&H Photo has new 2019 21″ and 27″ 5K iMacs on stock today and on sale for up to $150 off Apple’s MSRP. Overnight shipping is free to many locations in the US. These are the same iMacs sold by... Read more
2018 4 and 6-Core Mac minis on sale today for...
Apple resellers are offering new 2018 4-Core and 6-Core Mac minis for $80-$100 off MSRP for a limited time. B&H Photo has the new 2018 4-Core and 6-Core Mac minis on sale for up to $100 off Apple... Read more
Early Holiday 2019 sale at B&H Photo: 12....
B&H Photo has new 12.9″ iPad Pros on sale for up to $120 off Apple’s MSRP as part of their early Holiday 2019 sale. Overnight shipping is free to many addresses in the US: – 12.9″ 64GB WiFi iPad... Read more
8-Core iMac Pro on sale today for $4499 at B...
B&H Photo has the base 8-Core 3.2GHz 32GB/1TB iMac Pro on sale today for $4499 — $500 off Apple’s MSRP. Shipping is free. Their price is the lowest available for a new iMac Pro from any Apple... Read more

Jobs Board

*Apple* Health Benefit Specialist - Call Cen...
Description ** Apple Health Benefit Specialist - Call Center (MAS 3/MACSC)** **Olympia, WA Multiple Positions** *The ideal candidate for this position will have Read more
Hair Stylist - *Apple* Blossom Mall - JCPen...
Hair Stylist - Apple Blossom Mall Location:Winchester, VA, United States- Apple Blossom Mall 1850 Apple Blossom Dr Job ID:1065040Salon Professionals Job Read more
*Apple* Mobility Pro - Best Buy (United Stat...
**747088BR** **Job Title:** Apple Mobility Pro **Job Category:** Store Associates **Store NUmber or Department:** 000297-Reston-Store **Job Description:** At Best Read more
Nurse Practitioner - Field Based (San Bernard...
Nurse Practitioner - Field Based (San Bernardino, CA, Apple Valley, Hesperia) **Location:** **United States** **Requisition #:** PS30312 **Post Date:** Nov 11, 2019 Read more
Best Buy *Apple* Computing Master - Best Bu...
**747061BR** **Job Title:** Best Buy Apple Computing Master **Job Category:** Store Associates **Store NUmber or Department:** 000647-Kildeer-Store **Job Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.