MovieClip_ [Ming wrapper class]

#ifndef MOVIE_CLIP_ABSTRACT_H
#define MOVIE_CLIP_ABSTRACT_H

#include <string>

#include "ming.h"
#include "Shape.h"
#include "Button.h"
#include "Action.h"
#include "DisplayItem.h"
#include "DisplayClip.h"
#include "Morph.h"
#include "TextField.h"

/*  A Movie and a MovieClip share some common functionality. 
    Why not put these in an abstract base class?   	 */

class MovieClip_ {
  friend class Movie;
  friend class MovieClip;

	public:

    virtual void        Add (Action const&) = 0;

    virtual DisplayItem Add (Character_ &) = 0;
            DisplayItem Add (Character_ &, unsigned int z);

    virtual DisplayClip Add (MovieClip  &) = 0;
            DisplayClip Add (MovieClip  &, unsigned int z);

    /* Mask is very similar to Add, except that it adds a mask */
            DisplayItem Mask(Character_ &, unsigned int level);
            DisplayClip Mask(MovieClip  &, unsigned int level);

    /* Insert stop(); action... */
    virtual void Stop     ()                    = 0;
    virtual void NextFrame() const              = 0;
    virtual void Remove   (DisplayItem item)    = 0;
    virtual void Frames   (int)                 = 0;
    virtual void Label    (std::string const&)  = 0;

    /*  TODO
    virtual void StartSound()                 = 0;
    virtual void StopSound ()                 = 0;
    */

};

#endif

#include "MovieClip_.h"

DisplayItem MovieClip_::Mask(Character_ & c, unsigned int z) {
  DisplayItem d = Add(c);
  d.MaskLevel(z);
  return d;
}

DisplayClip MovieClip_::Mask(MovieClip & mc, unsigned int z) {
  DisplayClip dc = Add(mc);
  dc.MaskLevel(z);
  return dc;
}

//void MovieClip_::Add(Action const& a) {
//  SWFMovie_add(movie_, a.swf_block());
//}

DisplayItem MovieClip_::Add(Character_ & c, unsigned int z) {
  DisplayItem d = Add(c);
  d.Z(z);
  return DisplayItem(d);
}

DisplayClip MovieClip_::Add(MovieClip  & mc, unsigned int z) {
  DisplayClip dc = Add(mc);
  dc.Z(z);
  return DisplayClip(dc);
}