public void Populate(IPhoto [] photos)
    {
        Dictionary<uint, Tag> dict = new Dictionary<uint, Tag> ();
        if (photos != null) {
            foreach (IPhoto p in photos) {
                foreach (Tag t in p.Tags) {
                    if (!dict.ContainsKey (t.Id)) {
                        dict.Add (t.Id, t);
                    }
                }
            }
        }

        foreach (Widget w in this.Children) {
            w.Destroy ();
        }

        if (dict.Count == 0) {
            /* Fixme this should really set parent menu
               items insensitve */
            MenuItem item = new MenuItem (Mono.Unix.Catalog.GetString ("(No Tags)"));
            this.Append (item);
            item.Sensitive = false;
            item.ShowAll ();
            return;
        }

        foreach (Tag t in dict.Values) {
            MenuItem item = new TagMenu.TagMenuItem (t);
            this.Append (item);
            item.ShowAll ();
            item.Activated += HandleActivate;
        }
    }

		public void CopyIfNeeded (IPhoto item, SafeUri destinationBase)
		{
			// remember source uri for copying xmp file
			SafeUri defaultVersionUri = item.DefaultVersion.Uri;

			foreach (IPhotoVersion version in item.Versions) {
				// Copy into photo folder and update IPhotoVersion uri
				var source = version.Uri;
				var destination = destinationBase.Append (source.GetFilename ());
				if (!source.Equals (destination)) {
					destination = GetUniqueFilename (destination);
					file_system.File.Copy (source, destination, false);
					copied_files.Add (destination);
					original_files.Add (source);
					version.Uri = destination;
				}
			}

			// Copy XMP sidecar
			var xmp_original = defaultVersionUri.ReplaceExtension(".xmp");
			if (file_system.File.Exists (xmp_original)) {
				var xmp_destination = item.DefaultVersion.Uri.ReplaceExtension (".xmp");
				file_system.File.Copy (xmp_original, xmp_destination, true);
				copied_files.Add (xmp_destination);
				original_files.Add (xmp_original);
			}
		}

 public static Gdk.Pixbuf LoadAtMaxSize(IPhoto item, int width, int height)
 {
     using (var img = ImageFile.Create (item.DefaultVersion.Uri)) {
         Gdk.Pixbuf pixbuf = img.Load (width, height);
         return pixbuf;
     }
 }

    public PhotoVersionMenu(IPhoto photo)
    {
        Version = photo.DefaultVersion;

        version_mapping = new Dictionary<MenuItem, IPhotoVersion> ();

        foreach (IPhotoVersion version in photo.Versions) {
            MenuItem menu_item = new MenuItem (version.Name);
            menu_item.Show ();
            menu_item.Sensitive = true;
            Gtk.Label child = ((Gtk.Label) menu_item.Child);

            if (version == photo.DefaultVersion) {
                child.UseMarkup = true;
                child.Markup = String.Format ("<b>{0}</b>", version.Name);
            }

            version_mapping.Add (menu_item, version);

            Append (menu_item);
        }

        if (version_mapping.Count == 1) {
            MenuItem no_edits_menu_item = new MenuItem (Mono.Unix.Catalog.GetString ("(No Edits)"));
            no_edits_menu_item.Show ();
            no_edits_menu_item.Sensitive = false;
            Append (no_edits_menu_item);
        }
    }

 public BrowsablePointerChangedEventArgs(IPhoto previous_item, int previous_index, IBrowsableItemChanges changes)
     : base()
 {
     PreviousItem = previous_item;
     PreviousIndex = previous_index;
     Changes = changes;
 }

 public ProductsController(INews news, IModule module, IPhoto photo, ICacheManager cache)
 {
     _news = news;
     _module = module;
     _cache = cache;
     _photo = photo;
 }

        public void Save(IPhoto tempImageStorage, IImageFormatSpec mediaFormat, out bool success)
        {
            success = false;
            Checks.Argument.IsNotNull(tempImageStorage, "tempImageStorage");
            Checks.Argument.IsNotNull(mediaFormat, "mediaFormat");
            Checks.Argument.IsNotNull(_tempImageStorageRepository, "_tempImageStorageRepository");


            //ValidateTempImageStorage(tempImageStorage, out validationState);

            //if (!validationState.IsValid)
            //{
            //    return;
            //}

            if (null == this.GetImage(tempImageStorage.PhotoId))
            {
                try
                {

                    _tempImageStorageRepository.Add(tempImageStorage);
                    success = true;
                }
                catch (Exception ex)
                {
                    success = false;
                    //var valState = new ValidationState();
                    //valState.Errors.Add(new ValidationError("Id.AlreadyExists", tempImageStorage, ex.Message));
                    //validationState.Append(typeof(ITempImageStorage), valState);
                }
            }

        }

 public PrintOperation(IPhoto [] selected_photos)
 {
     this.selected_photos = selected_photos;
     CustomTabLabel = Catalog.GetString ("Image Settings");
     NPages = selected_photos.Length;
     DefaultPageSetup = Global.PageSetup;
 }

    public bool Execute(IPhoto [] photos)
    {
        ProgressDialog progress_dialog = null;
        var loader = ThumbnailLoader.Default;
        if (photos.Length > 1) {
            progress_dialog = new ProgressDialog (Mono.Unix.Catalog.GetString ("Updating Thumbnails"),
                                  ProgressDialog.CancelButtonType.Stop,
                                  photos.Length, parent_window);
        }

        int count = 0;
        foreach (IPhoto photo in photos) {
            if (progress_dialog != null
                && progress_dialog.Update (String.Format (Mono.Unix.Catalog.GetString ("Updating picture \"{0}\""), photo.Name)))
                break;

            foreach (IPhotoVersion version in photo.Versions) {
                loader.Request (version.Uri, ThumbnailSize.Large, 10);
            }

            count++;
        }

        if (progress_dialog != null)
            progress_dialog.Destroy ();

        return true;
    }

 public static Gdk.Pixbuf Load(IPhoto item)
 {
     using (var img = ImageFile.Create (item.DefaultVersion.Uri)) {
         Gdk.Pixbuf pixbuf = img.Load ();
         return pixbuf;
     }
 }

        public override void Render(Drawable window,
                                     Widget widget,
                                     Rectangle cell_area,
                                     Rectangle expose_area,
                                     StateType cell_state,
                                     IPhoto photo)
        {
            string text = GetRenderText (photo);

            var layout = new Pango.Layout (widget.PangoContext);
            layout.SetText (text);

            Rectangle layout_bounds;
            layout.GetPixelSize (out layout_bounds.Width, out layout_bounds.Height);

            layout_bounds.Y = cell_area.Y;
            layout_bounds.X = cell_area.X + (cell_area.Width - layout_bounds.Width) / 2;

            if (layout_bounds.IntersectsWith (expose_area)) {
                Style.PaintLayout (widget.Style, window, cell_state,
                                   true, expose_area, widget, "IconView",
                                   layout_bounds.X, layout_bounds.Y,
                                   layout);
            }
        }

 public Photo(IPhoto photo)
 {
     PhotoId = photo.PhotoId;
     PhotoName = photo.PhotoName;
     PhotoType = photo.PhotoType;
     PhotoPath = photo.PhotoPath;
     GalleryId = photo.GalleryId;
 }

        public void InvalidateThumbnail (IPhoto photo)
        {
            PhotoGridViewChild child = GetDrawingChild (photo);

            if (child != null) {
                child.InvalidateThumbnail ();
                View.QueueDraw ();
            }
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="ViewPhotoForm"/> class.
 /// </summary>
 /// <param name="currentAlbum">The album whose photos the user is viewing.</param>
 /// <param name="photoToDisplay">the specific photo to view.</param>
 /// <remarks>
 /// Author(s): Miguel Gonzales and Andrea Tan
 /// </remarks>
 public ViewPhotoForm(IAlbum currentAlbum, IPhoto photoToDisplay)
 {
     this.InitializeComponent();
     this.album = currentAlbum;
     this.Text = this.album.AlbumId + " - Photo Buddy";
     this.allPhotosInAlbum = new List<IPhoto>(this.album.Photos);
     this.photoIndex = this.allPhotosInAlbum.IndexOf(photoToDisplay);
     this.DisplayPhoto(this.photoIndex);
 }

        protected PhotoGridViewChild GetDrawingChild (IPhoto photo)
        {
            foreach (PhotoGridViewChild child in Children) {
                if (child != null && child.BoundPhoto == photo) {
                    return child;
                }
            }

            return null;
        }

 public PhotoVersion(IPhoto photo, uint version_id, SafeUri base_uri, string filename, string md5_sum, string name, bool is_protected)
 {
     Photo = photo;
     VersionId = version_id;
     BaseUri = base_uri;
     Filename = filename;
     ImportMD5 = md5_sum;
     Name = name;
     IsProtected = is_protected;
 }

 public void SaveCommit(IPhoto photo, out bool success)
 {
     using (var unitOfWork = UnitOfWork.Begin())
     {
         Save(photo, out success);
         if (success)
         {
             unitOfWork.Commit();
         }
     }
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="UploadViewForm"/> class.
        /// </summary>
        /// <param name="photo">The photo to display.</param>
        /// <remarks>
        ///   <para>Author: Jim Counts and Eric Wei</para>
        ///   <para>Created: 2011-10-25</para>
        ///   <para>Modified: 2011-10-25</para>
        ///   <para>
        /// Creates an instance of the UploadViewForm that is configured to rename a photo.
        ///   </para>
        /// </remarks>
        public UploadViewForm(IPhoto photo)
        {
            this.InitializeComponent();

            Album = photo.Album;

            this.Text = Format.Culture("{0} {1} - Photo Buddy", "Rename", photo.DisplayName);
            this.UploadViewBox.Image = photo.Image;
            this.displayNameTextBox.Text = photo.DisplayName;
            this.messageLabel.Text = "This is the photo you have selected to rename.";
        }

        public static int Compare(this IPhoto photo1, IPhoto photo2)
        {
            int result = photo1.CompareDate (photo2);

            if (result == 0)
                result = CompareDefaultVersionUri (photo1, photo2);

            if (result == 0)
                result = photo1.CompareName (photo2);

            return result;
        }

        public static MipMapFile LoadMipMap (IPhoto photo)
        {
            var mipmap_uri = MipMapUri (photo);

            try {
                return new MipMapFile (mipmap_uri);
            } catch {}

            GenerateMipMap (photo);

            return new MipMapFile (mipmap_uri);
        }