Example #1
0
        /// <summary> Gets the view object from this item based on the requested viewer code  </summary>
        /// <param name="viewer_code"> Viewer code for the viewer requested </param>
        /// <returns> Valid view object from this item, based on requested viewer code, or NULL </returns>
        public View_Object Get_Viewer(string viewer_code)
        {
            string lower_code = viewer_code.ToLower();

            // If this is for the restricted viewer, that is always valid
            if (lower_code == "res")
            {
                return(new View_Object(View_Enum.RESTRICTED));
            }

            // If this was for the full citation, jsut return that
            if (lower_code.IndexOf("citation") == 0)
            {
                return(new View_Object(View_Enum.CITATION));
            }

            // Is this in the item level viewer list?
            if (behaviors.Views_Count > 0)
            {
                foreach (View_Object thisView in behaviors.Views)
                {
                    foreach (string thisCode in thisView.Viewer_Codes)
                    {
                        if (thisCode.ToLower() == lower_code)
                        {
                            return(thisView);
                        }
                    }
                }
            }

            // Check each page
            if ((viewer_to_file != null) && (viewer_to_file.ContainsKey(lower_code)))
            {
                return(viewer_to_file[lower_code].Get_Viewer());
            }

            // No match, so just return the default..
            if (behaviors.Default_View != null)
            {
                return(behaviors.Default_View);
            }

            // Return first page viewer
            if ((pages_by_seq != null) && (pages_by_seq.Count > 0) && (pages_by_seq[0].Files.Count > 0))
            {
                SobekCM_File_Info first_page      = pages_by_seq[0].Files[0];
                View_Object       firstPageViewer = first_page.Get_Viewer();
            }

            // If there is a single view, return the first code for it
            if (behaviors.Views_Count > 0)
            {
                return(behaviors.Views[0]);
            }

            // Return null
            return(null);
        }
        /// <summary> Saves the data stored in this instance of the
        /// element to the provided bibliographic object </summary>
        /// <param name="Bib"> Object into which to save this element's data </param>
        public override void Save_To_Bib(SobekCM_Item Bib)
        {
            if (thisViewBox.Text.Trim().Length > 0)
            {
                switch (thisViewBox.Text)
                {
                case "Page Image (JPEG)":
                    Bib.Behaviors.Add_View(View_Enum.JPEG);
                    break;

                case "Zoomable (JPEG2000)":
                    Bib.Behaviors.Add_View(View_Enum.JPEG2000);
                    break;

                case "HTML":
                    View_Object newView = new View_Object(View_Enum.HTML);
                    newView.Attributes = thisAttributesBox.Text.Trim();
                    newView.Label      = thisLabelBox.Text.Trim();
                    Bib.Behaviors.Add_View(newView);
                    if (thisAttributesBox.Text.Trim().Length > 0)
                    {
                        SobekCM_File_Info newestFile = new SobekCM_File_Info(thisAttributesBox.Text.Trim());
                        Bib.Divisions.Physical_Tree.Add_File(newestFile);
                    }
                    break;

                case "HTML_MAP":
                    View_Object newView2 = new View_Object(View_Enum.HTML_MAP);
                    newView2.Attributes = thisAttributesBox.Text.Trim();
                    newView2.Label      = thisLabelBox.Text.Trim();
                    Bib.Behaviors.Add_View(newView2);
                    break;

                case "Thumbnails":
                    Bib.Behaviors.Add_View(View_Enum.RELATED_IMAGES);
                    break;

                case "Text":
                    Bib.Behaviors.Add_View(View_Enum.TEXT);
                    break;

                case "Page Turner":
                    Bib.Behaviors.Add_View(View_Enum.PAGE_TURNER);
                    break;
                }
            }
        }
Example #3
0
        private void recurse_through_nodes(SobekCM_Item thisPackage, abstract_TreeNode node, List <Page_TreeNode> pages_encountered)
        {
            if (node.Page)
            {
                Page_TreeNode pageNode = (Page_TreeNode)node;
                if (!pages_encountered.Contains(pageNode))
                {
                    pageseq++;

                    // Add each of the files view codes to the list
                    bool page_added = false;
                    foreach (SobekCM_File_Info thisFile in pageNode.Files)
                    {
                        string upper_name = thisFile.System_Name.ToUpper();
                        if ((upper_name.IndexOf("SOUNDFILESONLY") < 0) && (upper_name.IndexOf("FILMONLY") < 0) && (upper_name.IndexOf("MULTIMEDIA") < 0) && (upper_name.IndexOf("THM.JPG") < 0))
                        {
                            if (!page_added)
                            {
                                // Add this to the simple page collection
                                thisPackage.Web.Add_Pages_By_Sequence(pageNode);
                                pages_encountered.Add(pageNode);
                                page_added = true;
                            }
                            View_Object thisViewer = thisFile.Get_Viewer();
                            if (thisViewer != null)
                            {
                                string[] codes = thisViewer.Viewer_Codes;
                                if ((codes.Length > 0) && (codes[0].Length > 0))
                                {
                                    thisPackage.Web.Viewer_To_File[pageseq.ToString() + codes[0]] = thisFile;
                                }
                            }
                        }
                    }
                }
            }
            else
            {
                divseq++;
                Division_TreeNode divNode = (Division_TreeNode)node;
                foreach (abstract_TreeNode childNode in divNode.Nodes)
                {
                    recurse_through_nodes(thisPackage, childNode, pages_encountered);
                }
            }
        }
        /// <summary>Add a new SobekCM View to this resource </summary>
        /// <param name="View_Type">Standard type of SobekCM View</param>
        /// <param name="Label">Label for this SobekCM View</param>
        /// <param name="Attributes">Any additional attribures needed for thie SobekCM View</param>
        /// <param name="MenuOrder"> order where this sits on the item main menu </param>
        /// <returns>Built view object</returns>
        public View_Object Add_View(string View_Type, string Label, string Attributes, float MenuOrder, bool Exclude )
        {
            if (!String.IsNullOrEmpty(View_Type))
            {
                if (Views == null)
                    Views = new List<View_Object>();

                View_Object newView = new View_Object(View_Type, Label, Attributes) { MenuOrder = MenuOrder, Exclude = Exclude };
                Views.Add(newView);
                return newView;
            }

            return null;
        }
