private bool AddDirectoryEx(DvMediaContainer container, DirectoryInfo directory)
        {
            if (directory.Exists == false) return false;

            MediaBuilder.storageFolder storageInfo = new MediaBuilder.storageFolder(directory.Name);
            storageInfo.Searchable = true;
            storageInfo.IsRestricted = false;
            DvMediaContainer newContainer = DvMediaBuilder.CreateContainer(storageInfo);
            newContainer.OnChildrenRemoved += new DvDelegates.Delegate_OnChildrenRemove(this.Sink_OnChildRemoved);
            newContainer.Callback_UpdateMetadata = new DvMediaContainer.Delegate_UpdateMetadata(this.Sink_UpdateContainerMetadata);

            InnerMediaDirectory mediadir = new InnerMediaDirectory();
            mediadir.directory = directory;
            mediadir.directoryname = directory.FullName;
            mediadir.watcher = new FileSystemWatcher(directory.FullName);
            mediadir.watcher.Changed += new FileSystemEventHandler(OnDirectoryChangedSink);
            mediadir.watcher.Created += new FileSystemEventHandler(OnDirectoryCreatedSink);
            mediadir.watcher.Deleted += new FileSystemEventHandler(OnDirectoryDeletedSink);
            mediadir.watcher.Renamed += new RenamedEventHandler(OnFileSystemRenameSink);
            mediadir.restricted = true;
            mediadir.readOnly = true;

            watcherTable.Add(mediadir.watcher,newContainer);
            mediadir.watcher.EnableRaisingEvents = true;

            newContainer.Tag = mediadir;

            FileInfo[] files = directory.GetFiles();
            ArrayList addedFiles = new ArrayList(files.Length);
            foreach (FileInfo file in files)
            {
                IDvMedia newObj = CreateObjFromFile(file, new ArrayList());
                if (newObj != null)
                {
                    addedFiles.Add(newObj);
                    totalFileCount++;
                }
            }

            newContainer.AddObjects(addedFiles, true);

            // Add the new container to an existing container.
            container.AddObject(newContainer, true);

            foreach (IDvMedia item in addedFiles)
            {
                if (item.Class.IsA(MediaBuilder.StandardMediaClasses.AudioItem))
                {
                    this.m_AudioItems.AddReference((DvMediaItem)item);
                }
                else if (item.Class.IsA(MediaBuilder.StandardMediaClasses.ImageItem))
                {
                    this.m_ImageItems.AddReference((DvMediaItem)item);
                }
                else if (item.Class.IsA(MediaBuilder.StandardMediaClasses.VideoItem))
                {
                    this.m_VideoItems.AddReference((DvMediaItem)item);
                }
                else if (item.Class.IsA(MediaBuilder.StandardMediaClasses.PlaylistContainer))
                {
                    // References to playlists are not allowed, so we have to build
                    // completely new instances of the container and its resources.
                    // However the new container can have references to the items.
                    DvMediaContainer originalC = (DvMediaContainer) item;

                    MediaBuilder.playlistContainer plcInfo = new MediaBuilder.playlistContainer(originalC.Title);
                    DvMediaContainer newC = DvMediaBuilder.CreateContainer(plcInfo);

                    foreach (DvMediaResource res in originalC.Resources)
                    {
                        ResourceBuilder.AllResourceAttributes resAttribs = new ResourceBuilder.AllResourceAttributes();
                        resAttribs.contentUri = res.ContentUri;
                        foreach (string attribute in res.ValidAttributes)
                        {
                            object obj = res[attribute];
                            _RESATTRIB attribName = (_RESATTRIB) Enum.Parse(typeof(_RESATTRIB), attribute, true);

                            switch (attribName)
                            {
                                case _RESATTRIB.bitrate:
                                    resAttribs.bitrate = (_UInt) obj;
                                    break;
                                case _RESATTRIB.bitsPerSample:
                                    resAttribs.bitsPerSample = (_UInt) obj;
                                    break;
                                case _RESATTRIB.colorDepth:
                                    resAttribs.colorDepth = (_UInt) obj;
                                    break;
                                case _RESATTRIB.duration:
                                    resAttribs.duration = (_TimeSpan) obj;
                                    break;
                                case _RESATTRIB.importUri:
                                    //do not allow import
                                    break;
                                case _RESATTRIB.nrAudioChannels:
                                    resAttribs.nrAudioChannels = (_UInt) obj;
                                    break;
                                case _RESATTRIB.protection:
                                    resAttribs.protection = (string) obj;
                                    break;
                                case _RESATTRIB.protocolInfo:
                                    resAttribs.protocolInfo = new ProtocolInfoString(((ProtocolInfoString)obj).ToString());
                                    break;
                                case _RESATTRIB.resolution:
                                    resAttribs.resolution = (ImageDimensions) obj;
                                    break;
                                case _RESATTRIB.sampleFrequency:
                                    resAttribs.sampleFrequency = (_UInt) obj;
                                    break;
                                case _RESATTRIB.size:
                                    resAttribs.size = (_ULong) obj;
                                    break;
                            }
                        }
                        DvMediaResource newCR = DvResourceBuilder.CreateResource(resAttribs, false);
                        newCR.AllowImport = res.AllowImport;
                        newCR.CheckAutomapFileExists = res.CheckAutomapFileExists;
                        newCR.HideContentUri = res.HideContentUri;
                        newCR.MakeStreamAtHttpGetTime = res.MakeStreamAtHttpGetTime;
                        newCR.Tag = res.Tag;

                        newC.AddResource(newCR);
                    }

                    // The child container should only have items.
                    // If the child-container has child containers, then
                    // then this is bad because those child playlists
                    // should have been converted to a flat list
                    // in the recursive building of the hierarchy
                    foreach (DvMediaItem childItem in originalC.CompleteList)
                    {
                        newC.AddReference(childItem);
                    }

                    this.m_Playlists.AddObject(newC, true);
                }
            }

            DirectoryInfo[] directories = directory.GetDirectories();
            foreach (DirectoryInfo dir in directories)
            {
                AddDirectoryEx(newContainer,dir);
            }

            totalDirectoryCount++;
            if (OnStatsChanged != null) OnStatsChanged(this);
            return true;
        }
        private void ModifyLocalFileSystem(DvMediaContainer branchFrom, IDvMedia branch)
        {
            DvMediaContainer parent = (DvMediaContainer) branchFrom;

            IList resources = branch.Resources;

            if (branch.IsContainer)
            {
                DvMediaContainer container = (DvMediaContainer) branch;
                if (container.Class.ToString().StartsWith("object.container.storage"))
                {
                    // This container is a storage container of some sort
                    // so it should map to local directory.
                    //
                    string newDirPath = "";
                    if (container.Tag != null)
                    {
                        newDirPath = container.Tag.ToString();
                    }

                    // Make a directory representing this container
                    // and set the container's tag to point to the
                    // media dir info.
                    //
                    DirectoryInfo newDirInfo = Directory.CreateDirectory(newDirPath);
                    InnerMediaDirectory mediadir = new InnerMediaDirectory();
                    mediadir.directory = newDirInfo;
                    mediadir.directoryname = newDirInfo.FullName;
                    container.Tag = mediadir;
                }
                else if (container.Class.ToString().StartsWith("object.container"))
                {
                    // This is a container, but it doesn't nececessarily map
                    // to a local directory. The container subtree may have
                    // items and references, so persist them virtually
                    // in the hierarchy but not on disk.
                    //
                    container.Tag = null;
                }

                foreach (IDvMedia child in container.CompleteList)
                {
                    ModifyLocalFileSystem(container, child);
                }
            }
        }