Example #5
0
        /// <summary> Get the navigation bar html for a view, given information about the current request </summary>
        /// <param name="Item_View"> View for which to generate the html </param>
        /// <param name="Resource_Type"> Current resource type, which determines the text in several viewer's tabs</param>
        /// <param name="Skin_Code"> Code for the current web sking, which determines which tab images to use </param>
        /// <param name="Current_Mode"> Mode / navigation information for the current request</param>
        /// <param name="Page_Sequence"> Current page sequence </param>
        /// <param name="Translator"> Language support object provides support for translating common user interface elements, like the names of these tabs </param>
        /// <param name="Show_Zoomable"> Flag indicates if the zoomable server is online and should be displayable </param>
        /// <returns> Collection of the html for the navigation bar (one view could have multiple tabs)</returns>
        public static List <string> Get_Nav_Bar_HTML(View_Object Item_View, string Resource_Type,
                                                     string Skin_Code, SobekCM_Navigation_Object Current_Mode, int Page_Sequence,
                                                     Language_Support_Info Translator, bool Show_Zoomable, SobekCM_Item Current_Item)
        {
            List <string> returnVal = new List <string>();

            switch (Item_View.View_Type)
            {
            case View_Enum.ALL_VOLUMES:
                string allVolumeCode       = "allvolumes";
                string resource_type_upper = Resource_Type.ToUpper();
                if (Current_Mode.ViewerCode.IndexOf("allvolumes") == 0)
                {
                    allVolumeCode = Current_Mode.ViewerCode;
                }
                if (resource_type_upper.IndexOf("NEWSPAPER") >= 0)
                {
                    returnVal.Add(HTML_Helper(Skin_Code, allVolumeCode, Translator.Get_Translation("ALL ISSUES", Current_Mode.Language), Current_Mode));
                }
                else
                {
                    if (resource_type_upper.IndexOf("MAP") >= 0)
                    {
                        returnVal.Add(HTML_Helper(Skin_Code, allVolumeCode, Translator.Get_Translation("RELATED MAPS", Current_Mode.Language), Current_Mode));
                    }
                    else
                    {
                        returnVal.Add(resource_type_upper.IndexOf("AERIAL") >= 0
                                              ? HTML_Helper(Skin_Code, allVolumeCode, Translator.Get_Translation("RELATED FLIGHTS", Current_Mode.Language), Current_Mode)
                                              : HTML_Helper(Skin_Code, allVolumeCode, Translator.Get_Translation("ALL VOLUMES", Current_Mode.Language), Current_Mode));
                    }
                }
                break;

            case View_Enum.CITATION:
                if ((Current_Mode.ViewerCode == "citation") || (Current_Mode.ViewerCode == "marc") || (Current_Mode.ViewerCode == "metadata") || (Current_Mode.ViewerCode == "usage"))
                {
                    returnVal.Add(HTML_Helper(Skin_Code, Current_Mode.ViewerCode, Translator.Get_Translation("CITATION", Current_Mode.Language), Current_Mode));
                }
                else
                {
                    returnVal.Add(HTML_Helper(Skin_Code, "citation", Translator.Get_Translation("CITATION", Current_Mode.Language), Current_Mode));
                }
                break;

            case View_Enum.DATASET_CODEBOOK:
                returnVal.Add(HTML_Helper(Skin_Code, "dscodebook", Translator.Get_Translation("DATA STRUCTURE", Current_Mode.Language), Current_Mode));
                break;

            case View_Enum.DATASET_REPORTS:
                returnVal.Add(HTML_Helper(Skin_Code, "dsreports", Translator.Get_Translation("REPORTS", Current_Mode.Language), Current_Mode));
                break;

            case View_Enum.DATASET_VIEWDATA:
                returnVal.Add(HTML_Helper(Skin_Code, "dsview", Translator.Get_Translation("EXPLORE DATA", Current_Mode.Language), Current_Mode));
                break;

            case View_Enum.DOWNLOADS:
                returnVal.Add(HTML_Helper(Skin_Code, "downloads", Translator.Get_Translation("DOWNLOADS", Current_Mode.Language), Current_Mode));
                break;

            case View_Enum.FEATURES:
                returnVal.Add(HTML_Helper(Skin_Code, "features", Translator.Get_Translation("FEATURES", Current_Mode.Language), Current_Mode));
                break;

            case View_Enum.FLASH:
                returnVal.Add(Item_View.Label.Length == 0
                                      ? HTML_Helper(Skin_Code, "flash", Translator.Get_Translation("FLASH VIEW", Current_Mode.Language), Current_Mode)
                                      : HTML_Helper(Skin_Code, "flash", Translator.Get_Translation(Item_View.Label.ToUpper(), Current_Mode.Language), Current_Mode));
                break;

            case View_Enum.GOOGLE_MAP:
                if (Current_Mode.Coordinates.Length > 0)
                {
                    if (Current_Mode.ViewerCode == "mapsearch")
                    {
                        returnVal.Add(HTML_Helper(Skin_Code, "mapsearch", Translator.Get_Translation("MAP SEARCH", Current_Mode.Language), Current_Mode));
                    }
                    else
                    {
                        if ((Current_Item.Web.Static_PageCount > 1) || (Current_Item.Bib_Info.SobekCM_Type != TypeOfResource_SobekCM_Enum.Map))
                        {
                            returnVal.Add(HTML_Helper(Skin_Code, "map", Translator.Get_Translation("SEARCH RESULTS", Current_Mode.Language), Current_Mode));
                        }
                        else
                        {
                            returnVal.Add(HTML_Helper(Skin_Code, "map", Translator.Get_Translation("MAP COVERAGE", Current_Mode.Language), Current_Mode));
                        }
                    }
                }
                else
                {
                    returnVal.Add(HTML_Helper(Skin_Code, "map", Translator.Get_Translation("MAP IT!", Current_Mode.Language), Current_Mode));
                }
                break;

            case View_Enum.GOOGLE_MAP_BETA:
                if (Current_Mode.Coordinates.Length > 0)
                {
                    if (Current_Mode.ViewerCode == "mapsearchbeta")
                    {
                        returnVal.Add(HTML_Helper(Skin_Code, "mapsearchbeta", Translator.Get_Translation("MAP SEARCH", Current_Mode.Language), Current_Mode));
                    }
                    else
                    {
                        if ((Current_Item.Web.Static_PageCount > 1) || (Current_Item.Bib_Info.SobekCM_Type != TypeOfResource_SobekCM_Enum.Map_Beta))
                        {
                            returnVal.Add(HTML_Helper(Skin_Code, "mapbeta", Translator.Get_Translation("SEARCH RESULTS", Current_Mode.Language), Current_Mode));
                        }
                        else
                        {
                            returnVal.Add(HTML_Helper(Skin_Code, "mapbeta", Translator.Get_Translation("MAP COVERAGE", Current_Mode.Language), Current_Mode));
                        }
                    }
                }
                else
                {
                    returnVal.Add(HTML_Helper(Skin_Code, "map", Translator.Get_Translation("MAP IT!", Current_Mode.Language), Current_Mode));
                }
                break;

            case View_Enum.HTML:
                returnVal.Add(Item_View.Label.Length > 0
                                      ? HTML_Helper(Skin_Code, "html", Item_View.Label.ToUpper(), Current_Mode)
                                      : HTML_Helper(Skin_Code, "html", "HTML LINK", Current_Mode));
                break;

            case View_Enum.JPEG:
                returnVal.Add(HTML_Helper_PageView(Skin_Code, Page_Sequence.ToString() + "j", Translator.Get_Translation("STANDARD", Current_Mode.Language), Current_Mode));
                break;

            case View_Enum.JPEG_TEXT_TWO_UP:
                returnVal.Add(HTML_Helper_PageView(Skin_Code, Page_Sequence.ToString() + "u", Translator.Get_Translation("PAGE IMAGE WITH TEXT", Current_Mode.Language), Current_Mode));
                break;

            case View_Enum.JPEG2000:
                if (Show_Zoomable)
                {
                    returnVal.Add(HTML_Helper_PageView(Skin_Code, Page_Sequence.ToString() + "x", Translator.Get_Translation("ZOOMABLE", Current_Mode.Language), Current_Mode));
                }
                break;

            case View_Enum.PDF:
                returnVal.Add(HTML_Helper(Skin_Code, "pdf", Translator.Get_Translation("PDF VIEWER", Current_Mode.Language), Current_Mode));
                break;

            case View_Enum.RELATED_IMAGES:
                returnVal.Add(Current_Mode.ViewerCode.IndexOf("thumbs") >= 0
                                      ? HTML_Helper(Skin_Code, Current_Mode.ViewerCode, Translator.Get_Translation("THUMBNAILS", Current_Mode.Language), Current_Mode)
                                      : HTML_Helper(Skin_Code, "thumbs", Translator.Get_Translation("THUMBNAILS", Current_Mode.Language), Current_Mode));
                break;

            case View_Enum.SEARCH:
                returnVal.Add(HTML_Helper(Skin_Code, "search", Translator.Get_Translation("SEARCH", Current_Mode.Language), Current_Mode));
                break;

            case View_Enum.SIMPLE_HTML_LINK:
                returnVal.Add("<li> <a href=\"" + Item_View.Attributes + "\" target=\"_blank\" alt=\"Link to '" + Item_View.Label + "'\"> " + Translator.Get_Translation(Item_View.Label.ToUpper(), Current_Mode.Language) + " </a></li>");
                break;

            case View_Enum.STREETS:
                returnVal.Add(HTML_Helper(Skin_Code, "streets", Translator.Get_Translation("STREETS", Current_Mode.Language), Current_Mode));
                break;

            case View_Enum.TEXT:
                returnVal.Add(HTML_Helper_PageView(Skin_Code, Page_Sequence.ToString() + "t", Translator.Get_Translation("PAGE TEXT", Current_Mode.Language), Current_Mode));
                break;

            case View_Enum.TOC:
                // returnVal.Add(base.HTML_Helper(Skin_Code, "TC", "Table of Contents", Current_Mode));
                break;

            case View_Enum.RESTRICTED:
                returnVal.Add(HTML_Helper(Skin_Code, "restricted", Translator.Get_Translation("RESTRICTED", Current_Mode.Language), Current_Mode));
                break;

            case View_Enum.EAD_CONTAINER_LIST:
                returnVal.Add(HTML_Helper(Skin_Code, "container", Translator.Get_Translation("CONTAINER LIST", Current_Mode.Language), Current_Mode));
                break;

            case View_Enum.EAD_DESCRIPTION:
                // Return nothing, this is currently written when writing the CITATION, for
                // all EAD type items.
                //returnVal.Add(HTML_Helper(Skin_Code, "description", Translator.Get_Translation("DESCRIPTION", Current_Mode.Language), Current_Mode));
                break;

            case View_Enum.PAGE_TURNER:
                returnVal.Add(HTML_Helper(Skin_Code, "pageturner#page/1/mode/2up", Translator.Get_Translation("PAGE TURNER", Current_Mode.Language), Current_Mode));
                break;

            case View_Enum.YOUTUBE_VIDEO:
                returnVal.Add(HTML_Helper(Skin_Code, "youtube", Translator.Get_Translation("VIDEO", Current_Mode.Language), Current_Mode));
                break;

            case View_Enum.EMBEDDED_VIDEO:
                returnVal.Add(HTML_Helper(Skin_Code, "video", Translator.Get_Translation("VIDEO", Current_Mode.Language), Current_Mode));
                break;

            case View_Enum.TRACKING:
                // DO nothing in this case.. do not write any tab
                break;

            case View_Enum.TRACKING_SHEET:
                //DO nothing in this case.. do not write any tab
                break;

            case View_Enum.QUALITY_CONTROL:
                // DO nothing in this case.. do not write any tab
                break;
            }

            return(returnVal);
        }
        private void Finish_Building_Item(SobekCM_Item Package_To_Finalize, DataSet DatabaseInfo, bool Multiple, List<string> Item_Viewer_Priority, Custom_Tracer Tracer )
        {
            Tracer.Add_Trace("SobekCM_METS_Based_ItemBuilder.Finish_Building_Item", "Load the data from the database into the resource object");

            if ((DatabaseInfo == null) || (DatabaseInfo.Tables[2] == null) || (DatabaseInfo.Tables[2].Rows.Count == 0))
            {
                Tracer.Add_Trace("SobekCM_METS_Based_ItemBuilder.Finish_Building_Item", "Invalid data from the database, either not enough tables, or no rows in Tables[2]");
            }
            else
            {
                // Copy over some basic values
                DataRow mainItemRow = DatabaseInfo.Tables[2].Rows[0];
                Package_To_Finalize.Behaviors.Set_Primary_Identifier(mainItemRow["Primary_Identifier_Type"].ToString(), mainItemRow["Primary_Identifier"].ToString());
                Package_To_Finalize.Behaviors.GroupTitle = mainItemRow["GroupTitle"].ToString();
                Package_To_Finalize.Behaviors.GroupType = mainItemRow["GroupType"].ToString();
                Package_To_Finalize.Web.File_Root = mainItemRow["File_Location"].ToString();
                Package_To_Finalize.Web.AssocFilePath = mainItemRow["File_Location"] + "\\" + Package_To_Finalize.VID + "\\";
                Package_To_Finalize.Behaviors.IP_Restriction_Membership = Convert.ToInt16(mainItemRow["IP_Restriction_Mask"]);
                Package_To_Finalize.Behaviors.CheckOut_Required = Convert.ToBoolean(mainItemRow["CheckoutRequired"]);
                Package_To_Finalize.Behaviors.Text_Searchable = Convert.ToBoolean(mainItemRow["TextSearchable"]);
                Package_To_Finalize.Web.ItemID = Convert.ToInt32(mainItemRow["ItemID"]);
                Package_To_Finalize.Web.GroupID = Convert.ToInt32(mainItemRow["GroupID"]);
                Package_To_Finalize.Behaviors.Suppress_Endeca = Convert.ToBoolean(mainItemRow["SuppressEndeca"]);
                //Package_To_Finalize.Behaviors.Expose_Full_Text_For_Harvesting = Convert.ToBoolean(mainItemRow["SuppressEndeca"]);
                Package_To_Finalize.Tracking.Internal_Comments = mainItemRow["Comments"].ToString();
                Package_To_Finalize.Behaviors.Dark_Flag = Convert.ToBoolean(mainItemRow["Dark"]);
                Package_To_Finalize.Tracking.Born_Digital = Convert.ToBoolean(mainItemRow["Born_Digital"]);
                Package_To_Finalize.Behaviors.Main_Thumbnail = mainItemRow["MainThumbnail"].ToString();
                //Package_To_Finalize.Divisions.Page_Count = Convert.ToInt32(mainItemRow["Pages"]);
                if (mainItemRow["Disposition_Advice"] != DBNull.Value)
                    Package_To_Finalize.Tracking.Disposition_Advice = Convert.ToInt16(mainItemRow["Disposition_Advice"]);
                else
                    Package_To_Finalize.Tracking.Disposition_Advice = -1;
                if (mainItemRow["Material_Received_Date"] != DBNull.Value)
                    Package_To_Finalize.Tracking.Material_Received_Date = Convert.ToDateTime(mainItemRow["Material_Received_Date"]);
                else
                    Package_To_Finalize.Tracking.Material_Received_Date = null;
                if (mainItemRow["Material_Recd_Date_Estimated"] != DBNull.Value)
                    Package_To_Finalize.Tracking.Material_Rec_Date_Estimated = Convert.ToBoolean(mainItemRow["Material_Recd_Date_Estimated"]);
                if (DatabaseInfo.Tables[2].Columns.Contains("Tracking_Box"))
                {
                    if (mainItemRow["Tracking_Box"] != DBNull.Value)
                        Package_To_Finalize.Tracking.Tracking_Box = mainItemRow["Tracking_Box"].ToString();
                }

                // Set more of the sobekcm web portions in the item
                Package_To_Finalize.Web.Set_BibID_VID(Package_To_Finalize.BibID, Package_To_Finalize.VID);
                Package_To_Finalize.Web.Image_Root = Engine_ApplicationCache_Gateway.Settings.Servers.Image_URL;
                if (Multiple)
                    Package_To_Finalize.Web.Siblings = 2;

                // Set the serial hierarchy from the database (if multiple)
                if ((Multiple) && (mainItemRow["Level1_Text"].ToString().Length > 0))
                {
                    Tracer.Add_Trace("SobekCM_METS_Based_ItemBuilder.Finish_Building_Item", "Assigning serial hierarchy from the database info");

                    bool found = false;

                    // Get the values from the database first
                    string level1_text = mainItemRow["Level1_Text"].ToString();
                    string level2_text = mainItemRow["Level2_Text"].ToString();
                    string level3_text = mainItemRow["Level3_Text"].ToString();
                    int level1_index = Convert.ToInt32(mainItemRow["Level1_Index"]);
                    int level2_index = Convert.ToInt32(mainItemRow["Level2_Index"]);
                    int level3_index = Convert.ToInt32(mainItemRow["Level3_Index"]);

                    // Does this match the enumeration
                    if (level1_text.ToUpper().Trim() == Package_To_Finalize.Bib_Info.Series_Part_Info.Enum1.ToUpper().Trim())
                    {
                        // Copy the database values to the enumeration portion
                        Package_To_Finalize.Bib_Info.Series_Part_Info.Enum1 = level1_text;
                        Package_To_Finalize.Bib_Info.Series_Part_Info.Enum1_Index = level1_index;
                        Package_To_Finalize.Bib_Info.Series_Part_Info.Enum2 = level2_text;
                        Package_To_Finalize.Bib_Info.Series_Part_Info.Enum2_Index = level2_index;
                        Package_To_Finalize.Bib_Info.Series_Part_Info.Enum3 = level3_text;
                        Package_To_Finalize.Bib_Info.Series_Part_Info.Enum3_Index = level3_index;
                        found = true;
                    }

                    // Does this match the chronology
                    if ((!found) && (level1_text.ToUpper().Trim() == Package_To_Finalize.Bib_Info.Series_Part_Info.Year.ToUpper().Trim()))
                    {
                        // Copy the database values to the chronology portion
                        Package_To_Finalize.Bib_Info.Series_Part_Info.Year = level1_text;
                        Package_To_Finalize.Bib_Info.Series_Part_Info.Year_Index = level1_index;
                        Package_To_Finalize.Bib_Info.Series_Part_Info.Month = level2_text;
                        Package_To_Finalize.Bib_Info.Series_Part_Info.Month_Index = level2_index;
                        Package_To_Finalize.Bib_Info.Series_Part_Info.Day = level3_text;
                        Package_To_Finalize.Bib_Info.Series_Part_Info.Day_Index = level3_index;
                        found = true;
                    }

                    if (!found)
                    {
                        // No match.  If it is numeric, move it to the chronology, otherwise, enumeration
                        bool charFound = level1_text.Trim().Any(ThisChar => !Char.IsNumber(ThisChar));

                        if (charFound)
                        {
                            // Copy the database values to the enumeration portion
                            Package_To_Finalize.Bib_Info.Series_Part_Info.Enum1 = level1_text;
                            Package_To_Finalize.Bib_Info.Series_Part_Info.Enum1_Index = level1_index;
                            Package_To_Finalize.Bib_Info.Series_Part_Info.Enum2 = level2_text;
                            Package_To_Finalize.Bib_Info.Series_Part_Info.Enum2_Index = level2_index;
                            Package_To_Finalize.Bib_Info.Series_Part_Info.Enum3 = level3_text;
                            Package_To_Finalize.Bib_Info.Series_Part_Info.Enum3_Index = level3_index;
                        }
                        else
                        {
                            // Copy the database values to the chronology portion
                            Package_To_Finalize.Bib_Info.Series_Part_Info.Year = level1_text;
                            Package_To_Finalize.Bib_Info.Series_Part_Info.Year_Index = level1_index;
                            Package_To_Finalize.Bib_Info.Series_Part_Info.Month = level2_text;
                            Package_To_Finalize.Bib_Info.Series_Part_Info.Month_Index = level2_index;
                            Package_To_Finalize.Bib_Info.Series_Part_Info.Day = level3_text;
                            Package_To_Finalize.Bib_Info.Series_Part_Info.Day_Index = level3_index;
                        }
                    }

                    // Copy the database values to the simple serial portion (used to actually determine serial heirarchy)
                    Package_To_Finalize.Behaviors.Serial_Info.Clear();
                    Package_To_Finalize.Behaviors.Serial_Info.Add_Hierarchy(1, level1_index, level1_text);
                    if (level2_text.Length > 0)
                    {
                        Package_To_Finalize.Behaviors.Serial_Info.Add_Hierarchy(2, level2_index, level2_text);
                        if (level3_text.Length > 0)
                        {
                            Package_To_Finalize.Behaviors.Serial_Info.Add_Hierarchy(3, level3_index, level3_text);
                        }
                    }
                }

                // See if this can be described
                bool can_describe = false;
                foreach (DataRow thisRow in DatabaseInfo.Tables[1].Rows)
                {
                    int thisAggregationValue = Convert.ToInt16(thisRow["Items_Can_Be_Described"]);
                    if (thisAggregationValue == 0)
                    {
                        can_describe = false;
                        break;
                    }
                    if (thisAggregationValue == 2)
                    {
                        can_describe = true;
                    }
                }
                Package_To_Finalize.Behaviors.Can_Be_Described = can_describe;

                // Look for rights information to add
                if (mainItemRow["EmbargoEnd"] != DBNull.Value)
                {
                    try
                    {
                        DateTime embargoEnd = DateTime.Parse(mainItemRow["EmbargoEnd"].ToString());
                        string origAccessCode = mainItemRow["Original_AccessCode"].ToString();

                        // Is there already a RightsMD module in the item?
                        // Ensure this metadata module extension exists
                        RightsMD_Info rightsInfo = Package_To_Finalize.Get_Metadata_Module(GlobalVar.PALMM_RIGHTSMD_METADATA_MODULE_KEY) as RightsMD_Info;
                        if (rightsInfo == null)
                        {
                            rightsInfo = new RightsMD_Info();
                            Package_To_Finalize.Add_Metadata_Module(GlobalVar.PALMM_RIGHTSMD_METADATA_MODULE_KEY, rightsInfo);
                        }

                        // Add the data
                        rightsInfo.Access_Code_String = origAccessCode;
                        rightsInfo.Embargo_End = embargoEnd;
                    }
                    catch (Exception)
                    {

                    }
                }
            }

            // Look for user descriptions
            Tracer.Add_Trace("SobekCM_METS_Based_ItemBuilder.Finish_Building_Item", "Look for user descriptions (or tags)");
            foreach (DataRow thisRow in DatabaseInfo.Tables[0].Rows)
            {
                string first_name = thisRow["FirstName"].ToString();
                string nick_name = thisRow["NickName"].ToString();
                string last_name = thisRow["LastName"].ToString();
                int userid = Convert.ToInt32(thisRow["UserID"]);
                string tag = thisRow["Description_Tag"].ToString();
                int tagid = Convert.ToInt32(thisRow["TagID"]);
                DateTime dateAdded = Convert.ToDateTime(thisRow["Date_Modified"]);

                if (nick_name.Length > 0)
                {
                    Package_To_Finalize.Behaviors.Add_User_Tag(userid, nick_name + " " + last_name, tag, dateAdded, tagid);
                }
                else
                {
                    Package_To_Finalize.Behaviors.Add_User_Tag(userid, first_name + " " + last_name, tag, dateAdded, tagid);
                }
            }

            // Look for ticklers
            Tracer.Add_Trace("SobekCM_METS_Based_ItemBuilder.Finish_Building_Item", "Load ticklers from the database info");
            foreach (DataRow thisRow in DatabaseInfo.Tables[3].Rows)
            {
                Package_To_Finalize.Behaviors.Add_Tickler(thisRow["MetadataValue"].ToString().Trim());
            }

            // Set the aggregationPermissions in the package to the aggregation links from the database
            Tracer.Add_Trace("SobekCM_METS_Based_ItemBuilder.Finish_Building_Item", "Load the aggregations from the database info");
            Package_To_Finalize.Behaviors.Clear_Aggregations();
            foreach (DataRow thisRow in DatabaseInfo.Tables[1].Rows)
            {
                if (!Convert.ToBoolean(thisRow["impliedLink"]))
                {
                    string code = thisRow["Code"].ToString();
                    if (String.Compare(code, "all", StringComparison.OrdinalIgnoreCase) != 0)
                    {
                        Package_To_Finalize.Behaviors.Add_Aggregation(code, thisRow["Name"].ToString(), thisRow["Type"].ToString());
                    }
                }
            }

            // If no collections, add some regardless of whether it was IMPLIED
            if ( Package_To_Finalize.Behaviors.Aggregation_Count == 0)
            {
                foreach (DataRow thisRow in DatabaseInfo.Tables[1].Rows)
                {
                    string code = thisRow["Code"].ToString();
                    if (String.Compare(code, "all", StringComparison.OrdinalIgnoreCase) != 0)
                    {
                        Package_To_Finalize.Behaviors.Add_Aggregation(code, thisRow["Name"].ToString(), thisRow["Type"].ToString());
                    }
                }
            }

            // Step through each page and set the static page count
            Tracer.Add_Trace("SobekCM_METS_Based_ItemBuilder.Finish_Building_Item", "Set the static page count");

            pageseq = 0;
            List<Page_TreeNode> pages_encountered = new List<Page_TreeNode>();
            if (!Package_To_Finalize.Behaviors.Dark_Flag)
            {
                foreach (abstract_TreeNode rootNode in Package_To_Finalize.Divisions.Physical_Tree.Roots)
                {
                    recurse_through_nodes(Package_To_Finalize, rootNode, pages_encountered);
                }
            }
            Package_To_Finalize.Web.Static_PageCount = pages_encountered.Count;
            Package_To_Finalize.Web.Static_Division_Count = divseq;

            // Make sure no icons were retained from the METS file itself
            Tracer.Add_Trace("SobekCM_METS_Based_ItemBuilder.Finish_Building_Item", "Load the wordmarks/icons from the database info");
            Package_To_Finalize.Behaviors.Clear_Wordmarks();

            // Add the icons from the database information
            foreach (DataRow iconRow in DatabaseInfo.Tables[5].Rows)
            {
                string image = iconRow[0].ToString();
                string link = iconRow[1].ToString().Replace("&", "&amp;").Replace("\"", "&quot;");
                string code = iconRow[2].ToString();
                string name = iconRow[3].ToString();
                if ( name.Length == 0 )
                    name = code.Replace("&", "&amp;").Replace("\"", "&quot;");

                string html;
                if (link.Length == 0)
                {
                    html = "<img class=\"SobekItemWordmark\" src=\"<%BASEURL%>design/wordmarks/" + image + "\" title=\"" + name + "\" alt=\"" + name + "\" />";
                }
                else
                {
                    if (link[0] == '?')
                    {
                        html = "<a href=\"" + link + "\"><img class=\"SobekItemWordmark\" src=\"<%BASEURL%>design/wordmarks/" + image + "\" alt=\"" + name + "\" /></a>";
                    }
                    else
                    {
                        html = "<a href=\"" + link + "\" target=\"_blank\"><img class=\"SobekItemWordmark\" src=\"<%BASEURL%>design/wordmarks/" + image + "\" alt=\"" + name + "\" /></a>";
                    }
                }

                Wordmark_Info newIcon = new Wordmark_Info {HTML = html, Link = link, Title = name, Code = code};
                Package_To_Finalize.Behaviors.Add_Wordmark(newIcon);
            }

            // Make sure no web skins were retained from the METS file itself
            Tracer.Add_Trace("SobekCM_METS_Based_ItemBuilder.Finish_Building_Item", "Load the web skins from the database info");
            Package_To_Finalize.Behaviors.Clear_Web_Skins();

            // Add the web skins from the database
            foreach (DataRow skinRow in DatabaseInfo.Tables[6].Rows)
            {
                Package_To_Finalize.Behaviors.Add_Web_Skin(skinRow[0].ToString().ToUpper());
            }

            Tracer.Add_Trace("SobekCM_METS_Based_ItemBuilder.Finish_Building_Item", "Set the views from a combination of the METS and the database info");

            // Make sure no views were retained from the METS file itself
            Package_To_Finalize.Behaviors.Clear_Views();
            Package_To_Finalize.Behaviors.Clear_Item_Level_Page_Views();

            // If this has more than 1 sibling (this count includes itself), add the multi-volumes viewer
            if (Multiple)
            {
                Package_To_Finalize.Behaviors.Add_View(View_Enum.ALL_VOLUMES, String.Empty, Package_To_Finalize.Bib_Info.SobekCM_Type_String);
            }

            // Add the full citation view and the (hidden) tracking view and some other ALWAYS views
            Package_To_Finalize.Behaviors.Add_View(View_Enum.CITATION);
            Package_To_Finalize.Behaviors.Add_View(View_Enum.TRACKING);
            Package_To_Finalize.Behaviors.Add_View(View_Enum.TRACKING_SHEET);
            Package_To_Finalize.Behaviors.Add_View(View_Enum.GOOGLE_COORDINATE_ENTRY);
            Package_To_Finalize.Behaviors.Add_View(View_Enum.TEST);
            Package_To_Finalize.Behaviors.Add_View(View_Enum.MANAGE);

            // Add the full text searchable
            if ( Package_To_Finalize.Behaviors.Text_Searchable )
                Package_To_Finalize.Behaviors.Add_View(View_Enum.SEARCH);

            // Is there an embedded video?
            if (Package_To_Finalize.Behaviors.Embedded_Video.Length > 0)
                Package_To_Finalize.Behaviors.Add_View(View_Enum.EMBEDDED_VIDEO);

            // If there is no PURL, add one based on how SobekCM operates
            if (Package_To_Finalize.Bib_Info.Location.PURL.Length == 0)
            {
                Package_To_Finalize.Bib_Info.Location.PURL = Engine_ApplicationCache_Gateway.Settings.Servers.System_Base_URL + Package_To_Finalize.BibID + "/" + Package_To_Finalize.VID;

            }

            // If this is a newspaper, and there is no datecreated, see if we
            // can make one from the  serial hierarchy
            if (Package_To_Finalize.Behaviors.GroupType.ToUpper() == "NEWSPAPER")
            {
                if ((Package_To_Finalize.Bib_Info.Origin_Info.Date_Created.Length == 0) && (Package_To_Finalize.Bib_Info.Origin_Info.Date_Issued.Length == 0))
                {
                    // Is the serial hierarchy three deep?
                    if (Package_To_Finalize.Behaviors.hasSerialInformation)
                    {
                        if (Package_To_Finalize.Behaviors.Serial_Info.Count == 3)
                        {
                            int year;

                            if (Int32.TryParse(Package_To_Finalize.Behaviors.Serial_Info[0].Display, out year))
                            {
                                int day;
                                if (Int32.TryParse(Package_To_Finalize.Behaviors.Serial_Info[2].Display, out day))
                                {
                                    if ((year > 0) && (year < DateTime.Now.Year + 2) && ( day > 0 ) && ( day <= 31 ))
                                    {
                                        // Is the month a number?
                                        int month;
                                        if (Int32.TryParse(Package_To_Finalize.Behaviors.Serial_Info[1].Display, out month))
                                        {
                                            try
                                            {
                                                // Do it this way since hopefully that will work for localization issues
                                                DateTime date = new DateTime(year, month, day);
                                                Package_To_Finalize.Bib_Info.Origin_Info.Date_Created = date.ToShortDateString();
                                            }
                                            catch
                                            {
                                                // If this is an invalid date, catch the error and do nothing
                                            }
                                        }
                                        else
                                        {
                                            Package_To_Finalize.Bib_Info.Origin_Info.Date_Created = Package_To_Finalize.Behaviors.Serial_Info[1].Display + " " + day + ", " + year;
                                        }
                                    }
                                }
                            }
                        }
                        else if ( Package_To_Finalize.Behaviors.Serial_Info.Count == 2 )
                        {
                            int year;
                            if (Int32.TryParse(Package_To_Finalize.Behaviors.Serial_Info[0].Display, out year))
                            {
                                if ((year > 0) && (year < DateTime.Now.Year + 2) && ( Package_To_Finalize.Behaviors.Serial_Info[1].Display.Length > 0 ))
                                {
                                    Package_To_Finalize.Bib_Info.Origin_Info.Date_Created = Package_To_Finalize.Behaviors.Serial_Info[1].Display + " " + year;
                                }
                            }
                        }
                    }
                }
            }

            // IF this is dark, add no other views
            if (Package_To_Finalize.Behaviors.Dark_Flag) return;

            // Check to see which views were present from the database, and build the list
            Dictionary<View_Enum, View_Object> viewsFromDb = new Dictionary<View_Enum, View_Object>();
            foreach (DataRow viewRow in DatabaseInfo.Tables[4].Rows)
            {
                string viewType = viewRow[0].ToString();
                string attribute = viewRow[1].ToString();
                string label = viewRow[2].ToString();

                View_Enum viewTypeEnum = View_Enum.None;
                switch (viewType)
                {
                    case "Dataset Codebook":
                        viewTypeEnum = View_Enum.DATASET_CODEBOOK;
                        break;

                    case "Dataset Reports":
                        viewTypeEnum = View_Enum.DATASET_REPORTS;
                        break;

                    case "Dataset View Data":
                        viewTypeEnum = View_Enum.DATASET_VIEWDATA;
                        break;

                    case "Google Map":
                        viewTypeEnum = View_Enum.GOOGLE_MAP;
                        break;

                    case "Google Map Beta":
                        viewTypeEnum = View_Enum.GOOGLE_MAP_BETA;
                        break;

                    case "HTML Viewer":
                        viewTypeEnum = View_Enum.HTML;
                        break;

                    case "JPEG":
                        viewTypeEnum = View_Enum.JPEG;
                        break;

                    case "JPEG/Text Two Up":
                        viewTypeEnum = View_Enum.JPEG_TEXT_TWO_UP;
                        break;

                    case "JPEG2000":
                        viewTypeEnum = View_Enum.JPEG2000;
                        break;

                    case "Page Turner":
                        viewTypeEnum = View_Enum.PAGE_TURNER;
                        break;

                    case "Related Images":
                        viewTypeEnum = View_Enum.RELATED_IMAGES;
                        break;

                    case "TEI":
                        viewTypeEnum = View_Enum.TEI;
                        break;

                    case "Text":
                        viewTypeEnum = View_Enum.TEXT;
                        break;

                    case "TOC":
                        viewTypeEnum = View_Enum.TOC;
                        break;
                }

                if (viewTypeEnum != View_Enum.None)
                {
                    viewsFromDb[viewTypeEnum] = new View_Object(viewTypeEnum, label, attribute);
                }
            }

            // Add the dataset views (later we should do some checking here, but for
            // now just add them if the user selected them.
            if (viewsFromDb.ContainsKey(View_Enum.DATASET_VIEWDATA))
            {
                Package_To_Finalize.Behaviors.Add_View(viewsFromDb[View_Enum.DATASET_VIEWDATA]);
                viewsFromDb.Remove(View_Enum.DATASET_VIEWDATA);
            }
            if (viewsFromDb.ContainsKey(View_Enum.DATASET_CODEBOOK))
            {
                Package_To_Finalize.Behaviors.Add_View(viewsFromDb[View_Enum.DATASET_CODEBOOK]);
                viewsFromDb.Remove(View_Enum.DATASET_CODEBOOK);
            }
            if (viewsFromDb.ContainsKey(View_Enum.DATASET_REPORTS))
            {
                Package_To_Finalize.Behaviors.Add_View(viewsFromDb[View_Enum.DATASET_REPORTS]);
                viewsFromDb.Remove(View_Enum.DATASET_REPORTS);
            }

            // Add the thumbnail view, if requested and has multiple pages
            if (Package_To_Finalize.Divisions.Page_Count > 1)
            {
                if (viewsFromDb.ContainsKey(View_Enum.RELATED_IMAGES))
                {
                    Package_To_Finalize.Behaviors.Add_View(viewsFromDb[View_Enum.RELATED_IMAGES]);
                    viewsFromDb.Remove(View_Enum.RELATED_IMAGES);
                }
            }
            else
            {
                if (viewsFromDb.ContainsKey(View_Enum.RELATED_IMAGES))
                {
                    viewsFromDb.Remove(View_Enum.RELATED_IMAGES);
                }
            }

            // Always add the QC viewer ( the QC viewer will redirect to upload files if there are NO pages)
            Package_To_Finalize.Behaviors.Add_View(View_Enum.QUALITY_CONTROL);

            // If this item has more than one division, look for the TOC viewer
            if ((Package_To_Finalize.Divisions.Has_Multiple_Divisions) && (!Package_To_Finalize.Bib_Info.ImageClass))
            {
                if (viewsFromDb.ContainsKey(View_Enum.TOC))
                {
                    Package_To_Finalize.Behaviors.Add_View(viewsFromDb[View_Enum.TOC]);
                    viewsFromDb.Remove(View_Enum.TOC);
                }
            }

            // In addition, if there is a latitude or longitude listed, look for the Google Maps
            bool hasCoords = false;
            GeoSpatial_Information geoInfo = (GeoSpatial_Information) Package_To_Finalize.Get_Metadata_Module(GlobalVar.GEOSPATIAL_METADATA_MODULE_KEY);
            if (( geoInfo != null ) && ( geoInfo.hasData ))
            {
                if ((geoInfo.Point_Count > 0) || (geoInfo.Polygon_Count > 0))
                {
                    hasCoords = true;
                }
            }
            if (!hasCoords)
            {
                List<abstract_TreeNode> pageList = Package_To_Finalize.Divisions.Physical_Tree.Pages_PreOrder;
                if (pageList.Select(ThisPage => (GeoSpatial_Information) ThisPage.Get_Metadata_Module(GlobalVar.GEOSPATIAL_METADATA_MODULE_KEY)).Where(GeoInfo2 => (GeoInfo2 != null) && (GeoInfo2.hasData)).Any(GeoInfo2 => (GeoInfo2.Point_Count > 0) || (GeoInfo2.Polygon_Count > 0)))
                {
                    hasCoords = true;
                }
            }

            if (hasCoords)
            {
                if (viewsFromDb.ContainsKey(View_Enum.GOOGLE_MAP))
                {
                    Package_To_Finalize.Behaviors.Add_View(viewsFromDb[View_Enum.GOOGLE_MAP]);
                    viewsFromDb.Remove(View_Enum.GOOGLE_MAP);
                }
                else
                {
                    Package_To_Finalize.Behaviors.Add_View(View_Enum.GOOGLE_MAP);
                }
            }

            // Step through each download and make sure it is fully built
            if (( !Package_To_Finalize.Behaviors.Dark_Flag ) && ( Package_To_Finalize.Divisions.Download_Tree.Has_Files))
            {
                string ead_file = String.Empty;
                int pdf_download = 0;
                int video_download = 0;
                string pdf_download_url = String.Empty;
                List<abstract_TreeNode> downloadPages = Package_To_Finalize.Divisions.Download_Tree.Pages_PreOrder;
                string xsl = String.Empty;

                // Keep track of all the unhandled downloads, which will casue a DOWNLOAD tab to appear
                List<abstract_TreeNode> unhandledDownload = new List<abstract_TreeNode>();

                // Step through each download page
                foreach (Page_TreeNode downloadPage in downloadPages)
                {
                    bool download_handled = false;

                    // If this page has only a single file, might be handled by a single viewer
                    if ((!download_handled) && (downloadPage.Files.Count == 1))
                    {
                        string extension = downloadPage.Files[0].File_Extension;

                        // Was this an EAD page?
                        switch (extension)
                        {
                            case "XML":
                                if (downloadPage.Label == "EAD")
                                {
                                    Package_To_Finalize.Bib_Info.SobekCM_Type = TypeOfResource_SobekCM_Enum.EAD;
                                    ead_file = downloadPage.Files[0].System_Name;
                                    download_handled = true;
                                }
                                break;

                            case "SWF":
                                // FLASH files are always handled
                                string flashlabel = downloadPage.Label;
                                Package_To_Finalize.Behaviors.Add_View(View_Enum.FLASH, flashlabel, String.Empty, downloadPage.Files[0].System_Name);
                                download_handled = true;
                                break;

                            case "PDF":
                                pdf_download++;
                                if (pdf_download == 1)
                                {
                                    pdf_download_url = downloadPage.Files[0].System_Name;
                                    download_handled = true;
                                }
                                break;

                            case "XSL":
                                xsl = downloadPage.Files[0].System_Name;
                                download_handled = true;
                                break;

                            case "HTML":
                            case "HTM":
                                if (viewsFromDb.ContainsKey(View_Enum.HTML))
                                {
                                    if (String.Compare(viewsFromDb[View_Enum.HTML].Attributes, downloadPage.Files[0].System_Name, StringComparison.InvariantCultureIgnoreCase) == 0)
                                    {
                                        download_handled = true;
                                    }
                                }
                                break;

                            case "WEBM":
                            case "OGG":
                            case "MP4":
                            //case "AVI":
                            //case "WMV":
                            //case "MPG":
                            //case "MOV":
                            //case "FLV":
                            //case "VOB":
                            //case "WAV":
                            //case "OGM":
                            //case "MKV":
                                video_download++;
                                download_handled = true;
                                break;
                        }
                    }

                    // Check for video files
                    if ((!download_handled) && ( downloadPage.Files != null ))
                    {
                        foreach (SobekCM_File_Info thisFileInfo in downloadPage.Files)
                        {
                            string extension = thisFileInfo.File_Extension;

                            // Was this an EAD page?
                            switch (extension)
                            {
                                case "WEBM":
                                case "OGG":
                                case "MP4":
                                    //case "AVI":
                                    //case "WMV":
                                    //case "MPG":
                                    //case "MOV":
                                    //case "FLV":
                                    //case "VOB":
                                    //case "WAV":
                                    //case "OGM":
                                    //case "MKV":
                                    video_download++;
                                    download_handled = true;
                                    break;
                            }

                            if (download_handled)
                                break;
                        }
                    }

                    // Step through each download file
                    if (!download_handled)
                    {
                        unhandledDownload.Add(downloadPage);

                        foreach (SobekCM_File_Info thisFile in downloadPage.Files)
                        {
                            if (thisFile.File_Extension == "SWF")
                            {
                                string flashlabel = downloadPage.Label;
                                Package_To_Finalize.Behaviors.Add_View(View_Enum.FLASH, flashlabel, String.Empty, thisFile.System_Name);
                            }

                            if (thisFile.File_Extension == "PDF")
                            {
                                pdf_download++;
                                if (pdf_download == 1)
                                {
                                    pdf_download_url = thisFile.System_Name;
                                }
                            }

                        }
                    }
                }

                // Some special code for EAD objects
                if ((Package_To_Finalize.Bib_Info.SobekCM_Type == TypeOfResource_SobekCM_Enum.EAD) && (ead_file.Length > 0))
                {
                    // Now, read this EAD file information
                    string ead_file_location = Engine_ApplicationCache_Gateway.Settings.Servers.Image_Server_Network + Package_To_Finalize.Web.AssocFilePath + ead_file;
                    EAD_File_ReaderWriter reader = new EAD_File_ReaderWriter();
                    string errorMessage;
                    Dictionary<string, object> options = new Dictionary<string, object>();
                    options["EAD_File_ReaderWriter:XSL_Location"] = Engine_ApplicationCache_Gateway.Settings.Servers.System_Base_URL + "default/sobekcm_default.xsl";

                    reader.Read_Metadata(ead_file_location, Package_To_Finalize, options, out errorMessage);

                    // Clear all existing views
                    Package_To_Finalize.Behaviors.Add_View(View_Enum.EAD_DESCRIPTION);

                    // Get the metadata module for EADs
                    EAD_Info eadInfo = Package_To_Finalize.Get_Metadata_Module(GlobalVar.EAD_METADATA_MODULE_KEY) as EAD_Info;
                    if ((eadInfo != null) && (eadInfo.Container_Hierarchy.Containers.Count > 0))
                        Package_To_Finalize.Behaviors.Add_View(View_Enum.EAD_CONTAINER_LIST);

                }

                //string view_type_of = Package_To_Finalize.Behaviors.Views[0].GetType().ToString();
                //string ufdc_type_of = Package_To_Finalize.Behaviors.Views[0].View_Type.ToString();

                if (unhandledDownload.Count > 0 )
                {
                    Package_To_Finalize.Behaviors.Add_View(View_Enum.DOWNLOADS);
                }

                if (pdf_download == 1)
                {
                    Package_To_Finalize.Behaviors.Add_View(View_Enum.PDF).FileName = pdf_download_url;
                }

                if (video_download > 0)
                {
                    Package_To_Finalize.Behaviors.Add_View(View_Enum.VIDEO);
                }
            }
            else
            {
                if (Package_To_Finalize.Bib_Info.SobekCM_Type == TypeOfResource_SobekCM_Enum.Aerial )
                {
                    Package_To_Finalize.Behaviors.Add_View(View_Enum.DOWNLOADS);
                }
            }

            // If there is a RELATED URL with youtube, add that viewer
            if ((Package_To_Finalize.Bib_Info.hasLocationInformation) && (Package_To_Finalize.Bib_Info.Location.Other_URL.ToLower().IndexOf("www.youtube.com") >= 0))
            {
                View_Object newViewObj = new View_Object(View_Enum.YOUTUBE_VIDEO);
                Package_To_Finalize.Behaviors.Add_View(newViewObj);
            }

            // Look for the HTML type views next, and possible set some defaults
            if ((!Package_To_Finalize.Behaviors.Dark_Flag) && viewsFromDb.ContainsKey(View_Enum.HTML))
            {
                Package_To_Finalize.Behaviors.Add_View(viewsFromDb[View_Enum.HTML]);
                viewsFromDb.Remove(View_Enum.HTML);
            }

            // Copy the TEI flag
            if ((!Package_To_Finalize.Behaviors.Dark_Flag) && viewsFromDb.ContainsKey(View_Enum.TEI))
            {
                Package_To_Finalize.Behaviors.Add_View(viewsFromDb[View_Enum.TEI]);
                viewsFromDb.Remove(View_Enum.TEI);
            }

            // Look to add any index information here ( such as on SANBORN maps)
            Map_Info mapInfo = (Map_Info) Package_To_Finalize.Get_Metadata_Module(GlobalVar.SOBEKCM_MAPS_METADATA_MODULE_KEY);
            if (mapInfo != null)
            {
                //// Were there streets?
                //if (Package_To_Finalize.Map.Streets.Count > 0)
                //{
                //    returnValue.Item_Views.Add(new ViewerFetcher.Streets_ViewerFetcher());
                //}

                //// Were there features?
                //if (Package_To_Finalize.Map.Features.Count > 0)
                //{
                //    returnValue.Item_Views.Add(new ViewerFetcher.Features_ViewerFetcher());
                //}
            }

            // Finally, add all the ITEM VIEWS
            if ((!Package_To_Finalize.Behaviors.Dark_Flag) && (Package_To_Finalize.Web.Pages_By_Sequence != null) && (Package_To_Finalize.Web.Pages_By_Sequence.Count > 0))
            {
                // Look for the RELATED IMAGES view next
                if (viewsFromDb.ContainsKey(View_Enum.RELATED_IMAGES))
                {
                    Package_To_Finalize.Behaviors.Add_View(viewsFromDb[View_Enum.RELATED_IMAGES]);
                    viewsFromDb.Remove(View_Enum.RELATED_IMAGES);
                }

                // Look for the PAGE TURNER view next
                if (viewsFromDb.ContainsKey(View_Enum.PAGE_TURNER))
                {
                    Package_To_Finalize.Behaviors.Add_View(viewsFromDb[View_Enum.PAGE_TURNER]);
                    viewsFromDb.Remove(View_Enum.PAGE_TURNER);
                }

                // Add the individual PAGE VIEWS
                foreach (View_Object thisObject in viewsFromDb.Values)
                {
                    switch (thisObject.View_Type)
                    {
                        case View_Enum.TEXT:
                        case View_Enum.JPEG:
                        case View_Enum.JPEG2000:
                            Package_To_Finalize.Behaviors.Add_Item_Level_Page_View(thisObject);
                            break;
                    }
                }
            }

            // Set the default views for this item
            Tracer.Add_Trace("SobekCM_METS_Based_ItemBuilder.Finish_Building_Item", "Set the default view, if not already assigned");
            Package_To_Finalize.Behaviors.Default_View = null;
            Dictionary<string, View_Object> views_by_view_name = new Dictionary<string, View_Object>();
            foreach (View_Object thisView in Package_To_Finalize.Behaviors.Views)
            {
                if (!views_by_view_name.ContainsKey(thisView.View_Type.ToString()))
                    views_by_view_name[thisView.View_Type.ToString()] = thisView;
            }
            foreach (View_Object thisView in Package_To_Finalize.Behaviors.Item_Level_Page_Views)
            {
                if (!views_by_view_name.ContainsKey(thisView.View_Type.ToString()))
                    views_by_view_name[thisView.View_Type.ToString()] = thisView;
            }

            //If no viewer priorities have been passed in, add the default one
            if (Item_Viewer_Priority == null)
            {
                //TODO: Add default view here if present
               // if (views_by_view_name != null)
               //     Package_To_Finalize.Behaviors.Default_View =
            }
            else
            {
                foreach (string thisViewerType in Item_Viewer_Priority)
                {
                    if (views_by_view_name.ContainsKey(thisViewerType))
                    {
                        Package_To_Finalize.Behaviors.Default_View = views_by_view_name[thisViewerType];
                        break;
                    }
                }
            }

            Tracer.Add_Trace("SobekCM_METS_Based_ItemBuilder.Finish_Building_Item", "Done merging the database information with the resource object");
        }
        /// <summary>Add a new SobekCM View to this resource </summary>
        /// <param name="Index">Index where to insert this view</param>
        /// <param name="View_Type">Standard type of SobekCM View</param>
        /// <returns>Built view object</returns>
        public View_Object Insert_View(int Index, View_Enum View_Type)
        {
            if (View_Type != View_Enum.None)
            {
                if (views == null)
                    views = new List<View_Object>();

                View_Object newView = new View_Object(View_Type, String.Empty, String.Empty);
                views.Insert(Index, newView);
                return newView;
            }
            return null;
        }
        private static List<View_Object> Get_Current_Item_Viewers(string BibID, string VID )
        {
            // Build the parameters list
            List<EalDbParameter> parameters = new List<EalDbParameter>
            {
                new EalDbParameter("@bibid", BibID),
                new EalDbParameter("@vid", VID)
            };

            // Create the database agnostic reader
            EalDbReaderWrapper readerWrapper = EalDbAccess.ExecuteDataReader(DatabaseType, Connection_String, CommandType.StoredProcedure, "SobekCM_Get_Item_Viewers", parameters);

            // Pull out the database reader
            DbDataReader reader = readerWrapper.Reader;

            //Build the return list
            List<View_Object> returnValue = new List<View_Object>();

            // Get all the main title values first
            while (reader.Read())
            {
                string viewType = reader.GetString(0);
                string attributes = reader.GetString(1);
                string label = reader.GetString(2);
                double menuOrder = reader.GetDouble(3);
                bool exclude = reader.GetBoolean(4);

                // Create new database title object for this
                View_Object result = new View_Object
                {
                    View_Type = viewType,
                    Attributes = attributes,
                    Label = label,
                    MenuOrder = (float) menuOrder,
                    Exclude = exclude
                };

                returnValue.Add(result);
            }

            // Close the reader (which also closes the connection)
            readerWrapper.Close();

            return returnValue;
        }
 /// <summary>Add a new SobekCM item-level page view to this resource </summary>
 /// <param name="New_View">SobekCM View object</param>
 public void Add_Item_Level_Page_View(View_Object New_View)
 {
     if (item_level_page_views == null)
         item_level_page_views = new List<View_Object>();
     item_level_page_views.Add(New_View);
 }
        /// <summary>Add a new SobekCM View to this resource </summary>
        /// <param name="View_Type">Standard type of SobekCM View</param>
        /// <param name="Label">Label for this SobekCM View</param>
        /// <param name="FileName">Name of the file</param>
        /// <param name="Attributes">Any additional attribures needed for thie SobekCM View</param>
        /// <returns>Built view object</returns>
        public View_Object Add_View(View_Enum View_Type, string Label, string FileName, string Attributes)
        {
            if (View_Type != View_Enum.None)
            {
                if (views == null)
                    views = new List<View_Object>();

                View_Object newView = new View_Object(View_Type, Label, Attributes) {FileName = FileName};
                views.Add(newView);
                return newView;
            }

            return null;
        }
        /// <summary> Saves the data rendered by this element to the provided bibliographic object during postback </summary>
        /// <param name="Bib"> Object into which to save the user's data, entered into the html rendered by this element </param>
        public override void Save_To_Bib(SobekCM_Item Bib)
        {
            // Build a dictionary of the current views
            Dictionary <string, View_Object> typeToViewObjectDictionary = new Dictionary <string, View_Object>(StringComparer.OrdinalIgnoreCase);

            foreach (View_Object thisView in Bib.Behaviors.Views)
            {
                typeToViewObjectDictionary[thisView.View_Type] = thisView;
            }

            // Clear the viewers
            Bib.Behaviors.Clear_Views();

            // Save each view
            string[] getKeys = HttpContext.Current.Request.Form.AllKeys;
            Dictionary <string, string> addedViewTypes = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);

            foreach (string thisKey in getKeys)
            {
                if (thisKey.IndexOf("viewer_type") == 0)
                {
                    // Get the viewer type
                    //string key = thisKey.Replace("viewer_type", "");
                    string type = HttpContext.Current.Request.Form[thisKey].Trim();

                    // Ensure no other view of this type already exists
                    if (addedViewTypes.ContainsKey(type))
                    {
                        continue;
                    }

                    // Did this type already exist?
                    if (typeToViewObjectDictionary.ContainsKey(type))
                    {
                        // View already exists
                        View_Object addBackView = typeToViewObjectDictionary[type].Copy();
                        addBackView.Exclude = false;
                        Bib.Behaviors.Add_View(addBackView);
                    }
                    else
                    {
                        //string file_key = "viewer_file" + key;
                        //string label_key = "viewer_label" + key;
                        string file  = String.Empty;
                        string label = String.Empty;

                        // A new view type, so add this view
                        Bib.Behaviors.Add_View(type, label, file);
                    }

                    // Since this was added back, put it in the dictionary to avoid multiple views being added
                    // of the same type
                    addedViewTypes[type] = type;

                    //// Get the details information for html and html map
                    //if (type == "HTML")
                    //{
                    //    if (HttpContext.Current.Request.Form[file_key] != null)
                    //    {
                    //        file = HttpContext.Current.Request.Form[file_key].Trim();
                    //    }
                    //    if (HttpContext.Current.Request.Form[label_key] != null)
                    //    {
                    //        label = HttpContext.Current.Request.Form[label_key].Trim();
                    //    }
                    //}
                }
            }

            typeToViewObjectDictionary.Clear();
        }
Example #12
0
        /// <summary> Gets a valid viewer code for this item, based on the requested viewer code and page </summary>
        /// <param name="viewer_code"> Requested viewer code </param>
        /// <param name="page"> Requested page </param>
        /// <returns> Valid viewer code and page </returns>
        /// <remarks> The requested viewer code and page are validated, and if valid, returned.  Otherwise, the closest valid viewer code to the one requested is returned. </remarks>
        public string Get_Valid_Viewer_Code(string viewer_code, int page)
        {
            string lower_code = viewer_code.ToLower();

            // If this is 'RES' for restricted, taht is always valid
            if (viewer_code == "res")
            {
                return("res");
            }

            // Is this in the item level viewer list?
            if (lower_code.Length > 0)
            {
                if (behaviors.Views_Count > 0)
                {
                    foreach (View_Object thisView in behaviors.Views)
                    {
                        foreach (string thisCode in thisView.Viewer_Codes)
                        {
                            if (thisCode.ToLower() == lower_code)
                            {
                                return(lower_code);
                            }
                        }
                    }
                }

                // Check if this is a Related Items page, which also allows paging
                if (lower_code.IndexOf(View_Object.Viewer_Code_By_Type(View_Enum.RELATED_IMAGES)[0]) >= 0)
                {
                    int viewer_page = 0;
                    try
                    {
                        string try_page_get = lower_code.Replace(View_Object.Viewer_Code_By_Type(View_Enum.RELATED_IMAGES)[0], "").Trim();
                        if (try_page_get.Length > 0)
                        {
                            viewer_page = Convert.ToInt32(try_page_get);
                        }
                        return(View_Object.Viewer_Code_By_Type(View_Enum.RELATED_IMAGES)[0]);
                    }
                    catch
                    {
                    }
                }

                // Check if this is the quality conrtols page, which also allows paging
                if (lower_code.IndexOf(View_Object.Viewer_Code_By_Type(View_Enum.QUALITY_CONTROL)[0]) >= 0)
                {
                    int viewer_page = 0;
                    try
                    {
                        string try_page_get = lower_code.Replace(View_Object.Viewer_Code_By_Type(View_Enum.QUALITY_CONTROL)[0], "").Trim();
                        if (try_page_get.Length > 0)
                        {
                            viewer_page = Convert.ToInt32(try_page_get);
                        }
                        return(View_Object.Viewer_Code_By_Type(View_Enum.QUALITY_CONTROL)[0]);
                    }
                    catch
                    {
                    }
                }

                // Check each page
                if (viewer_to_file != null)
                {
                    if (viewer_to_file.ContainsKey(lower_code))
                    {
                        return(lower_code);
                    }
                    else
                    {
                        // TODO: This should not be hardcoded for JPEG, ZOOMABLE, and then TEXT priority. This should come from the item viewer priority table in the database.
                        int testInt;
                        if (Int32.TryParse(lower_code, out testInt))
                        {
                            if (viewer_to_file.ContainsKey(lower_code + "j"))
                            {
                                return(lower_code + "j");
                            }
                            if (viewer_to_file.ContainsKey(lower_code + "x"))
                            {
                                return(lower_code + "x");
                            }
                            if (viewer_to_file.ContainsKey(lower_code + "t"))
                            {
                                return(lower_code + "t");
                            }
                        }
                    }
                }
            }

            // No match, so just return the default, if there is one
            if ((viewer_code.Length == 0) && (behaviors.Default_View != null) && (behaviors.Default_View.Viewer_Codes.Length > 0))
            {
                if (behaviors.Item_Level_Page_Views.Contains(behaviors.Default_View))
                {
                    foreach (SobekCM_File_Info thisFile in pages_by_seq[page - 1].Files)
                    {
                        if (thisFile.Get_Viewer() != null)
                        {
                            if (thisFile.Get_Viewer().View_Type == behaviors.Default_View.View_Type)
                            {
                                return(page.ToString() + thisFile.Get_Viewer().Viewer_Codes[0]);
                            }
                        }
                    }

                    // If no matching item level page view was found matching the view type,
                    // default to any of the item level page views
                    foreach (View_Object itemTaggedView in behaviors.Item_Level_Page_Views)
                    {
                        foreach (SobekCM_File_Info thisFile in pages_by_seq[page - 1].Files)
                        {
                            if (thisFile.Get_Viewer() != null)
                            {
                                if (thisFile.Get_Viewer().View_Type == itemTaggedView.View_Type)
                                {
                                    return(page.ToString() + thisFile.Get_Viewer().Viewer_Codes[0]);
                                }
                            }
                        }
                    }
                }
                else
                {
                    return(behaviors.Default_View.Viewer_Codes[0]);
                }
            }

            // Return first page viewer code
            if ((pages_by_seq != null) && (behaviors.Item_Level_Page_Views_Count > 0) && (pages_by_seq.Count > 0) && (pages_by_seq[0].Files.Count > 0))
            {
                foreach (View_Object itemTaggedView in behaviors.Item_Level_Page_Views)
                {
                    foreach (SobekCM_File_Info thisFile in pages_by_seq[0].Files)
                    {
                        if (thisFile.Get_Viewer() != null)
                        {
                            if (thisFile.Get_Viewer().View_Type == itemTaggedView.View_Type)
                            {
                                return("1" + thisFile.Get_Viewer().Viewer_Codes[0]);
                            }
                        }
                    }
                }
            }

            return(View_Object.Viewer_Code_By_Type(View_Enum.CITATION)[0]);
        }
        /// <summary> Pulls the item id, main thumbnail, and aggregation codes and adds them to the resource object </summary>
        /// <param name="Resource"> Digital resource object </param>
        /// <returns> TRUE if successful, otherwise FALSE </returns>
        /// <remarks> This calls the 'SobekCM_Builder_Get_Minimum_Item_Information' stored procedure </remarks> 
        public static bool Add_Minimum_Builder_Information(SobekCM_Item Resource)
        {
            try
            {
                EalDbParameter[] parameters = new EalDbParameter[2];
                parameters[0] = new EalDbParameter("@bibid", Resource.BibID);
                parameters[1] = new EalDbParameter("@vid", Resource.VID);

                // Define a temporary dataset
                DataSet tempSet = EalDbAccess.ExecuteDataset(DatabaseType, connectionString, CommandType.StoredProcedure, "SobekCM_Builder_Get_Minimum_Item_Information", parameters);

                // If there was no data for this collection and entry point, return null (an ERROR occurred)
                if ((tempSet.Tables.Count == 0) || (tempSet.Tables[0] == null) || (tempSet.Tables[0].Rows.Count == 0))
                {
                    return false;
                }

                // Get the item id and the thumbnail from the first table
                Resource.Web.ItemID = Convert.ToInt32(tempSet.Tables[0].Rows[0][0]);
                Resource.Behaviors.Main_Thumbnail = tempSet.Tables[0].Rows[0][1].ToString();
                Resource.Behaviors.IP_Restriction_Membership = Convert.ToInt16(tempSet.Tables[0].Rows[0][2]);
                Resource.Tracking.Born_Digital = Convert.ToBoolean(tempSet.Tables[0].Rows[0][3]);
                Resource.Web.Siblings = Convert.ToInt32(tempSet.Tables[0].Rows[0][4]) - 1;
                Resource.Behaviors.Dark_Flag = Convert.ToBoolean(tempSet.Tables[0].Rows[0]["Dark"]);

                // Add the aggregation codes
                Resource.Behaviors.Clear_Aggregations();
                foreach( DataRow thisRow in tempSet.Tables[1].Rows )
                {
                    string code = thisRow[0].ToString();
                    Resource.Behaviors.Add_Aggregation(code);
                }

                // Add the icons
                Resource.Behaviors.Clear_Wordmarks();
                foreach (DataRow iconRow in tempSet.Tables[2].Rows)
                {
                    string image = iconRow[0].ToString();
                    string link = iconRow[1].ToString().Replace("&", "&amp;").Replace("\"", "&quot;");
                    string code = iconRow[2].ToString();
                    string name = iconRow[3].ToString();
                    if (name.Length == 0)
                        name = code.Replace("&", "&amp;").Replace("\"", "&quot;");

                    string html;
                    if (link.Length == 0)
                    {
                        html = "<img class=\"SobekItemWordmark\" src=\"<%BASEURL%>design/wordmarks/" + image + "\" title=\"" + name + "\" alt=\"" + name + "\" />";
                    }
                    else
                    {
                        if (link[0] == '?')
                        {
                            html = "<a href=\"" + link + "\"><img class=\"SobekItemWordmark\" src=\"<%BASEURL%>design/wordmarks/" + image + "\" title=\"" + name + "\" alt=\"" + name + "\" /></a>";
                        }
                        else
                        {
                            html = "<a href=\"" + link + "\" target=\"_blank\"><img class=\"SobekItemWordmark\" src=\"<%BASEURL%>design/wordmarks/" + image + "\" title=\"" + name + "\" alt=\"" + name + "\" /></a>";
                        }
                    }

                    Wordmark_Info newIcon = new Wordmark_Info { HTML = html, Link = link, Title = name, Code = code };
                    Resource.Behaviors.Add_Wordmark(newIcon);
                }

                // Add the web skins
                Resource.Behaviors.Clear_Web_Skins();
                foreach (DataRow skinRow in tempSet.Tables[3].Rows)
                {
                    Resource.Behaviors.Add_Web_Skin(skinRow[0].ToString().ToUpper());
                }

                // Add the views
                Resource.Behaviors.Clear_Views();
                foreach (DataRow viewRow in tempSet.Tables[4].Rows)
                {
                    string viewType = viewRow[0].ToString();
                    string attributes = viewRow[1].ToString();
                    string label = viewRow[2].ToString();
                    double menuOrder = Double.Parse(viewRow[3].ToString());
                    bool exclude = Boolean.Parse(viewRow[4].ToString());

                    // Create new database title object for this
                    View_Object result = new View_Object
                    {
                        View_Type = viewType,
                        Attributes = attributes,
                        Label = label,
                        MenuOrder = (float)menuOrder,
                        Exclude = exclude
                    };

                    Resource.Behaviors.Add_View(result);
                }

                // Return the first table from the returned dataset
                return true;
            }
            catch (Exception ee)
            {
                lastException = ee;
                return false;
            }
        }
        /// <summary>Add a new SobekCM View to this resource </summary>
        /// <param name="Index">Index where to insert this view</param>
        /// <param name="View_Type">Standard type of SobekCM View</param>
        /// <param name="Label">Label for this SobekCM View</param>
        /// <param name="Attributes">Any additional attribures needed for thie SobekCM View</param>
        /// <returns>Built view object</returns>
        public View_Object Insert_View(int Index, string View_Type, string Label, string Attributes)
        {
            if (!String.IsNullOrEmpty(View_Type))
            {
                if (Views == null)
                    Views = new List<View_Object>();

                View_Object newView = new View_Object(View_Type, Label, Attributes);
                Views.Insert(Index, newView);
                return newView;
            }

            return null;
        }
        /// <summary>Add a new SobekCM View to this resource </summary>
        /// <param name="Index">Index where to insert this view</param>
        /// <param name="View_Type">Standard type of SobekCM View</param>
        /// <param name="Label">Label for this SobekCM View</param>
        /// <param name="Attributes">Any additional attribures needed for thie SobekCM View</param>
        /// <returns>Built view object</returns>
        public View_Object Insert_View(int Index, View_Enum View_Type, string Label, string Attributes)
        {
            if (View_Type != View_Enum.None)
            {
                if (views == null)
                    views = new List<View_Object>();

                View_Object newView = new View_Object(View_Type, Label, Attributes);
                views.Insert(Index, newView);
                return newView;
            }

            return null;
        }
        /// <summary> Accepts a simple <see cref="View_Object"/> from the digital resource object and returns
        /// the appropriate item viewer object which extends the <see cref="SobekCM.Library.ItemViewer.Viewers.abstractItemViewer"/>
        /// class for rendering the item to the web via HTML.</summary>
        /// <param name="ViewObject"> View object from the digital resource object </param>
        /// <param name="Resource_Type">Resource type often impacts how an item viewer renders</param>
        /// <param name="Current_Object">Current resource object </param>
        /// <param name="Current_User">Currently session's user </param>
        /// <param name="Current_Mode"> Navigation object with all the information about the current request </param>
        /// <returns> Genereated item viewer class for rendering the particular view of a digital resource
        /// via HTML. </returns>
        public static abstractItemViewer Get_Viewer(View_Object ViewObject, string Resource_Type, SobekCM_Item Current_Object, User_Object Current_User, Navigation_Object Current_Mode )
        {
            switch (ViewObject.View_Type)
            {
                case View_Enum.ALL_VOLUMES:
                    return new MultiVolumes_ItemViewer();

                case View_Enum.CITATION:
                    return new Citation_ItemViewer();

                case View_Enum.DOWNLOADS:
                    return new Download_ItemViewer();

                case View_Enum.DATASET_CODEBOOK:
                    return new Dataset_CodeBook_ItemViewer();

                case View_Enum.DATASET_REPORTS:
                    return new Dataset_Reports_ItemViewer();

                case View_Enum.DATASET_VIEWDATA:
                    return new Dataset_ViewData_ItemViewer();

                case View_Enum.EAD_DESCRIPTION:
                    return new EAD_Description_ItemViewer();

                case View_Enum.EAD_CONTAINER_LIST:
                    return new EAD_Container_List_ItemViewer();

                case View_Enum.EMBEDDED_VIDEO:
                    return new EmbeddedVideo_ItemViewer();

                case View_Enum.FEATURES:
                    return new Feature_ItemViewer();

                case View_Enum.FLASH:
                    return new Flash_ItemViewer(ViewObject.Label, 0);

                case View_Enum.GOOGLE_COORDINATE_ENTRY:
                    return new Google_Coordinate_Entry_ItemViewer(Current_User, Current_Object, Current_Mode);

                case View_Enum.GOOGLE_MAP:
                    return new Google_Map_ItemViewer();

                case View_Enum.GOOGLE_MAP_BETA:
                    return new Google_Map_ItemViewer_Beta();

                case View_Enum.HTML:
                    return new HTML_ItemViewer(ViewObject.Attributes, ViewObject.Label);

                case View_Enum.JPEG:
                    abstractItemViewer jpegViewer = new JPEG_ItemViewer( ViewObject.Attributes );
                    jpegViewer.FileName = ViewObject.FileName;
                    return jpegViewer;

                case View_Enum.JPEG_TEXT_TWO_UP:
                    abstractItemViewer jpegTextViewer = new JPEG_Text_Two_Up_ItemViewer(ViewObject.Attributes);
                    jpegTextViewer.FileName = ViewObject.FileName;
                    return jpegTextViewer;

                case View_Enum.JPEG2000:
                    if ( UI_ApplicationCache_Gateway.Settings.Servers.JP2ServerType == "Built-In IIPImage")
                    {
                        abstractItemViewer newJp2Viewer = new JPEG2000_ItemViewer();
                        newJp2Viewer.FileName = ViewObject.FileName;
                        return newJp2Viewer;
                    }
                    return null;

                case View_Enum.MANAGE:
                    return new ManageMenu_ItemViewer(Current_Object, Current_User, Current_Mode);

                case View_Enum.PAGE_TURNER:
                        return new GnuBooks_PageTurner_ItemViewer();

                case View_Enum.PDF:
                        return new PDF_ItemViewer(ViewObject.FileName, Current_Mode);

                case View_Enum.QUALITY_CONTROL:
                        return new QC_ItemViewer(Current_Object, Current_User, Current_Mode);

                case View_Enum.RELATED_IMAGES:
                    return new Related_Images_ItemViewer();

                case View_Enum.SEARCH:
                    return new Text_Search_ItemViewer();

                case View_Enum.STREETS:
                    return new Street_ItemViewer();

                case View_Enum.TEST:
                    return new Test_ItemViewer();

                case View_Enum.TEXT:
                    abstractItemViewer textViewer = new Text_ItemViewer();
                    textViewer.FileName = ViewObject.FileName;
                    return textViewer;

                case View_Enum.TOC:
                    return new TOC_ItemViewer();

                case View_Enum.TRACKING:
                    return new Tracking_ItemViewer();

                case View_Enum.TRACKING_SHEET:
                    return new TrackingSheet_ItemViewer(Current_Object, Current_User, Current_Mode);

                case View_Enum.YOUTUBE_VIDEO:
                    return new YouTube_Embedded_Video_ItemViewer();

                case View_Enum.VIDEO:
                    return new Video_ItemViewer(Current_Object);

            }

            return null;
        }
        private void Finish_Building_Item(SobekCM_Item thisPackage, DataSet databaseInfo, bool multiple)
        {
            // Copy over some basic values
            DataRow mainItemRow = databaseInfo.Tables[2].Rows[0];
            thisPackage.Behaviors.Set_Primary_Identifier(mainItemRow["Primary_Identifier_Type"].ToString(), mainItemRow["Primary_Identifier"].ToString());
            thisPackage.Behaviors.GroupTitle = mainItemRow["GroupTitle"].ToString();
            thisPackage.Web.File_Root = mainItemRow["File_Location"].ToString();
            thisPackage.Web.AssocFilePath = mainItemRow["File_Location"] + "\\" + thisPackage.VID + "\\";
            thisPackage.Behaviors.IP_Restriction_Membership = Convert.ToInt16(mainItemRow["IP_Restriction_Mask"]);
            thisPackage.Behaviors.CheckOut_Required = Convert.ToBoolean(mainItemRow["CheckoutRequired"]);
            thisPackage.Behaviors.Text_Searchable = Convert.ToBoolean(mainItemRow["TextSearchable"]);
            thisPackage.Web.ItemID = Convert.ToInt32(mainItemRow["ItemID"]);
            thisPackage.Web.GroupID = Convert.ToInt32(mainItemRow["GroupID"]);
            thisPackage.Behaviors.Suppress_Endeca = Convert.ToBoolean(mainItemRow["SuppressEndeca"]);
            //thisPackage.Behaviors.Expose_Full_Text_For_Harvesting = Convert.ToBoolean(mainItemRow["SuppressEndeca"]);
            thisPackage.Tracking.Internal_Comments = mainItemRow["Comments"].ToString();
            thisPackage.Behaviors.Dark_Flag = Convert.ToBoolean(mainItemRow["Dark"]);
            thisPackage.Tracking.Born_Digital = Convert.ToBoolean(mainItemRow["Born_Digital"]);
            //thisPackage.Divisions.Page_Count = Convert.ToInt32(mainItemRow["Pages"]);
            if (mainItemRow["Disposition_Advice"] != DBNull.Value)
                thisPackage.Tracking.Disposition_Advice = Convert.ToInt16(mainItemRow["Disposition_Advice"]);
            else
                thisPackage.Tracking.Disposition_Advice = -1;
            if (mainItemRow["Material_Received_Date"] != DBNull.Value)
                thisPackage.Tracking.Material_Received_Date = Convert.ToDateTime(mainItemRow["Material_Received_Date"]);
            else
                thisPackage.Tracking.Material_Received_Date = null;
            if (mainItemRow["Material_Recd_Date_Estimated"] != DBNull.Value)
                thisPackage.Tracking.Material_Rec_Date_Estimated = Convert.ToBoolean(mainItemRow["Material_Recd_Date_Estimated"]);
            if (databaseInfo.Tables[2].Columns.Contains("Tracking_Box"))
            {
                if (mainItemRow["Tracking_Box"] != DBNull.Value)
                    thisPackage.Tracking.Tracking_Box= mainItemRow["Tracking_Box"].ToString();
            }

            // Set more of the sobekcm web portions in the item
            thisPackage.Web.Set_BibID_VID(thisPackage.BibID, thisPackage.VID);
            thisPackage.Web.Image_Root = SobekCM_Library_Settings.Image_URL;
            if (multiple)
                thisPackage.Web.Siblings = 2;

            // Set the serial hierarchy from the database (if multiple)
            if ((multiple) && (mainItemRow["Level1_Text"].ToString().Length > 0))
            {
                bool found = false;

                // Get the values from the database first
                string level1_text = mainItemRow["Level1_Text"].ToString();
                string level2_text = mainItemRow["Level2_Text"].ToString();
                string level3_text = mainItemRow["Level3_Text"].ToString();
                int level1_index = Convert.ToInt32(mainItemRow["Level1_Index"]);
                int level2_index = Convert.ToInt32(mainItemRow["Level2_Index"]);
                int level3_index = Convert.ToInt32(mainItemRow["Level3_Index"]);

                // Does this match the enumeration
                if (level1_text.ToUpper().Trim() == thisPackage.Bib_Info.Series_Part_Info.Enum1.ToUpper().Trim())
                {
                    // Copy the database values to the enumeration portion
                    thisPackage.Bib_Info.Series_Part_Info.Enum1 = level1_text;
                    thisPackage.Bib_Info.Series_Part_Info.Enum1_Index = level1_index;
                    thisPackage.Bib_Info.Series_Part_Info.Enum2 = level2_text;
                    thisPackage.Bib_Info.Series_Part_Info.Enum2_Index = level2_index;
                    thisPackage.Bib_Info.Series_Part_Info.Enum3 = level3_text;
                    thisPackage.Bib_Info.Series_Part_Info.Enum3_Index = level3_index;
                    found = true;
                }

                // Does this match the chronology
                if ((!found) && (level1_text.ToUpper().Trim() == thisPackage.Bib_Info.Series_Part_Info.Year.ToUpper().Trim()))
                {
                    // Copy the database values to the chronology portion
                    thisPackage.Bib_Info.Series_Part_Info.Year = level1_text;
                    thisPackage.Bib_Info.Series_Part_Info.Year_Index = level1_index;
                    thisPackage.Bib_Info.Series_Part_Info.Month = level2_text;
                    thisPackage.Bib_Info.Series_Part_Info.Month_Index = level2_index;
                    thisPackage.Bib_Info.Series_Part_Info.Day = level3_text;
                    thisPackage.Bib_Info.Series_Part_Info.Day_Index = level3_index;
                    found = true;
                }

                if (!found)
                {
                    // No match.  If it is numeric, move it to the chronology, otherwise, enumeration
                    bool charFound = level1_text.Trim().Any(thisChar => !Char.IsNumber(thisChar));

                    if (charFound)
                    {
                        // Copy the database values to the enumeration portion
                        thisPackage.Bib_Info.Series_Part_Info.Enum1 = level1_text;
                        thisPackage.Bib_Info.Series_Part_Info.Enum1_Index = level1_index;
                        thisPackage.Bib_Info.Series_Part_Info.Enum2 = level2_text;
                        thisPackage.Bib_Info.Series_Part_Info.Enum2_Index = level2_index;
                        thisPackage.Bib_Info.Series_Part_Info.Enum3 = level3_text;
                        thisPackage.Bib_Info.Series_Part_Info.Enum3_Index = level3_index;
                    }
                    else
                    {
                        // Copy the database values to the chronology portion
                        thisPackage.Bib_Info.Series_Part_Info.Year = level1_text;
                        thisPackage.Bib_Info.Series_Part_Info.Year_Index = level1_index;
                        thisPackage.Bib_Info.Series_Part_Info.Month = level2_text;
                        thisPackage.Bib_Info.Series_Part_Info.Month_Index = level2_index;
                        thisPackage.Bib_Info.Series_Part_Info.Day = level3_text;
                        thisPackage.Bib_Info.Series_Part_Info.Day_Index = level3_index;
                    }
                }

                // Copy the database values to the simple serial portion (used to actually determine serial heirarchy)
                thisPackage.Behaviors.Serial_Info.Clear();
                thisPackage.Behaviors.Serial_Info.Add_Hierarchy(1, level1_index, level1_text);
                if (level2_text.Length > 0)
                {
                    thisPackage.Behaviors.Serial_Info.Add_Hierarchy(2, level2_index, level2_text);
                    if (level3_text.Length > 0)
                    {
                        thisPackage.Behaviors.Serial_Info.Add_Hierarchy(3, level3_index, level3_text);
                    }
                }
            }

            // See if this can be described
            bool can_describe = false;
            foreach (DataRow thisRow in databaseInfo.Tables[1].Rows)
            {
                int thisAggregationValue = Convert.ToInt16(thisRow["Items_Can_Be_Described"]);
                if (thisAggregationValue == 0)
                {
                    can_describe = false;
                    break;
                }
                if (thisAggregationValue == 2)
                {
                    can_describe = true;
                }
            }
            thisPackage.Behaviors.Can_Be_Described = can_describe;

            // Look for user descriptions
            foreach (DataRow thisRow in databaseInfo.Tables[0].Rows)
            {
                string first_name = thisRow["FirstName"].ToString();
                string nick_name = thisRow["NickName"].ToString();
                string last_name = thisRow["LastName"].ToString();
                int userid = Convert.ToInt32(thisRow["UserID"]);
                string tag = thisRow["Description_Tag"].ToString();
                int tagid = Convert.ToInt32(thisRow["TagID"]);
                DateTime dateAdded = Convert.ToDateTime(thisRow["Date_Modified"]);

                if (nick_name.Length > 0)
                {
                    thisPackage.Behaviors.Add_User_Tag(userid, nick_name + " " + last_name, tag, dateAdded, tagid);
                }
                else
                {
                    thisPackage.Behaviors.Add_User_Tag(userid, first_name + " " + last_name, tag, dateAdded, tagid);
                }
            }

            // Look for ticklers
            foreach (DataRow thisRow in databaseInfo.Tables[3].Rows)
            {
                thisPackage.Behaviors.Add_Tickler(thisRow["MetadataValue"].ToString().Trim());
            }

            // Set the aggregations in the package to the aggregation links from the database
            thisPackage.Behaviors.Clear_Aggregations();
            foreach (DataRow thisRow in databaseInfo.Tables[1].Rows)
            {
                if (!Convert.ToBoolean(thisRow["impliedLink"]))
                {
                    thisPackage.Behaviors.Add_Aggregation(thisRow["Code"].ToString());
                }
            }

            // If no collections, add some regardless of whether it was IMPLIED
            if ( thisPackage.Behaviors.Aggregation_Count == 0)
            {
                foreach (DataRow thisRow in databaseInfo.Tables[1].Rows)
                {
                    if (thisRow["Type"].ToString().ToUpper() == "COLLECTION")
                        thisPackage.Behaviors.Add_Aggregation(thisRow["Code"].ToString());
                }
            }

            // Step through each page and set the static page count
            pageseq = 0;
            List<Page_TreeNode> pages_encountered = new List<Page_TreeNode>();
            foreach (abstract_TreeNode rootNode in thisPackage.Divisions.Physical_Tree.Roots)
            {
                recurse_through_nodes(thisPackage, rootNode, pages_encountered);
            }
            thisPackage.Web.Static_PageCount = pages_encountered.Count;
            thisPackage.Web.Static_Division_Count = divseq;

            // Make sure no icons were retained from the METS file itself
            thisPackage.Behaviors.Clear_Wordmarks();

            // Add the icons from the database information
            foreach (DataRow iconRow in databaseInfo.Tables[5].Rows)
            {
                string image = iconRow[0].ToString();
                string link = iconRow[1].ToString().Replace("&", "&amp;").Replace("\"", "&quot;");
                string code = iconRow[2].ToString();
                string name = code.Replace("&", "&amp;").Replace("\"", "&quot;");

                string html;
                if (link.Length == 0)
                {
                    html = "<img class=\"SobekItemWordmark\" src=\"<%BASEURL%>design/wordmarks/" + image + "\" title=\"" + name + "\" alt=\"" + name + "\" />";
                }
                else
                {
                    if (link[0] == '?')
                    {
                        html = "<a href=\"" + link + "\"><img class=\"SobekItemWordmark\" src=\"<%BASEURL%>design/wordmarks/" + image + "\" title=\"" + name + "\" alt=\"" + name + "\" /></a>";
                    }
                    else
                    {
                        html = "<a href=\"" + link + "\" target=\"_blank\"><img class=\"SobekItemWordmark\" src=\"<%BASEURL%>design/wordmarks/" + image + "\" title=\"" + name + "\" alt=\"" + name + "\" /></a>";
                    }
                }

                Wordmark_Info newIcon = new Wordmark_Info {HTML = html, Link = link, Title = name, Code = code};
                thisPackage.Behaviors.Add_Wordmark(newIcon);
            }

            // Make sure no web skins were retained from the METS file itself
            thisPackage.Behaviors.Clear_Web_Skins();

            // Add the web skins from the database
            foreach (DataRow skinRow in databaseInfo.Tables[6].Rows)
            {
                thisPackage.Behaviors.Add_Web_Skin(skinRow[0].ToString().ToUpper());
            }

            // Make sure no views were retained from the METS file itself
            thisPackage.Behaviors.Clear_Views();

            // If this has more than 1 sibling (this count includes itself), add the multi-volumes viewer
            if (multiple)
            {
                thisPackage.Behaviors.Add_View(View_Enum.ALL_VOLUMES, String.Empty, thisPackage.Bib_Info.SobekCM_Type_String);
            }

            // Add the full citation view and the (hidden) tracking view
            thisPackage.Behaviors.Add_View(View_Enum.CITATION);
            thisPackage.Behaviors.Add_View(View_Enum.TRACKING);

            // Add the full text
            if ( thisPackage.Behaviors.Text_Searchable )
                thisPackage.Behaviors.Add_View(View_Enum.SEARCH);

            // Is there an embedded video?
            if (thisPackage.Behaviors.Embedded_Video.Length > 0)
                thisPackage.Behaviors.Add_View(View_Enum.EMBEDDED_VIDEO);

            // If there is no PURL, add one based on how SobekCM operates
            if (thisPackage.Bib_Info.Location.PURL.Length == 0)
            {
                thisPackage.Bib_Info.Location.PURL = SobekCM_Library_Settings.System_Base_URL + thisPackage.BibID + "/" + thisPackage.VID;

            }

            // IF this is dark, add no other views
            if (!thisPackage.Behaviors.Dark_Flag)
            {
                // Check to see which views were present from the database, and build the list
                Dictionary<View_Enum, View_Object> viewsFromDb = new Dictionary<View_Enum, View_Object>();
                foreach (DataRow viewRow in databaseInfo.Tables[4].Rows)
                {
                    string viewType = viewRow[0].ToString();
                    string attribute = viewRow[1].ToString();
                    string label = viewRow[2].ToString();

                    View_Enum viewTypeEnum = View_Enum.None;
                    switch (viewType)
                    {
                        case "JPEG":
                            viewTypeEnum = View_Enum.JPEG;
                            break;

                        case "JPEG2000":
                            viewTypeEnum = View_Enum.JPEG2000;
                            break;

                        case "Text":
                            viewTypeEnum = View_Enum.TEXT;
                            break;

                        case "Page Turner":
                            viewTypeEnum = View_Enum.PAGE_TURNER;
                            break;

                        case "Google Map":
                            viewTypeEnum = View_Enum.GOOGLE_MAP;
                            break;

                        case "HTML Viewer":
                            viewTypeEnum = View_Enum.HTML;
                            break;

                        case "HTML Map Viewer":
                            viewTypeEnum = View_Enum.HTML_MAP;
                            break;

                        case "Related Images":
                            viewTypeEnum = View_Enum.RELATED_IMAGES;
                            break;

                        case "TOC":
                            viewTypeEnum = View_Enum.TOC;
                            break;

                        case "TEI":
                            viewTypeEnum = View_Enum.TEI;
                            break;
                    }

                    if (viewTypeEnum != View_Enum.None)
                    {
                        viewsFromDb[viewTypeEnum] = new View_Object(viewTypeEnum, label, attribute);
                    }
                }

                // Add the thumbnail view, if requested and has multiple pages
                if (thisPackage.Divisions.Page_Count > 1)
                {
                    if (viewsFromDb.ContainsKey(View_Enum.RELATED_IMAGES))
                    {
                        thisPackage.Behaviors.Add_View(viewsFromDb[View_Enum.RELATED_IMAGES]);
                        viewsFromDb.Remove(View_Enum.RELATED_IMAGES);
                    }

                    thisPackage.Behaviors.Add_View(View_Enum.QUALITY_CONTROL);
                }
                else
                {
                    if (viewsFromDb.ContainsKey(View_Enum.RELATED_IMAGES))
                    {
                        viewsFromDb.Remove(View_Enum.RELATED_IMAGES);
                    }
                }

                // If this item has more than one division, look for the TOC viewer
                if ((thisPackage.Divisions.Has_Multiple_Divisions) && (!thisPackage.Bib_Info.ImageClass))
                {
                    if (viewsFromDb.ContainsKey(View_Enum.TOC))
                    {
                        thisPackage.Behaviors.Add_View(viewsFromDb[View_Enum.TOC]);
                        viewsFromDb.Remove(View_Enum.TOC);
                    }
                }

                // In addition, if there is a latitude or longitude listed, look for the Google Maps
                bool hasCoords = false;
                GeoSpatial_Information geoInfo = (GeoSpatial_Information) thisPackage.Get_Metadata_Module(GlobalVar.GEOSPATIAL_METADATA_MODULE_KEY);
                if (( geoInfo != null ) && ( geoInfo.hasData ))
                {
                    if ((geoInfo.Point_Count > 0) || (geoInfo.Polygon_Count > 0))
                    {
                        hasCoords = true;
                    }
                }
                if (!hasCoords)
                {
                    List<abstract_TreeNode> pageList = thisPackage.Divisions.Physical_Tree.Pages_PreOrder;
                    foreach (abstract_TreeNode thisPage in pageList)
                    {
                        GeoSpatial_Information geoInfo2 = (GeoSpatial_Information) thisPage.Get_Metadata_Module(GlobalVar.GEOSPATIAL_METADATA_MODULE_KEY);
                        if ((geoInfo2 != null) && (geoInfo2.hasData))
                        {
                            if ((geoInfo2.Point_Count > 0) || (geoInfo2.Polygon_Count > 0))
                            {
                                hasCoords = true;
                                break;
                            }
                        }
                    }
                }

                if (hasCoords)
                {
                    if (viewsFromDb.ContainsKey(View_Enum.GOOGLE_MAP))
                    {
                        thisPackage.Behaviors.Add_View(viewsFromDb[View_Enum.GOOGLE_MAP]);
                        viewsFromDb.Remove(View_Enum.GOOGLE_MAP);
                    }
                    else
                    {
                        thisPackage.Behaviors.Add_View(View_Enum.GOOGLE_MAP);
                    }
                }

                // Step through each download and make sure it is fully built
                if (thisPackage.Divisions.Download_Tree.Has_Files)
                {
                    string ead_file = String.Empty;
                    int pdf_download = 0;
                    string pdf_download_url = String.Empty;
                    int non_flash_downloads = 0;
                    List<abstract_TreeNode> downloadPages = thisPackage.Divisions.Download_Tree.Pages_PreOrder;
                    foreach (Page_TreeNode downloadPage in downloadPages)
                    {
                        // Was this an EAD page?
                        if ((downloadPage.Label == GlobalVar.EAD_METADATA_MODULE_KEY) && (downloadPage.Files.Count == 1))
                        {
                            ead_file = downloadPage.Files[0].System_Name;
                        }

                        // Was this an XSL/EAD page?
                        if ((downloadPage.Label == "XSL") && (downloadPage.Files.Count == 1))
                        {
                        }

                        // Step through each download file
                        foreach (SobekCM_File_Info thisFile in downloadPage.Files)
                        {
                            if (thisFile.File_Extension == "SWF")
                            {
                                string flashlabel = downloadPage.Label;
                                View_Object newView = thisPackage.Behaviors.Add_View(View_Enum.FLASH, flashlabel, String.Empty, thisFile.System_Name);
                                thisPackage.Behaviors.Default_View = newView;
                            }
                            else
                            {
                                non_flash_downloads++;
                            }

                            if (thisFile.File_Extension == "PDF")
                            {
                                pdf_download++;
                                pdf_download_url = thisFile.System_Name;
                            }
                        }
                    }

                    if (((non_flash_downloads > 0) && (pdf_download != 1)) || ((non_flash_downloads > 1) && (pdf_download == 1)))
                    {

                        if (thisPackage.Web.Static_PageCount == 0)
                            thisPackage.Behaviors.Default_View = thisPackage.Behaviors.Add_View(View_Enum.DOWNLOADS);
                        else
                            thisPackage.Behaviors.Add_View(View_Enum.DOWNLOADS);
                    }

                    if (pdf_download == 1)
                    {
                        if ((thisPackage.Web.Static_PageCount == 0) && ( thisPackage.Behaviors.Default_View == null ))
                        {
                            thisPackage.Behaviors.Default_View = thisPackage.Behaviors.Add_View(View_Enum.PDF);
                            thisPackage.Behaviors.Default_View.FileName = pdf_download_url;
                        }
                        else
                        {
                            thisPackage.Behaviors.Add_View(View_Enum.PDF).FileName = pdf_download_url;
                        }
                    }

                    // Some special code for EAD objects
                    if ((thisPackage.Bib_Info.SobekCM_Type == TypeOfResource_SobekCM_Enum.Archival ) && (ead_file.Length > 0))
                    {
                        // Now, read this EAD file information
                        string ead_file_location = SobekCM_Library_Settings.Image_Server_Network + thisPackage.Web.AssocFilePath + ead_file;
                        EAD_File_ReaderWriter reader = new EAD_File_ReaderWriter();
                        string Error_Message;
                        Dictionary<string, object> options = new Dictionary<string, object>();
                        options["EAD_File_ReaderWriter:XSL_Location"] = SobekCM_Library_Settings.System_Base_URL + "default/sobekcm_default.xsl";
                        reader.Read_Metadata(ead_file_location, thisPackage, options, out Error_Message);

                        // Clear all existing views
                        thisPackage.Behaviors.Clear_Views();
                        thisPackage.Behaviors.Add_View(View_Enum.CITATION);
                        thisPackage.Behaviors.Default_View = thisPackage.Behaviors.Add_View(View_Enum.EAD_DESCRIPTION);

                        // Get the metadata module for EADs
                        EAD_Info eadInfo = (EAD_Info)thisPackage.Get_Metadata_Module(GlobalVar.EAD_METADATA_MODULE_KEY);
                        if (( eadInfo != null ) && ( eadInfo.Container_Hierarchy.Containers.Count > 0 ))
                            thisPackage.Behaviors.Add_View(View_Enum.EAD_CONTAINER_LIST);

                    }
                }
                else
                {
                    if (thisPackage.Bib_Info.SobekCM_Type == TypeOfResource_SobekCM_Enum.Aerial )
                    {
                        thisPackage.Behaviors.Add_View(View_Enum.DOWNLOADS);
                    }
                }

                // If there is a RELATED URL with youtube, add that viewer
                if ((thisPackage.Bib_Info.hasLocationInformation) && (thisPackage.Bib_Info.Location.Other_URL.ToLower().IndexOf("www.youtube.com") >= 0))
                {
                    View_Object newViewObj = new View_Object(View_Enum.YOUTUBE_VIDEO);
                    thisPackage.Behaviors.Add_View(newViewObj);
                    thisPackage.Behaviors.Default_View = newViewObj;
                }

                // Look for the HTML type views next, and possible set some defaults
                if (viewsFromDb.ContainsKey(View_Enum.HTML))
                {
                    thisPackage.Behaviors.Add_View(viewsFromDb[View_Enum.HTML]);
                    thisPackage.Behaviors.Default_View = viewsFromDb[View_Enum.HTML];
                    viewsFromDb.Remove(View_Enum.HTML);
                }

                // Look for the HTML MAP type views next, and possible set some defaults
                if (viewsFromDb.ContainsKey(View_Enum.HTML_MAP))
                {
                    thisPackage.Behaviors.Add_View(viewsFromDb[View_Enum.HTML_MAP]);
                    thisPackage.Behaviors.Default_View = viewsFromDb[View_Enum.HTML_MAP];
                    viewsFromDb.Remove(View_Enum.HTML_MAP);
                }

                // Copy the TEI flag
                if (viewsFromDb.ContainsKey(View_Enum.TEI))
                {
                    thisPackage.Behaviors.Add_View(viewsFromDb[View_Enum.TEI]);
                    viewsFromDb.Remove(View_Enum.HTML);
                }

                // Look to add any index information here ( such as on SANBORN maps)
                Map_Info mapInfo = (Map_Info) thisPackage.Get_Metadata_Module(GlobalVar.SOBEKCM_MAPS_METADATA_MODULE_KEY);
                if (mapInfo != null)
                {
                    // Was there a HTML map here?
                    if (mapInfo.Index_Count > 0)
                    {
                        Map_Index thisIndex = mapInfo.Get_Index(0);
                        View_Object newMapSanbView = thisPackage.Behaviors.Add_View(View_Enum.HTML_MAP, thisIndex.Title, thisIndex.Image_File + ";" + thisIndex.HTML_File);
                        thisPackage.Behaviors.Default_View = newMapSanbView;
                    }

                    //// Were there streets?
                    //if (thisPackage.Map.Streets.Count > 0)
                    //{
                    //    returnValue.Item_Views.Add(new ViewerFetcher.Streets_ViewerFetcher());
                    //}

                    //// Were there features?
                    //if (thisPackage.Map.Features.Count > 0)
                    //{
                    //    returnValue.Item_Views.Add(new ViewerFetcher.Features_ViewerFetcher());
                    //}
                }

                // Look for the RELATED IMAGES view next
                if (viewsFromDb.ContainsKey(View_Enum.RELATED_IMAGES))
                {
                    thisPackage.Behaviors.Add_View(viewsFromDb[View_Enum.RELATED_IMAGES]);
                    viewsFromDb.Remove(View_Enum.RELATED_IMAGES);
                }

                // Look for the PAGE TURNER view next
                if (viewsFromDb.ContainsKey(View_Enum.PAGE_TURNER))
                {
                    thisPackage.Behaviors.Add_View(viewsFromDb[View_Enum.PAGE_TURNER]);
                    viewsFromDb.Remove(View_Enum.PAGE_TURNER);
                }

                // Finally, add all the ITEM VIEWS
                foreach (View_Object thisObject in viewsFromDb.Values)
                {
                    switch (thisObject.View_Type)
                    {
                        case View_Enum.TEXT:
                        case View_Enum.JPEG:
                        case View_Enum.JPEG2000:
                            thisPackage.Behaviors.Add_Item_Level_Page_View(thisObject);
                            break;
                    }
                }
            }
        }
Example #18
0
        /// <summary> Gets a valid viewer code for this item, based on the requested viewer code and page </summary>
        /// <param name="viewer_code"> Requested viewer code </param>
        /// <param name="page"> Requested page </param>
        /// <returns> Valid viewer code and page </returns>
        /// <remarks> The requested viewer code and page are validated, and if valid, returned.  Otherwise, the closest valid viewer code to the one requested is returned. </remarks>
        public string Get_Valid_Viewer_Code(string viewer_code, int page)
        {
            string lower_code = viewer_code.ToLower();

            // If this is 'RES' for restricted, taht is always valid
            if (viewer_code == "res")
            {
                return("res");
            }

            // Is this in the item level viewer list?
            if (lower_code.Length > 0)
            {
                if (behaviors.Views_Count > 0)
                {
                    foreach (View_Object thisView in behaviors.Views)
                    {
                        foreach (string thisCode in thisView.Viewer_Codes)
                        {
                            if (thisCode.ToLower() == lower_code)
                            {
                                return(lower_code);
                            }
                        }
                    }
                }

                // Check if this is a Related Items page, which also allows paging
                if (lower_code.IndexOf(View_Object.Viewer_Code_By_Type(View_Enum.RELATED_IMAGES)[0]) >= 0)
                {
                    int viewer_page = 0;
                    try
                    {
                        string try_page_get = lower_code.Replace(View_Object.Viewer_Code_By_Type(View_Enum.RELATED_IMAGES)[0], "").Trim();
                        if (try_page_get.Length > 0)
                        {
                            viewer_page = Convert.ToInt32(try_page_get);
                        }
                        return(View_Object.Viewer_Code_By_Type(View_Enum.RELATED_IMAGES)[0]);
                    }
                    catch
                    {
                    }
                }

                // Check if this is the quality conrtols page, which also allows paging
                if (lower_code.IndexOf(View_Object.Viewer_Code_By_Type(View_Enum.QUALITY_CONTROL)[0]) >= 0)
                {
                    int viewer_page = 0;
                    try
                    {
                        string try_page_get = lower_code.Replace(View_Object.Viewer_Code_By_Type(View_Enum.QUALITY_CONTROL)[0], "").Trim();
                        if (try_page_get.Length > 0)
                        {
                            viewer_page = Convert.ToInt32(try_page_get);
                        }
                        return(View_Object.Viewer_Code_By_Type(View_Enum.QUALITY_CONTROL)[0]);
                    }
                    catch
                    {
                    }
                }

                // Check each page
                if (viewer_to_file != null)
                {
                    if (viewer_to_file.ContainsKey(lower_code))
                    {
                        return(lower_code);
                    }
                }
            }

            // No match, so just return the default, if there is one
            if ((viewer_code.Length == 0) && (behaviors.Default_View != null) && (behaviors.Default_View.Viewer_Codes.Length > 0))
            {
                return(behaviors.Default_View.Viewer_Codes[0]);
            }

            // If embedded video is present, show that.
            if (behaviors.Views_Count > 0)
            {
                foreach (View_Object thisView in behaviors.Views)
                {
                    if (thisView.View_Type == View_Enum.YOUTUBE_VIDEO)
                    {
                        return(thisView.Viewer_Codes[0]);
                    }
                    if (thisView.View_Type == View_Enum.EMBEDDED_VIDEO)
                    {
                        return(thisView.Viewer_Codes[0]);
                    }
                }
            }

            // If there are no pages, return the DEFAULT viewer, or FULL CITATION code
            if ((viewer_to_file == null) || (viewer_to_file.Count == 0))
            {
                if ((behaviors.Default_View != null) && (behaviors.Default_View.Viewer_Codes.Length > 0))
                {
                    return(behaviors.Default_View.Viewer_Codes[0]);
                }
                else
                {
                    return(View_Object.Viewer_Code_By_Type(View_Enum.CITATION)[0]);
                }
            }


            if (behaviors.Item_Level_Page_Views_Count == 0)
            {
                behaviors.Add_Item_Level_Page_View(new View_Object(View_Enum.JPEG2000));
                behaviors.Add_Item_Level_Page_View(new View_Object(View_Enum.JPEG));
            }

            // Return the first viewer code for this page
            if ((pages_by_seq != null) && (behaviors.Item_Level_Page_Views_Count > 0) && (pages_by_seq.Count >= page) && (pages_by_seq[page - 1].Files.Count > 0))
            {
                foreach (View_Object itemTaggedView in behaviors.Item_Level_Page_Views)
                {
                    foreach (SobekCM_File_Info thisFile in pages_by_seq[page - 1].Files)
                    {
                        if (thisFile.Get_Viewer() != null)
                        {
                            if (thisFile.Get_Viewer().View_Type == itemTaggedView.View_Type)
                            {
                                return(page.ToString() + thisFile.Get_Viewer().Viewer_Codes[0]);
                            }
                        }
                    }
                }
            }

            // Look for FLASH or PDF views if no page was requested
            if (behaviors.Views_Count > 0)
            {
                foreach (View_Object thisView in behaviors.Views)
                {
                    if ((thisView.View_Type == View_Enum.PDF) || (thisView.View_Type == View_Enum.FLASH))
                    {
                        return(thisView.Viewer_Codes[0]);
                    }
                }
            }

            // Return first page viewer code
            if ((pages_by_seq != null) && (behaviors.Item_Level_Page_Views_Count > 0) && (pages_by_seq.Count > 0) && (pages_by_seq[0].Files.Count > 0))
            {
                foreach (View_Object itemTaggedView in behaviors.Item_Level_Page_Views)
                {
                    foreach (SobekCM_File_Info thisFile in pages_by_seq[0].Files)
                    {
                        if (thisFile.Get_Viewer() != null)
                        {
                            if (thisFile.Get_Viewer().View_Type == itemTaggedView.View_Type)
                            {
                                return("1" + thisFile.Get_Viewer().Viewer_Codes[0]);
                            }
                        }
                    }
                }
            }

            return(View_Object.Viewer_Code_By_Type(View_Enum.CITATION)[0]);
        }
        /// <summary> Accepts a simple <see cref="View_Object"/> from the digital resource object and returns
        /// the appropriate item viewer object which extends the <see cref="SobekCM.Library.ItemViewer.Viewers.abstractItemViewer"/>
        /// class for rendering the item to the web via HTML.</summary>
        /// <param name="viewObject"> View object from the digital resource object </param>
        /// <param name="Resource_Type">Resource type often impacts how an item viewer renders</param>
        /// <param name="Current_Object">Current resource object </param>
        /// <param name="Current_User">Currently session's user </param>
        /// <returns> Genereated item viewer class for rendering the particular view of a digital resource
        /// via HTML. </returns>
        public static abstractItemViewer Get_Viewer(View_Object viewObject, string Resource_Type, SobekCM_Item Current_Object, User_Object Current_User, SobekCM_Navigation_Object Current_Mode)
        {
            switch (viewObject.View_Type)
            {
            case View_Enum.ALL_VOLUMES:
                return(new MultiVolumes_ItemViewer());

            case View_Enum.CITATION:
                return(new Citation_ItemViewer());

            case View_Enum.DOWNLOADS:
                return(new Download_ItemViewer());

            case View_Enum.DATASET_CODEBOOK:
                return(new Dataset_CodeBook_ItemViewer());

            case View_Enum.DATASET_REPORTS:
                return(new Dataset_Reports_ItemViewer());

            case View_Enum.DATASET_VIEWDATA:
                return(new Dataset_ViewData_ItemViewer());

            case View_Enum.EAD_DESCRIPTION:
                return(new EAD_Description_ItemViewer());

            case View_Enum.EAD_CONTAINER_LIST:
                return(new EAD_Container_List_ItemViewer());

            case View_Enum.EMBEDDED_VIDEO:
                return(new EmbeddedVideo_ItemViewer());

            case View_Enum.FEATURES:
                return(new Feature_ItemViewer());

            case View_Enum.FLASH:
                return(new Flash_ItemViewer(viewObject.Label, 0));

            case View_Enum.GOOGLE_COORDINATE_ENTRY:
                return(new Google_Coordinate_Entry_ItemViewer(Current_User, Current_Object, Current_Mode));

            case View_Enum.GOOGLE_MAP:
                return(new Google_Map_ItemViewer());

            case View_Enum.GOOGLE_MAP_BETA:
                return(new Google_Map_ItemViewer_Beta());

            case View_Enum.HTML:
                return(new HTML_ItemViewer(viewObject.Attributes, viewObject.Label));

            case View_Enum.JPEG:
                abstractItemViewer jpegViewer = new JPEG_ItemViewer(viewObject.Attributes);
                jpegViewer.FileName = viewObject.FileName;
                return(jpegViewer);

            case View_Enum.JPEG_TEXT_TWO_UP:
                abstractItemViewer jpegTextViewer = new JPEG_Text_Two_Up_ItemViewer(viewObject.Attributes);
                jpegTextViewer.FileName = viewObject.FileName;
                return(jpegTextViewer);

            case View_Enum.JPEG2000:
                if (SobekCM_Library_Settings.JP2ServerType == "Built-In IIPImage")
                {
                    abstractItemViewer newJp2Viewer = new JPEG2000_ItemViewer();
                    newJp2Viewer.FileName = viewObject.FileName;
                    return(newJp2Viewer);
                }
                else if (SobekCM_Library_Settings.JP2ServerType == "Aware")
                {
                    abstractItemViewer jpeg2000Viewer = new Aware_JP2_ItemViewer(Resource_Type, viewObject.Attributes, Current_Mode);
                    jpeg2000Viewer.FileName = viewObject.FileName;
                    return(jpeg2000Viewer);
                }
                return(null);

                break;

            case View_Enum.MANAGE:
                return(new ManageMenu_ItemViewer(Current_Object, Current_User, Current_Mode));

            case View_Enum.PAGE_TURNER:
                return(new GnuBooks_PageTurner_ItemViewer());

            case View_Enum.PDF:
                return(new PDF_ItemViewer(viewObject.FileName));

            case View_Enum.QUALITY_CONTROL:
                return(new QC_ItemViewer(Current_Object, Current_User, Current_Mode));

            case View_Enum.RELATED_IMAGES:
                return(new Related_Images_ItemViewer());

            case View_Enum.SEARCH:
                return(new Text_Search_ItemViewer());

            case View_Enum.STREETS:
                return(new Street_ItemViewer());

            case View_Enum.TEST:
                return(new Test_ItemViewer());

            case View_Enum.TEXT:
                abstractItemViewer textViewer = new Text_ItemViewer();
                textViewer.FileName = viewObject.FileName;
                return(textViewer);

            case View_Enum.TOC:
                return(new TOC_ItemViewer());

            case View_Enum.TRACKING:
                return(new Tracking_ItemViewer());

            case View_Enum.TRACKING_SHEET:
                return(new TrackingSheet_ItemViewer(Current_Object, Current_User, Current_Mode));

            case View_Enum.YOUTUBE_VIDEO:
                return(new YouTube_Embedded_Video_ItemViewer());
            }

            return(null);
        }
        /// <summary> Stream to which to write the HTML for this subwriter  </summary>
        /// <param name="Output"> Response stream for the item viewer to write directly to </param>
        /// <param name="Tracer"> Trace object keeps a list of each method executed and important milestones in rendering </param>
        public override void Write_Main_Viewer_Section(TextWriter Output, Custom_Tracer Tracer)
        {
            if (Tracer != null)
            {
                Tracer.Add_Trace("JPEG_ItemViewer.Write_Main_Viewer_Section", "");
            }

            // Determine if there is a zoomable version of this page
            bool isZoomable = false;

            if (CurrentItem.Web.Pages_By_Sequence.Count > CurrentMode.Page - 1)
            {
                foreach (View_Object thisPageView in CurrentItem.Behaviors.Item_Level_Page_Views)
                {
                    View_Enum thisViewType = thisPageView.View_Type;
                    foreach (SobekCM_File_Info thisFile in CurrentItem.Web.Pages_By_Sequence[CurrentMode.Page - 1].Files)
                    {
                        View_Object fileObject = thisFile.Get_Viewer();
                        if ((fileObject != null) && (fileObject.View_Type == View_Enum.JPEG2000))
                        {
                            isZoomable = true;
                            break;
                        }
                    }
                }
            }

            string displayFileName = CurrentItem.Web.Source_URL + "/" + FileName;

            // MAKE THIS USE THE FILES.ASPX WEB PAGE if this is restricted (or dark)
            if ((CurrentItem.Behaviors.Dark_Flag) || (CurrentItem.Behaviors.IP_Restriction_Membership > 0))
            {
                displayFileName = CurrentMode.Base_URL + "files/" + CurrentItem.BibID + "/" + CurrentItem.VID + "/" + FileName;
            }


            string name_for_image = HttpUtility.HtmlEncode(CurrentItem.Bib_Info.Main_Title.ToString());


            if ((CurrentItem.Web.Pages_By_Sequence.Count > 1) && (Current_Page - 1 < CurrentItem.Web.Pages_By_Sequence.Count))
            {
                string name_of_page = CurrentItem.Web.Pages_By_Sequence[Current_Page - 1].Label;
                name_for_image = name_for_image + " - " + HttpUtility.HtmlEncode(name_of_page);
            }



            // Add the HTML for the image
            if (isZoomable)
            {
                string currViewer = CurrentMode.ViewerCode;
                CurrentMode.ViewerCode = CurrentMode.ViewerCode.ToLower().Replace("j", "") + "x";
                string toZoomable = CurrentMode.Redirect_URL();
                CurrentMode.ViewerCode = currViewer;
                Output.WriteLine("\t\t<td id=\"sbkJiv_ImageZoomable\">");
                Output.WriteLine("Click on image below to switch to zoomable version<br />");
                Output.WriteLine("<a href=\"" + toZoomable + "\" title=\"Click on image to switch to zoomable version\">");

                Output.Write("\t\t\t<img itemprop=\"primaryImageOfPage\" ");
                if ((height > 0) && (width > 0))
                {
                    Output.Write("style=\"height:" + height + "px;width:" + width + "px;\" ");
                }
                Output.WriteLine("src=\"" + displayFileName + "\" alt=\"MISSING IMAGE\" />");

                Output.WriteLine("</a>");
            }
            else
            {
                Output.WriteLine("\t\t<td align=\"center\" id=\"sbkJiv_Image\">");

                Output.Write("\t\t\t<img itemprop=\"primaryImageOfPage\" ");
                if ((height > 0) && (width > 0))
                {
                    Output.Write("style=\"height:" + height + "px;width:" + width + "px;\" ");
                }
                Output.WriteLine("src=\"" + displayFileName + "\" alt=\"MISSING IMAGE\" title=\"" + name_for_image + "\" />");
            }

            Output.WriteLine("\t\t</td>");
        }
        /// <summary> Accepts a simple <see cref="View_Object"/> from the digital resource object and returns
        /// the appropriate item viewer object which extends the <see cref="SobekCM.Library.ItemViewer.Viewers.abstractItemViewer"/>
        /// class for rendering the item to the web via HTML.</summary>
        /// <param name="viewObject"> View object from the digital resource object </param>
        /// <param name="Resource_Type">Resource type often impacts how an item viewer renders</param>
        /// <returns> Genereated item viewer class for rendering the particular view of a digital resource
        /// via HTML. </returns>
        public static abstractItemViewer Get_Viewer(View_Object viewObject, string Resource_Type )
        {
            switch (viewObject.View_Type)
            {
                case View_Enum.ALL_VOLUMES:
                    return new MultiVolumes_ItemViewer();

                case View_Enum.CITATION:
                    return new Citation_ItemViewer();

                case View_Enum.DOWNLOADS:
                    return new Download_ItemViewer();

                case View_Enum.FEATURES:
                    return new Feature_ItemViewer();

                case View_Enum.FLASH:
                    return new Flash_ItemViewer(viewObject.Label, 0);

                case View_Enum.GOOGLE_MAP:
                    return new Google_Map_ItemViewer();

                case View_Enum.HTML:
                    return new HTML_ItemViewer(viewObject.Attributes, viewObject.Label);

                case View_Enum.HTML_MAP:
                    string[] html_map_splitter = viewObject.Attributes.Split(";".ToCharArray());
                    if (html_map_splitter.Length >= 2)
                    {
                        return new HTML_Map_ItemViewer(html_map_splitter[0], html_map_splitter[1], viewObject.Label);
                    }
                    break;

                case View_Enum.JPEG:
                    abstractItemViewer jpegViewer = new JPEG_ItemViewer( viewObject.Attributes );
                    jpegViewer.FileName = viewObject.FileName;
                    return jpegViewer;

                case View_Enum.JPEG2000:
                    abstractItemViewer jpeg2000Viewer = new Aware_JP2_ItemViewer(Resource_Type, viewObject.Attributes);
                    jpeg2000Viewer.FileName = viewObject.FileName;
                    return jpeg2000Viewer;

                case View_Enum.RELATED_IMAGES:
                    return new Related_Images_ItemViewer(viewObject.Label);

                case View_Enum.SEARCH:
                    return new Text_Search_ItemViewer();

                case View_Enum.STREETS:
                    return new Street_ItemViewer();

                case View_Enum.TEXT:
                    abstractItemViewer textViewer = new Text_ItemViewer();
                    textViewer.FileName = viewObject.FileName;
                    return textViewer;

                case View_Enum.TOC:
                    return new TOC_ItemViewer();

                case View_Enum.PDF:
                    return new PDF_ItemViewer(viewObject.FileName);

                case View_Enum.EAD_DESCRIPTION:
                    return new EAD_Description_ItemViewer();

                case View_Enum.EAD_CONTAINER_LIST:
                    return new EAD_Container_List_ItemViewer();

                case View_Enum.PAGE_TURNER:
                    return new GnuBooks_PageTurner_ItemViewer();

                case View_Enum.YOUTUBE_VIDEO:
                    return new YouTube_Embedded_Video_ItemViewer();

                case View_Enum.EMBEDDED_VIDEO:
                    return new EmbeddedVideo_ItemViewer();

                case View_Enum.TRACKING:
                    return new Tracking_ItemViewer();

                case View_Enum.QUALITY_CONTROL:
                    return new QC_ItemViewer();
            }

            return null;
        }
        /// <summary> Get the navigation bar html for a view, given information about the current request </summary>
        /// <param name="Item_View"> View for which to generate the html </param>
        /// <param name="Resource_Type"> Current resource type, which determines the text in several viewer's tabs</param>
        /// <param name="Skin_Code"> Code for the current web sking, which determines which tab images to use </param>
        /// <param name="Current_Mode"> Mode / navigation information for the current request</param>
        /// <param name="Page_Sequence"> Current page sequence </param>
        /// <param name="Translator"> Language support object provides support for translating common user interface elements, like the names of these tabs </param>
        /// <param name="Show_Zoomable"> Flag indicates if the zoomable server is online and should be displayable </param>
        /// <returns> Collection of the html for the navigation bar (one view could have multiple tabs)</returns>
        public static List<string> Get_Nav_Bar_HTML(View_Object Item_View, string Resource_Type, 
            string Skin_Code, SobekCM_Navigation_Object Current_Mode, int Page_Sequence,
            Language_Support_Info Translator, bool Show_Zoomable, SobekCM_Item Current_Item )
        {
            List<string> returnVal = new List<string>();

            switch (Item_View.View_Type)
            {
                case View_Enum.ALL_VOLUMES:
                    string allVolumeCode = "allvolumes";
                    string resource_type_upper = Resource_Type.ToUpper();
                    if (Current_Mode.ViewerCode.IndexOf("allvolumes") == 0)
                        allVolumeCode = Current_Mode.ViewerCode;
                    if (resource_type_upper.IndexOf("NEWSPAPER") >= 0)
                    {
                        returnVal.Add(HTML_Helper(Skin_Code, allVolumeCode, Translator.Get_Translation("ALL ISSUES", Current_Mode.Language), Current_Mode));
                    }
                    else
                    {
                        if (resource_type_upper.IndexOf("MAP") >= 0)
                        {
                            returnVal.Add(HTML_Helper(Skin_Code, allVolumeCode, Translator.Get_Translation("RELATED MAPS", Current_Mode.Language), Current_Mode));
                        }
                        else
                        {
                            returnVal.Add(resource_type_upper.IndexOf("AERIAL") >= 0
                                              ? HTML_Helper(Skin_Code, allVolumeCode, Translator.Get_Translation("RELATED FLIGHTS", Current_Mode.Language), Current_Mode)
                                              : HTML_Helper(Skin_Code, allVolumeCode, Translator.Get_Translation("ALL VOLUMES", Current_Mode.Language), Current_Mode));
                        }
                    }
                    break;

                case View_Enum.CITATION:
                    if ((Current_Mode.ViewerCode == "citation") || ( Current_Mode.ViewerCode == "marc" ) || ( Current_Mode.ViewerCode == "metadata" ) || ( Current_Mode.ViewerCode == "usage" ))
                    {
                        returnVal.Add(HTML_Helper(Skin_Code, Current_Mode.ViewerCode, Translator.Get_Translation("CITATION", Current_Mode.Language), Current_Mode));
                    }
                    else
                    {
                        returnVal.Add(HTML_Helper(Skin_Code, "citation", Translator.Get_Translation("CITATION", Current_Mode.Language), Current_Mode));
                    }
                    break;

                case View_Enum.DATASET_CODEBOOK:
                    returnVal.Add(HTML_Helper(Skin_Code, "dscodebook", Translator.Get_Translation("DATA STRUCTURE", Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.DATASET_REPORTS:
                    returnVal.Add(HTML_Helper(Skin_Code, "dsreports", Translator.Get_Translation("REPORTS", Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.DATASET_VIEWDATA:
                    returnVal.Add(HTML_Helper(Skin_Code, "dsview", Translator.Get_Translation("EXPLORE DATA", Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.DOWNLOADS:
                    returnVal.Add(HTML_Helper(Skin_Code, "downloads", Translator.Get_Translation("DOWNLOADS", Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.FEATURES:
                    returnVal.Add(HTML_Helper(Skin_Code, "features", Translator.Get_Translation("FEATURES", Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.FLASH:
                    returnVal.Add(Item_View.Label.Length == 0
                                      ? HTML_Helper(Skin_Code, "flash", Translator.Get_Translation("FLASH VIEW", Current_Mode.Language), Current_Mode)
                                      : HTML_Helper(Skin_Code, "flash", Translator.Get_Translation(Item_View.Label.ToUpper(), Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.GOOGLE_MAP:
                    if (Current_Mode.Coordinates.Length > 0)
                    {
                        if (Current_Mode.ViewerCode == "mapsearch")
                        {
                            returnVal.Add( HTML_Helper(Skin_Code, "mapsearch", Translator.Get_Translation("MAP SEARCH", Current_Mode.Language), Current_Mode));
                        }
                        else
                        {
                            if (( Current_Item.Web.Static_PageCount > 1 ) || ( Current_Item.Bib_Info.SobekCM_Type != TypeOfResource_SobekCM_Enum.Map ))
                            {
                                returnVal.Add(HTML_Helper(Skin_Code, "map", Translator.Get_Translation("SEARCH RESULTS", Current_Mode.Language), Current_Mode));
                            }
                            else
                            {
                                returnVal.Add(HTML_Helper(Skin_Code, "map", Translator.Get_Translation("MAP COVERAGE", Current_Mode.Language), Current_Mode));
                            }

                        }
                    }
                    else
                    {
                        returnVal.Add(HTML_Helper(Skin_Code, "map", Translator.Get_Translation("MAP IT!", Current_Mode.Language), Current_Mode));
                    }
                    break;

                case View_Enum.GOOGLE_MAP_BETA:
                    if (Current_Mode.Coordinates.Length > 0)
                    {
                        if (Current_Mode.ViewerCode == "mapsearchbeta")
                        {
                            returnVal.Add(HTML_Helper(Skin_Code, "mapsearchbeta", Translator.Get_Translation("MAP SEARCH", Current_Mode.Language), Current_Mode));
                        }
                        else
                        {
                            if ((Current_Item.Web.Static_PageCount > 1) || (Current_Item.Bib_Info.SobekCM_Type != TypeOfResource_SobekCM_Enum.Map_Beta))
                            {
                                returnVal.Add(HTML_Helper(Skin_Code, "mapbeta", Translator.Get_Translation("SEARCH RESULTS", Current_Mode.Language), Current_Mode));
                            }
                            else
                            {
                                returnVal.Add(HTML_Helper(Skin_Code, "mapbeta", Translator.Get_Translation("MAP COVERAGE", Current_Mode.Language), Current_Mode));
                            }

                        }
                    }
                    else
                    {
                        returnVal.Add(HTML_Helper(Skin_Code, "map", Translator.Get_Translation("MAP IT!", Current_Mode.Language), Current_Mode));
                    }
                    break;

                case View_Enum.HTML:
                    returnVal.Add(Item_View.Label.Length > 0
                                      ? HTML_Helper(Skin_Code, "html", Item_View.Label.ToUpper(), Current_Mode)
                                      : HTML_Helper(Skin_Code, "html", "HTML LINK", Current_Mode));
                    break;

                case View_Enum.JPEG:
                    returnVal.Add(HTML_Helper_PageView(Skin_Code, Page_Sequence.ToString() + "j", Translator.Get_Translation("STANDARD", Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.JPEG_TEXT_TWO_UP:
                    returnVal.Add(HTML_Helper_PageView(Skin_Code, Page_Sequence.ToString() + "u", Translator.Get_Translation("PAGE IMAGE WITH TEXT", Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.JPEG2000:
                    if (Show_Zoomable)
                    {
                        returnVal.Add(HTML_Helper_PageView(Skin_Code, Page_Sequence.ToString() + "x", Translator.Get_Translation("ZOOMABLE", Current_Mode.Language), Current_Mode));
                    }
                    break;

                case View_Enum.PDF:
                    returnVal.Add(HTML_Helper(Skin_Code, "pdf", Translator.Get_Translation("PDF VIEWER", Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.RELATED_IMAGES:
                    returnVal.Add(Current_Mode.ViewerCode.IndexOf("thumbs") >= 0
                                      ? HTML_Helper(Skin_Code, Current_Mode.ViewerCode, Translator.Get_Translation("THUMBNAILS", Current_Mode.Language), Current_Mode)
                                      : HTML_Helper(Skin_Code, "thumbs", Translator.Get_Translation("THUMBNAILS", Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.SEARCH:
                    returnVal.Add(HTML_Helper(Skin_Code, "search", Translator.Get_Translation("SEARCH", Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.SIMPLE_HTML_LINK:
                    returnVal.Add("<li> <a href=\"" + Item_View.Attributes + "\" target=\"_blank\" alt=\"Link to '" + Item_View.Label + "'\"> " + Translator.Get_Translation(Item_View.Label.ToUpper(), Current_Mode.Language) + " </a></li>");
                    break;

                case View_Enum.STREETS:
                    returnVal.Add(HTML_Helper(Skin_Code, "streets", Translator.Get_Translation("STREETS", Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.TEXT:
                    returnVal.Add(HTML_Helper_PageView(Skin_Code, Page_Sequence.ToString() + "t", Translator.Get_Translation("PAGE TEXT", Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.TOC:
                     // returnVal.Add(base.HTML_Helper(Skin_Code, "TC", "Table of Contents", Current_Mode));
                    break;

                case View_Enum.RESTRICTED:
                    returnVal.Add(HTML_Helper(Skin_Code, "restricted", Translator.Get_Translation("RESTRICTED", Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.EAD_CONTAINER_LIST:
                    returnVal.Add(HTML_Helper(Skin_Code, "container", Translator.Get_Translation("CONTAINER LIST", Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.EAD_DESCRIPTION:
                    // Return nothing, this is currently written when writing the CITATION, for
                    // all EAD type items.
                    //returnVal.Add(HTML_Helper(Skin_Code, "description", Translator.Get_Translation("DESCRIPTION", Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.PAGE_TURNER:
                    returnVal.Add(HTML_Helper(Skin_Code, "pageturner#page/1/mode/2up", Translator.Get_Translation("PAGE TURNER", Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.YOUTUBE_VIDEO:
                    returnVal.Add(HTML_Helper(Skin_Code, "youtube", Translator.Get_Translation("VIDEO", Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.EMBEDDED_VIDEO:
                    returnVal.Add(HTML_Helper(Skin_Code, "video", Translator.Get_Translation("VIDEO", Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.TRACKING:
                    // DO nothing in this case.. do not write any tab
                    break;

                case View_Enum.TRACKING_SHEET:
                    //DO nothing in this case.. do not write any tab
                    break;

                case View_Enum.QUALITY_CONTROL:
                    // DO nothing in this case.. do not write any tab
                    break;
            }

            return returnVal;
        }
 /// <summary>Add a new SobekCM View to this resource </summary>
 /// <param name="New_View">SobekCM View object</param>
 public void Add_View(View_Object New_View)
 {
     if (Views == null)
         Views = new List<View_Object>();
     Views.Add(New_View);
 }
Example #24
0
        /// <summary> Accepts a simple <see cref="View_Object"/> from the digital resource object and returns
        /// the appropriate item viewer object which extends the <see cref="SobekCM.Library.ItemViewer.Viewers.abstractItemViewer"/>
        /// class for rendering the item to the web via HTML.</summary>
        /// <param name="viewObject"> View object from the digital resource object </param>
        /// <param name="Resource_Type">Resource type often impacts how an item viewer renders</param>
        /// <returns> Genereated item viewer class for rendering the particular view of a digital resource
        /// via HTML. </returns>
        public static abstractItemViewer Get_Viewer(View_Object viewObject, string Resource_Type)
        {
            switch (viewObject.View_Type)
            {
            case View_Enum.ALL_VOLUMES:
                return(new MultiVolumes_ItemViewer());

            case View_Enum.CITATION:
                return(new Citation_ItemViewer());

            case View_Enum.DOWNLOADS:
                return(new Download_ItemViewer());

            case View_Enum.FEATURES:
                return(new Feature_ItemViewer());

            case View_Enum.FLASH:
                return(new Flash_ItemViewer(viewObject.Label, 0));

            case View_Enum.GOOGLE_MAP:
                return(new Google_Map_ItemViewer());

            case View_Enum.HTML:
                return(new HTML_ItemViewer(viewObject.Attributes, viewObject.Label));

            case View_Enum.HTML_MAP:
                string[] html_map_splitter = viewObject.Attributes.Split(";".ToCharArray());
                if (html_map_splitter.Length >= 2)
                {
                    return(new HTML_Map_ItemViewer(html_map_splitter[0], html_map_splitter[1], viewObject.Label));
                }
                break;

            case View_Enum.JPEG:
                abstractItemViewer jpegViewer = new JPEG_ItemViewer(viewObject.Attributes);
                jpegViewer.FileName = viewObject.FileName;
                return(jpegViewer);

            case View_Enum.JPEG2000:
                abstractItemViewer jpeg2000Viewer = new Aware_JP2_ItemViewer(Resource_Type, viewObject.Attributes);
                jpeg2000Viewer.FileName = viewObject.FileName;
                return(jpeg2000Viewer);

            case View_Enum.RELATED_IMAGES:
                return(new Related_Images_ItemViewer(viewObject.Label));

            case View_Enum.SEARCH:
                return(new Text_Search_ItemViewer());

            case View_Enum.STREETS:
                return(new Street_ItemViewer());

            case View_Enum.TEXT:
                abstractItemViewer textViewer = new Text_ItemViewer();
                textViewer.FileName = viewObject.FileName;
                return(textViewer);

            case View_Enum.TOC:
                return(new TOC_ItemViewer());

            case View_Enum.PDF:
                return(new PDF_ItemViewer(viewObject.FileName));

            case View_Enum.EAD_DESCRIPTION:
                return(new EAD_Description_ItemViewer());

            case View_Enum.EAD_CONTAINER_LIST:
                return(new EAD_Container_List_ItemViewer());

            case View_Enum.PAGE_TURNER:
                return(new GnuBooks_PageTurner_ItemViewer());

            case View_Enum.YOUTUBE_VIDEO:
                return(new YouTube_Embedded_Video_ItemViewer());

            case View_Enum.EMBEDDED_VIDEO:
                return(new EmbeddedVideo_ItemViewer());

            case View_Enum.TRACKING:
                return(new Tracking_ItemViewer());

            case View_Enum.QUALITY_CONTROL:
                return(new QC_ItemViewer());
            }

            return(null);
        }
        /// <summary>Add a new SobekCM View to this resource </summary>
        /// <param name="View_Type">Standard type of SobekCM View</param>
        /// <param name="Label">Label for this SobekCM View</param>
        /// <param name="Attributes">Any additional attribures needed for thie SobekCM View</param>
        /// <returns>Built view object</returns>
        public View_Object Add_View(string View_Type, string Label, string Attributes)
        {
            if (!String.IsNullOrEmpty(View_Type))
            {
                if (Views == null)
                    Views = new List<View_Object>();

                View_Object newView = new View_Object(View_Type, Label, Attributes);
                Views.Add(newView);
                return newView;
            }

            return null;
        }
        /// <summary> Get the navigation bar html for a view, given information about the current request </summary>
        /// <param name="Item_View"> View for which to generate the html </param>
        /// <param name="Resource_Type"> Current resource type, which determines the text in several viewer's tabs</param>
        /// <param name="Skin_Code"> Code for the current web sking, which determines which tab images to use </param>
        /// <param name="Current_Mode"> Mode / navigation information for the current request</param>
        /// <param name="Page_Sequence"> Current page sequence </param>
        /// <param name="Translator"> Language support object provides support for translating common user interface elements, like the names of these tabs </param>
        /// <param name="Show_Zoomable"> Flag indicates if the zoomable server is online and should be displayable </param>
        /// <param name="Current_Item"> Current digital resource, with the viewers that should be displayed </param>
        /// <returns> Collection of the html for the navigation bar (one view could have multiple tabs)</returns>
        public static List<string> Get_Nav_Bar_HTML(View_Object Item_View, string Resource_Type, 
            string Skin_Code, Navigation_Object Current_Mode, int Page_Sequence,
            Language_Support_Info Translator, bool Show_Zoomable, SobekCM_Item Current_Item )
        {
            List<string> returnVal = new List<string>();

            switch (Item_View.View_Type)
            {
                case View_Enum.ALL_VOLUMES:
                    string allVolumeCode = "allvolumes";
                    string resource_type_upper = Resource_Type.ToUpper();
                    if (Current_Mode.ViewerCode.IndexOf("allvolumes") == 0)
                        allVolumeCode = Current_Mode.ViewerCode;
                    if (resource_type_upper.IndexOf("NEWSPAPER") >= 0)
                    {
                        returnVal.Add(HTML_Helper(allVolumeCode, Translator.Get_Translation("All Issues", Current_Mode.Language), Current_Mode));
                    }
                    else
                    {
                        if (resource_type_upper.IndexOf("MAP") >= 0)
                        {
                            returnVal.Add(HTML_Helper(allVolumeCode, Translator.Get_Translation("Related Maps", Current_Mode.Language), Current_Mode));
                        }
                        else
                        {
                            returnVal.Add(resource_type_upper.IndexOf("AERIAL") >= 0
                                              ? HTML_Helper(allVolumeCode, Translator.Get_Translation("Related Flights", Current_Mode.Language), Current_Mode)
                                              : HTML_Helper(allVolumeCode, Translator.Get_Translation("All Volumes", Current_Mode.Language), Current_Mode));
                        }
                    }
                    break;

                case View_Enum.CITATION:
                    if ((Current_Mode.ViewerCode == "citation") || ( Current_Mode.ViewerCode == "marc" ) || ( Current_Mode.ViewerCode == "metadata" ) || ( Current_Mode.ViewerCode == "usage" ))
                    {
                        returnVal.Add(HTML_Helper(Current_Mode.ViewerCode, Translator.Get_Translation("Citation", Current_Mode.Language), Current_Mode));
                    }
                    else
                    {
                        returnVal.Add(HTML_Helper("citation", Translator.Get_Translation("Citation", Current_Mode.Language), Current_Mode));
                    }
                    break;

                case View_Enum.DATASET_CODEBOOK:
                    returnVal.Add(HTML_Helper("dscodebook", Translator.Get_Translation("Data Structure", Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.DATASET_REPORTS:
                    returnVal.Add(HTML_Helper("dsreports", Translator.Get_Translation("Reports", Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.DATASET_VIEWDATA:
                    returnVal.Add(HTML_Helper("dsview", Translator.Get_Translation("Explore Data", Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.DOWNLOADS:
                    returnVal.Add(HTML_Helper("downloads", Translator.Get_Translation("Downloads", Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.FEATURES:
                    returnVal.Add(HTML_Helper("features", Translator.Get_Translation("Features", Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.FLASH:
                    returnVal.Add( String.IsNullOrEmpty(Item_View.Label)
                                      ? HTML_Helper("flash", Translator.Get_Translation("Flash View", Current_Mode.Language), Current_Mode)
                                      : HTML_Helper("flash", Translator.Get_Translation(Item_View.Label.ToUpper(), Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.GOOGLE_MAP:
                    if ( !String.IsNullOrEmpty(Current_Mode.Coordinates))
                    {
                        if (Current_Mode.ViewerCode == "mapsearch")
                        {
                            returnVal.Add( HTML_Helper("mapsearch", Translator.Get_Translation("Map Search", Current_Mode.Language), Current_Mode));
                        }
                        else
                        {
                            if (( Current_Item.Web.Static_PageCount > 1 ) || ( Current_Item.Bib_Info.SobekCM_Type != TypeOfResource_SobekCM_Enum.Map ))
                            {
                                returnVal.Add(HTML_Helper("map", Translator.Get_Translation("Search Results", Current_Mode.Language), Current_Mode));
                            }
                            else
                            {
                                returnVal.Add(HTML_Helper("map", Translator.Get_Translation("Map Coverage", Current_Mode.Language), Current_Mode));
                            }

                        }
                    }
                    else
                    {
                        returnVal.Add(HTML_Helper("map", Translator.Get_Translation("Map It!", Current_Mode.Language), Current_Mode));
                    }
                    break;

                case View_Enum.GOOGLE_MAP_BETA:
                    if (!String.IsNullOrEmpty(Current_Mode.Coordinates))
                    {
                        if (Current_Mode.ViewerCode == "mapsearchbeta")
                        {
                            returnVal.Add(HTML_Helper("mapsearchbeta", Translator.Get_Translation("Map Search", Current_Mode.Language), Current_Mode));
                        }
                        else
                        {
                            if ((Current_Item.Web.Static_PageCount > 1) || (Current_Item.Bib_Info.SobekCM_Type != TypeOfResource_SobekCM_Enum.Map_Beta))
                            {
                                returnVal.Add(HTML_Helper("mapbeta", Translator.Get_Translation("Search Results", Current_Mode.Language), Current_Mode));
                            }
                            else
                            {
                                returnVal.Add(HTML_Helper("mapbeta", Translator.Get_Translation("Map Coverage", Current_Mode.Language), Current_Mode));
                            }

                        }
                    }
                    else
                    {
                        returnVal.Add(HTML_Helper("map", Translator.Get_Translation("Map It!", Current_Mode.Language), Current_Mode));
                    }
                    break;

                case View_Enum.HTML:
                    returnVal.Add(!String.IsNullOrEmpty(Item_View.Label)
                                      ? HTML_Helper("html", Item_View.Label.ToUpper(), Current_Mode)
                                      : HTML_Helper("html", "HTML LINK", Current_Mode));
                    break;

                case View_Enum.JPEG:
                    returnVal.Add(HTML_Helper_PageView(Page_Sequence.ToString() + "j", Translator.Get_Translation("Standard", Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.JPEG_TEXT_TWO_UP:
                    returnVal.Add(HTML_Helper_PageView(Page_Sequence.ToString() + "u", Translator.Get_Translation("Page Image with Text", Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.JPEG2000:
                    if (Show_Zoomable)
                    {
                        returnVal.Add(HTML_Helper_PageView(Page_Sequence.ToString() + "x", Translator.Get_Translation("Zoomable", Current_Mode.Language), Current_Mode));
                    }
                    break;

                case View_Enum.PDF:
                    returnVal.Add(HTML_Helper("pdf", Translator.Get_Translation("PDF Viewer", Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.RELATED_IMAGES:
                    returnVal.Add(Current_Mode.ViewerCode.IndexOf("thumbs") >= 0
                                      ? HTML_Helper(Current_Mode.ViewerCode, Translator.Get_Translation("Thumbnails", Current_Mode.Language), Current_Mode)
                                      : HTML_Helper("thumbs", Translator.Get_Translation("Thumbnails", Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.SEARCH:
                    returnVal.Add(HTML_Helper("search", Translator.Get_Translation("Search", Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.SIMPLE_HTML_LINK:
                    returnVal.Add("<li> <a href=\"" + Item_View.Attributes + "\" target=\"_blank\" alt=\"Link to '" + Item_View.Label + "'\"> " + Translator.Get_Translation(Item_View.Label.ToUpper(), Current_Mode.Language) + " </a></li>");
                    break;

                case View_Enum.STREETS:
                    returnVal.Add(HTML_Helper("streets", Translator.Get_Translation("Streets", Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.TEXT:
                    returnVal.Add(HTML_Helper_PageView(Page_Sequence.ToString() + "t", Translator.Get_Translation("Page Text", Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.TOC:
                     // returnVal.Add(base.HTML_Helper(Skin_Code, "TC", "Table of Contents", Current_Mode));
                    break;

                case View_Enum.RESTRICTED:
                    returnVal.Add(HTML_Helper("restricted", Translator.Get_Translation("Restricted", Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.EAD_CONTAINER_LIST:
                    returnVal.Add(HTML_Helper("container", Translator.Get_Translation("Container List", Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.EAD_DESCRIPTION:
                    // Return nothing, this is currently written when writing the CITATION, for
                    // all EAD type items.
                    //returnVal.Add(HTML_Helper(Skin_Code, "description", Translator.Get_Translation("DESCRIPTION", Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.PAGE_TURNER:
                    returnVal.Add(HTML_Helper("pageturner#page/1/mode/2up", Translator.Get_Translation("Page Turner", Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.YOUTUBE_VIDEO:
                    returnVal.Add(HTML_Helper("youtube", Translator.Get_Translation("Video", Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.EMBEDDED_VIDEO:
                    returnVal.Add(HTML_Helper("videoem", Translator.Get_Translation("Video", Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.VIDEO:
                    returnVal.Add(HTML_Helper("video", Translator.Get_Translation("Video", Current_Mode.Language), Current_Mode));
                    break;

                case View_Enum.TRACKING:
                    // DO nothing in this case.. do not write any tab
                    break;

                case View_Enum.TRACKING_SHEET:
                    //DO nothing in this case.. do not write any tab
                    break;

                case View_Enum.QUALITY_CONTROL:
                    // DO nothing in this case.. do not write any tab
                    break;
            }

            return returnVal;
        }
Example #27
0
        private void Finish_Building_Item(SobekCM_Item thisPackage, DataSet databaseInfo, bool multiple)
        {
            // Copy over some basic values
            DataRow mainItemRow = databaseInfo.Tables[2].Rows[0];

            thisPackage.Behaviors.Set_Primary_Identifier(mainItemRow["Primary_Identifier_Type"].ToString(), mainItemRow["Primary_Identifier"].ToString());
            thisPackage.Behaviors.GroupTitle = mainItemRow["GroupTitle"].ToString();
            thisPackage.Web.File_Root        = mainItemRow["File_Location"].ToString();
            thisPackage.Web.AssocFilePath    = mainItemRow["File_Location"] + "\\" + thisPackage.VID + "\\";
            thisPackage.Behaviors.IP_Restriction_Membership = Convert.ToInt16(mainItemRow["IP_Restriction_Mask"]);
            thisPackage.Behaviors.CheckOut_Required         = Convert.ToBoolean(mainItemRow["CheckoutRequired"]);
            thisPackage.Behaviors.Text_Searchable           = Convert.ToBoolean(mainItemRow["TextSearchable"]);
            thisPackage.Web.ItemID  = Convert.ToInt32(mainItemRow["ItemID"]);
            thisPackage.Web.GroupID = Convert.ToInt32(mainItemRow["GroupID"]);
            thisPackage.Behaviors.Suppress_Endeca = Convert.ToBoolean(mainItemRow["SuppressEndeca"]);
            //thisPackage.Behaviors.Expose_Full_Text_For_Harvesting = Convert.ToBoolean(mainItemRow["SuppressEndeca"]);
            thisPackage.Tracking.Internal_Comments = mainItemRow["Comments"].ToString();
            thisPackage.Behaviors.Dark_Flag        = Convert.ToBoolean(mainItemRow["Dark"]);
            thisPackage.Tracking.Born_Digital      = Convert.ToBoolean(mainItemRow["Born_Digital"]);
            //thisPackage.Divisions.Page_Count = Convert.ToInt32(mainItemRow["Pages"]);
            if (mainItemRow["Disposition_Advice"] != DBNull.Value)
            {
                thisPackage.Tracking.Disposition_Advice = Convert.ToInt16(mainItemRow["Disposition_Advice"]);
            }
            else
            {
                thisPackage.Tracking.Disposition_Advice = -1;
            }
            if (mainItemRow["Material_Received_Date"] != DBNull.Value)
            {
                thisPackage.Tracking.Material_Received_Date = Convert.ToDateTime(mainItemRow["Material_Received_Date"]);
            }
            else
            {
                thisPackage.Tracking.Material_Received_Date = null;
            }
            if (mainItemRow["Material_Recd_Date_Estimated"] != DBNull.Value)
            {
                thisPackage.Tracking.Material_Rec_Date_Estimated = Convert.ToBoolean(mainItemRow["Material_Recd_Date_Estimated"]);
            }
            if (databaseInfo.Tables[2].Columns.Contains("Tracking_Box"))
            {
                if (mainItemRow["Tracking_Box"] != DBNull.Value)
                {
                    thisPackage.Tracking.Tracking_Box = mainItemRow["Tracking_Box"].ToString();
                }
            }


            // Set more of the sobekcm web portions in the item
            thisPackage.Web.Set_BibID_VID(thisPackage.BibID, thisPackage.VID);
            thisPackage.Web.Image_Root = SobekCM_Library_Settings.Image_URL;
            if (multiple)
            {
                thisPackage.Web.Siblings = 2;
            }

            // Set the serial hierarchy from the database (if multiple)
            if ((multiple) && (mainItemRow["Level1_Text"].ToString().Length > 0))
            {
                bool found = false;

                // Get the values from the database first
                string level1_text  = mainItemRow["Level1_Text"].ToString();
                string level2_text  = mainItemRow["Level2_Text"].ToString();
                string level3_text  = mainItemRow["Level3_Text"].ToString();
                int    level1_index = Convert.ToInt32(mainItemRow["Level1_Index"]);
                int    level2_index = Convert.ToInt32(mainItemRow["Level2_Index"]);
                int    level3_index = Convert.ToInt32(mainItemRow["Level3_Index"]);

                // Does this match the enumeration
                if (level1_text.ToUpper().Trim() == thisPackage.Bib_Info.Series_Part_Info.Enum1.ToUpper().Trim())
                {
                    // Copy the database values to the enumeration portion
                    thisPackage.Bib_Info.Series_Part_Info.Enum1       = level1_text;
                    thisPackage.Bib_Info.Series_Part_Info.Enum1_Index = level1_index;
                    thisPackage.Bib_Info.Series_Part_Info.Enum2       = level2_text;
                    thisPackage.Bib_Info.Series_Part_Info.Enum2_Index = level2_index;
                    thisPackage.Bib_Info.Series_Part_Info.Enum3       = level3_text;
                    thisPackage.Bib_Info.Series_Part_Info.Enum3_Index = level3_index;
                    found = true;
                }

                // Does this match the chronology
                if ((!found) && (level1_text.ToUpper().Trim() == thisPackage.Bib_Info.Series_Part_Info.Year.ToUpper().Trim()))
                {
                    // Copy the database values to the chronology portion
                    thisPackage.Bib_Info.Series_Part_Info.Year        = level1_text;
                    thisPackage.Bib_Info.Series_Part_Info.Year_Index  = level1_index;
                    thisPackage.Bib_Info.Series_Part_Info.Month       = level2_text;
                    thisPackage.Bib_Info.Series_Part_Info.Month_Index = level2_index;
                    thisPackage.Bib_Info.Series_Part_Info.Day         = level3_text;
                    thisPackage.Bib_Info.Series_Part_Info.Day_Index   = level3_index;
                    found = true;
                }

                if (!found)
                {
                    // No match.  If it is numeric, move it to the chronology, otherwise, enumeration
                    bool charFound = level1_text.Trim().Any(thisChar => !Char.IsNumber(thisChar));

                    if (charFound)
                    {
                        // Copy the database values to the enumeration portion
                        thisPackage.Bib_Info.Series_Part_Info.Enum1       = level1_text;
                        thisPackage.Bib_Info.Series_Part_Info.Enum1_Index = level1_index;
                        thisPackage.Bib_Info.Series_Part_Info.Enum2       = level2_text;
                        thisPackage.Bib_Info.Series_Part_Info.Enum2_Index = level2_index;
                        thisPackage.Bib_Info.Series_Part_Info.Enum3       = level3_text;
                        thisPackage.Bib_Info.Series_Part_Info.Enum3_Index = level3_index;
                    }
                    else
                    {
                        // Copy the database values to the chronology portion
                        thisPackage.Bib_Info.Series_Part_Info.Year        = level1_text;
                        thisPackage.Bib_Info.Series_Part_Info.Year_Index  = level1_index;
                        thisPackage.Bib_Info.Series_Part_Info.Month       = level2_text;
                        thisPackage.Bib_Info.Series_Part_Info.Month_Index = level2_index;
                        thisPackage.Bib_Info.Series_Part_Info.Day         = level3_text;
                        thisPackage.Bib_Info.Series_Part_Info.Day_Index   = level3_index;
                    }
                }

                // Copy the database values to the simple serial portion (used to actually determine serial heirarchy)
                thisPackage.Behaviors.Serial_Info.Clear();
                thisPackage.Behaviors.Serial_Info.Add_Hierarchy(1, level1_index, level1_text);
                if (level2_text.Length > 0)
                {
                    thisPackage.Behaviors.Serial_Info.Add_Hierarchy(2, level2_index, level2_text);
                    if (level3_text.Length > 0)
                    {
                        thisPackage.Behaviors.Serial_Info.Add_Hierarchy(3, level3_index, level3_text);
                    }
                }
            }

            // See if this can be described
            bool can_describe = false;

            foreach (DataRow thisRow in databaseInfo.Tables[1].Rows)
            {
                int thisAggregationValue = Convert.ToInt16(thisRow["Items_Can_Be_Described"]);
                if (thisAggregationValue == 0)
                {
                    can_describe = false;
                    break;
                }
                if (thisAggregationValue == 2)
                {
                    can_describe = true;
                }
            }
            thisPackage.Behaviors.Can_Be_Described = can_describe;

            // Look for user descriptions
            foreach (DataRow thisRow in databaseInfo.Tables[0].Rows)
            {
                string   first_name = thisRow["FirstName"].ToString();
                string   nick_name  = thisRow["NickName"].ToString();
                string   last_name  = thisRow["LastName"].ToString();
                int      userid     = Convert.ToInt32(thisRow["UserID"]);
                string   tag        = thisRow["Description_Tag"].ToString();
                int      tagid      = Convert.ToInt32(thisRow["TagID"]);
                DateTime dateAdded  = Convert.ToDateTime(thisRow["Date_Modified"]);

                if (nick_name.Length > 0)
                {
                    thisPackage.Behaviors.Add_User_Tag(userid, nick_name + " " + last_name, tag, dateAdded, tagid);
                }
                else
                {
                    thisPackage.Behaviors.Add_User_Tag(userid, first_name + " " + last_name, tag, dateAdded, tagid);
                }
            }

            // Look for ticklers
            foreach (DataRow thisRow in databaseInfo.Tables[3].Rows)
            {
                thisPackage.Behaviors.Add_Tickler(thisRow["MetadataValue"].ToString().Trim());
            }

            // Set the aggregations in the package to the aggregation links from the database
            thisPackage.Behaviors.Clear_Aggregations();
            foreach (DataRow thisRow in databaseInfo.Tables[1].Rows)
            {
                if (!Convert.ToBoolean(thisRow["impliedLink"]))
                {
                    thisPackage.Behaviors.Add_Aggregation(thisRow["Code"].ToString());
                }
            }

            // If no collections, add some regardless of whether it was IMPLIED
            if (thisPackage.Behaviors.Aggregation_Count == 0)
            {
                foreach (DataRow thisRow in databaseInfo.Tables[1].Rows)
                {
                    if (thisRow["Type"].ToString().ToUpper() == "COLLECTION")
                    {
                        thisPackage.Behaviors.Add_Aggregation(thisRow["Code"].ToString());
                    }
                }
            }

            // Step through each page and set the static page count
            pageseq = 0;
            List <Page_TreeNode> pages_encountered = new List <Page_TreeNode>();

            foreach (abstract_TreeNode rootNode in thisPackage.Divisions.Physical_Tree.Roots)
            {
                recurse_through_nodes(thisPackage, rootNode, pages_encountered);
            }
            thisPackage.Web.Static_PageCount      = pages_encountered.Count;
            thisPackage.Web.Static_Division_Count = divseq;

            // Make sure no icons were retained from the METS file itself
            thisPackage.Behaviors.Clear_Wordmarks();

            // Add the icons from the database information
            foreach (DataRow iconRow in databaseInfo.Tables[5].Rows)
            {
                string image = iconRow[0].ToString();
                string link  = iconRow[1].ToString().Replace("&", "&amp;").Replace("\"", "&quot;");
                string code  = iconRow[2].ToString();
                string name  = code.Replace("&", "&amp;").Replace("\"", "&quot;");

                string html;
                if (link.Length == 0)
                {
                    html = "<img class=\"SobekItemWordmark\" src=\"<%BASEURL%>design/wordmarks/" + image + "\" title=\"" + name + "\" alt=\"" + name + "\" />";
                }
                else
                {
                    if (link[0] == '?')
                    {
                        html = "<a href=\"" + link + "\"><img class=\"SobekItemWordmark\" src=\"<%BASEURL%>design/wordmarks/" + image + "\" title=\"" + name + "\" alt=\"" + name + "\" /></a>";
                    }
                    else
                    {
                        html = "<a href=\"" + link + "\" target=\"_blank\"><img class=\"SobekItemWordmark\" src=\"<%BASEURL%>design/wordmarks/" + image + "\" title=\"" + name + "\" alt=\"" + name + "\" /></a>";
                    }
                }

                Wordmark_Info newIcon = new Wordmark_Info {
                    HTML = html, Link = link, Title = name, Code = code
                };
                thisPackage.Behaviors.Add_Wordmark(newIcon);
            }

            // Make sure no web skins were retained from the METS file itself
            thisPackage.Behaviors.Clear_Web_Skins();

            // Add the web skins from the database
            foreach (DataRow skinRow in databaseInfo.Tables[6].Rows)
            {
                thisPackage.Behaviors.Add_Web_Skin(skinRow[0].ToString().ToUpper());
            }

            // Make sure no views were retained from the METS file itself
            thisPackage.Behaviors.Clear_Views();

            // If this has more than 1 sibling (this count includes itself), add the multi-volumes viewer
            if (multiple)
            {
                thisPackage.Behaviors.Add_View(View_Enum.ALL_VOLUMES, String.Empty, thisPackage.Bib_Info.SobekCM_Type_String);
            }

            // Add the full citation view and the (hidden) tracking view
            thisPackage.Behaviors.Add_View(View_Enum.CITATION);
            thisPackage.Behaviors.Add_View(View_Enum.TRACKING);

            // Add the full text
            if (thisPackage.Behaviors.Text_Searchable)
            {
                thisPackage.Behaviors.Add_View(View_Enum.SEARCH);
            }

            // Is there an embedded video?
            if (thisPackage.Behaviors.Embedded_Video.Length > 0)
            {
                thisPackage.Behaviors.Add_View(View_Enum.EMBEDDED_VIDEO);
            }

            // If there is no PURL, add one based on how SobekCM operates
            if (thisPackage.Bib_Info.Location.PURL.Length == 0)
            {
                thisPackage.Bib_Info.Location.PURL = SobekCM_Library_Settings.System_Base_URL + thisPackage.BibID + "/" + thisPackage.VID;
            }

            // IF this is dark, add no other views
            if (!thisPackage.Behaviors.Dark_Flag)
            {
                // Check to see which views were present from the database, and build the list
                Dictionary <View_Enum, View_Object> viewsFromDb = new Dictionary <View_Enum, View_Object>();
                foreach (DataRow viewRow in databaseInfo.Tables[4].Rows)
                {
                    string viewType  = viewRow[0].ToString();
                    string attribute = viewRow[1].ToString();
                    string label     = viewRow[2].ToString();

                    View_Enum viewTypeEnum = View_Enum.None;
                    switch (viewType)
                    {
                    case "JPEG":
                        viewTypeEnum = View_Enum.JPEG;
                        break;

                    case "JPEG2000":
                        viewTypeEnum = View_Enum.JPEG2000;
                        break;

                    case "Text":
                        viewTypeEnum = View_Enum.TEXT;
                        break;

                    case "Page Turner":
                        viewTypeEnum = View_Enum.PAGE_TURNER;
                        break;

                    case "Google Map":
                        viewTypeEnum = View_Enum.GOOGLE_MAP;
                        break;

                    case "HTML Viewer":
                        viewTypeEnum = View_Enum.HTML;
                        break;

                    case "HTML Map Viewer":
                        viewTypeEnum = View_Enum.HTML_MAP;
                        break;

                    case "Related Images":
                        viewTypeEnum = View_Enum.RELATED_IMAGES;
                        break;

                    case "TOC":
                        viewTypeEnum = View_Enum.TOC;
                        break;

                    case "TEI":
                        viewTypeEnum = View_Enum.TEI;
                        break;
                    }

                    if (viewTypeEnum != View_Enum.None)
                    {
                        viewsFromDb[viewTypeEnum] = new View_Object(viewTypeEnum, label, attribute);
                    }
                }

                // Add the thumbnail view, if requested and has multiple pages
                if (thisPackage.Divisions.Page_Count > 1)
                {
                    if (viewsFromDb.ContainsKey(View_Enum.RELATED_IMAGES))
                    {
                        thisPackage.Behaviors.Add_View(viewsFromDb[View_Enum.RELATED_IMAGES]);
                        viewsFromDb.Remove(View_Enum.RELATED_IMAGES);
                    }

                    thisPackage.Behaviors.Add_View(View_Enum.QUALITY_CONTROL);
                }
                else
                {
                    if (viewsFromDb.ContainsKey(View_Enum.RELATED_IMAGES))
                    {
                        viewsFromDb.Remove(View_Enum.RELATED_IMAGES);
                    }
                }

                // If this item has more than one division, look for the TOC viewer
                if ((thisPackage.Divisions.Has_Multiple_Divisions) && (!thisPackage.Bib_Info.ImageClass))
                {
                    if (viewsFromDb.ContainsKey(View_Enum.TOC))
                    {
                        thisPackage.Behaviors.Add_View(viewsFromDb[View_Enum.TOC]);
                        viewsFromDb.Remove(View_Enum.TOC);
                    }
                }

                // In addition, if there is a latitude or longitude listed, look for the Google Maps
                bool hasCoords = false;
                GeoSpatial_Information geoInfo = (GeoSpatial_Information)thisPackage.Get_Metadata_Module(GlobalVar.GEOSPATIAL_METADATA_MODULE_KEY);
                if ((geoInfo != null) && (geoInfo.hasData))
                {
                    if ((geoInfo.Point_Count > 0) || (geoInfo.Polygon_Count > 0))
                    {
                        hasCoords = true;
                    }
                }
                if (!hasCoords)
                {
                    List <abstract_TreeNode> pageList = thisPackage.Divisions.Physical_Tree.Pages_PreOrder;
                    foreach (abstract_TreeNode thisPage in pageList)
                    {
                        GeoSpatial_Information geoInfo2 = (GeoSpatial_Information)thisPage.Get_Metadata_Module(GlobalVar.GEOSPATIAL_METADATA_MODULE_KEY);
                        if ((geoInfo2 != null) && (geoInfo2.hasData))
                        {
                            if ((geoInfo2.Point_Count > 0) || (geoInfo2.Polygon_Count > 0))
                            {
                                hasCoords = true;
                                break;
                            }
                        }
                    }
                }

                if (hasCoords)
                {
                    if (viewsFromDb.ContainsKey(View_Enum.GOOGLE_MAP))
                    {
                        thisPackage.Behaviors.Add_View(viewsFromDb[View_Enum.GOOGLE_MAP]);
                        viewsFromDb.Remove(View_Enum.GOOGLE_MAP);
                    }
                    else
                    {
                        thisPackage.Behaviors.Add_View(View_Enum.GOOGLE_MAP);
                    }
                }

                // Step through each download and make sure it is fully built
                if (thisPackage.Divisions.Download_Tree.Has_Files)
                {
                    string ead_file                        = String.Empty;
                    int    pdf_download                    = 0;
                    string pdf_download_url                = String.Empty;
                    int    non_flash_downloads             = 0;
                    List <abstract_TreeNode> downloadPages = thisPackage.Divisions.Download_Tree.Pages_PreOrder;
                    foreach (Page_TreeNode downloadPage in downloadPages)
                    {
                        // Was this an EAD page?
                        if ((downloadPage.Label == GlobalVar.EAD_METADATA_MODULE_KEY) && (downloadPage.Files.Count == 1))
                        {
                            ead_file = downloadPage.Files[0].System_Name;
                        }

                        // Was this an XSL/EAD page?
                        if ((downloadPage.Label == "XSL") && (downloadPage.Files.Count == 1))
                        {
                        }

                        // Step through each download file
                        foreach (SobekCM_File_Info thisFile in downloadPage.Files)
                        {
                            if (thisFile.File_Extension == "SWF")
                            {
                                string      flashlabel = downloadPage.Label;
                                View_Object newView    = thisPackage.Behaviors.Add_View(View_Enum.FLASH, flashlabel, String.Empty, thisFile.System_Name);
                                thisPackage.Behaviors.Default_View = newView;
                            }
                            else
                            {
                                non_flash_downloads++;
                            }

                            if (thisFile.File_Extension == "PDF")
                            {
                                pdf_download++;
                                pdf_download_url = thisFile.System_Name;
                            }
                        }
                    }

                    if (((non_flash_downloads > 0) && (pdf_download != 1)) || ((non_flash_downloads > 1) && (pdf_download == 1)))
                    {
                        if (thisPackage.Web.Static_PageCount == 0)
                        {
                            thisPackage.Behaviors.Default_View = thisPackage.Behaviors.Add_View(View_Enum.DOWNLOADS);
                        }
                        else
                        {
                            thisPackage.Behaviors.Add_View(View_Enum.DOWNLOADS);
                        }
                    }

                    if (pdf_download == 1)
                    {
                        if ((thisPackage.Web.Static_PageCount == 0) && (thisPackage.Behaviors.Default_View == null))
                        {
                            thisPackage.Behaviors.Default_View          = thisPackage.Behaviors.Add_View(View_Enum.PDF);
                            thisPackage.Behaviors.Default_View.FileName = pdf_download_url;
                        }
                        else
                        {
                            thisPackage.Behaviors.Add_View(View_Enum.PDF).FileName = pdf_download_url;
                        }
                    }

                    // Some special code for EAD objects
                    if ((thisPackage.Bib_Info.SobekCM_Type == TypeOfResource_SobekCM_Enum.Archival) && (ead_file.Length > 0))
                    {
                        // Now, read this EAD file information
                        string ead_file_location     = SobekCM_Library_Settings.Image_Server_Network + thisPackage.Web.AssocFilePath + ead_file;
                        EAD_File_ReaderWriter reader = new EAD_File_ReaderWriter();
                        string Error_Message;
                        Dictionary <string, object> options = new Dictionary <string, object>();
                        options["EAD_File_ReaderWriter:XSL_Location"] = SobekCM_Library_Settings.System_Base_URL + "default/sobekcm_default.xsl";
                        reader.Read_Metadata(ead_file_location, thisPackage, options, out Error_Message);

                        // Clear all existing views
                        thisPackage.Behaviors.Clear_Views();
                        thisPackage.Behaviors.Add_View(View_Enum.CITATION);
                        thisPackage.Behaviors.Default_View = thisPackage.Behaviors.Add_View(View_Enum.EAD_DESCRIPTION);

                        // Get the metadata module for EADs
                        EAD_Info eadInfo = (EAD_Info)thisPackage.Get_Metadata_Module(GlobalVar.EAD_METADATA_MODULE_KEY);
                        if ((eadInfo != null) && (eadInfo.Container_Hierarchy.Containers.Count > 0))
                        {
                            thisPackage.Behaviors.Add_View(View_Enum.EAD_CONTAINER_LIST);
                        }
                    }
                }
                else
                {
                    if (thisPackage.Bib_Info.SobekCM_Type == TypeOfResource_SobekCM_Enum.Aerial)
                    {
                        thisPackage.Behaviors.Add_View(View_Enum.DOWNLOADS);
                    }
                }

                // If there is a RELATED URL with youtube, add that viewer
                if ((thisPackage.Bib_Info.hasLocationInformation) && (thisPackage.Bib_Info.Location.Other_URL.ToLower().IndexOf("www.youtube.com") >= 0))
                {
                    View_Object newViewObj = new View_Object(View_Enum.YOUTUBE_VIDEO);
                    thisPackage.Behaviors.Add_View(newViewObj);
                    thisPackage.Behaviors.Default_View = newViewObj;
                }

                // Look for the HTML type views next, and possible set some defaults
                if (viewsFromDb.ContainsKey(View_Enum.HTML))
                {
                    thisPackage.Behaviors.Add_View(viewsFromDb[View_Enum.HTML]);
                    thisPackage.Behaviors.Default_View = viewsFromDb[View_Enum.HTML];
                    viewsFromDb.Remove(View_Enum.HTML);
                }

                // Look for the HTML MAP type views next, and possible set some defaults
                if (viewsFromDb.ContainsKey(View_Enum.HTML_MAP))
                {
                    thisPackage.Behaviors.Add_View(viewsFromDb[View_Enum.HTML_MAP]);
                    thisPackage.Behaviors.Default_View = viewsFromDb[View_Enum.HTML_MAP];
                    viewsFromDb.Remove(View_Enum.HTML_MAP);
                }

                // Copy the TEI flag
                if (viewsFromDb.ContainsKey(View_Enum.TEI))
                {
                    thisPackage.Behaviors.Add_View(viewsFromDb[View_Enum.TEI]);
                    viewsFromDb.Remove(View_Enum.HTML);
                }

                // Look to add any index information here ( such as on SANBORN maps)
                Map_Info mapInfo = (Map_Info)thisPackage.Get_Metadata_Module(GlobalVar.SOBEKCM_MAPS_METADATA_MODULE_KEY);
                if (mapInfo != null)
                {
                    // Was there a HTML map here?
                    if (mapInfo.Index_Count > 0)
                    {
                        Map_Index   thisIndex      = mapInfo.Get_Index(0);
                        View_Object newMapSanbView = thisPackage.Behaviors.Add_View(View_Enum.HTML_MAP, thisIndex.Title, thisIndex.Image_File + ";" + thisIndex.HTML_File);
                        thisPackage.Behaviors.Default_View = newMapSanbView;
                    }

                    //// Were there streets?
                    //if (thisPackage.Map.Streets.Count > 0)
                    //{
                    //    returnValue.Item_Views.Add(new ViewerFetcher.Streets_ViewerFetcher());
                    //}

                    //// Were there features?
                    //if (thisPackage.Map.Features.Count > 0)
                    //{
                    //    returnValue.Item_Views.Add(new ViewerFetcher.Features_ViewerFetcher());
                    //}
                }

                // Look for the RELATED IMAGES view next
                if (viewsFromDb.ContainsKey(View_Enum.RELATED_IMAGES))
                {
                    thisPackage.Behaviors.Add_View(viewsFromDb[View_Enum.RELATED_IMAGES]);
                    viewsFromDb.Remove(View_Enum.RELATED_IMAGES);
                }

                // Look for the PAGE TURNER view next
                if (viewsFromDb.ContainsKey(View_Enum.PAGE_TURNER))
                {
                    thisPackage.Behaviors.Add_View(viewsFromDb[View_Enum.PAGE_TURNER]);
                    viewsFromDb.Remove(View_Enum.PAGE_TURNER);
                }

                // Finally, add all the ITEM VIEWS
                foreach (View_Object thisObject in viewsFromDb.Values)
                {
                    switch (thisObject.View_Type)
                    {
                    case View_Enum.TEXT:
                    case View_Enum.JPEG:
                    case View_Enum.JPEG2000:
                        thisPackage.Behaviors.Add_Item_Level_Page_View(thisObject);
                        break;
                    }
                }
            }
        }