Beispiel #1
0
                public void TestDictionary()
                {
                    Variant input = new Variant(Variant.EnumType.Dictionary);
                    input.Add("key1", new Variant("value1"));
                    input.Add("key2", new Variant("value2"));

                    StringBuilder ibuffer = new StringBuilder();
                    System.IO.StringWriter istream = new System.IO.StringWriter(ibuffer);
                    XMLWriter writer = new XMLWriter(istream);
                    writer.Write(input);

                    System.IO.StringReader ostream = new System.IO.StringReader(ibuffer.ToString());
                    XMLReader reader = new XMLReader(ostream);
                    Variant output = reader.Read();

                    Assert.True(input.Equals(output));
                }
    // Use this for initialization
    void Start()
    {
        _Save=new Rect(10,80,100,20);
        _SaveMSG=new Rect(10,120,400,40);

        writer = gameObject.GetComponent<XMLWriter>();

        memoryStream = new MemoryStream();

        xmlGeometrySerializer = new XmlSerializer(typeof(List<Geometry>));
        xmlLightSerializer = new XmlSerializer(typeof(List<OctetLight>));
        xmlRigidBodySerializer = new XmlSerializer(typeof(List<OctetRigidBody>));
        xmlCameraSerializer = new XmlSerializer(typeof(List<OctetCamera>));
        xmlHingeJointSerializer = new XmlSerializer(typeof(List<OctetHingeJoint>));
        xmlSpringJointSerializer = new XmlSerializer(typeof(List<OctetSpringJoint>));

        xmlTextWriter = new XmlTextWriter(memoryStream, Encoding.UTF8);
    }
		public String toString() {
			StringWriter @out = new StringWriter();
			XMLWriter writer = new XMLWriter(@out, OutputFormat.createPrettyPrint());
			try {
				writer.write(element);
			}
			catch (Exception e) { e.printStackTrace(); }
			return @out.ToString();
		}
		public override string ToString()
		{
			StringWriter @out = new StringWriter();
			XMLWriter writer = new XMLWriter(@out, OutputFormat.createPrettyPrint());
			try {
				writer.write(element);
			}
			catch (Exception e) {
				// Ignore.
			}
			return @out.toString();
		}
 public AppSemantic(string type, XMLWriter appXMLWriter)
 {
     this.type = type;
     this.appXMLWriter = appXMLWriter;
 }
Beispiel #6
0
        public MCESchedule(string[] args)
        {
            pdamxBeyondTV      mxBeyondTV;
            DateTimeFormatInfo dtFormat = new CultureInfo("en-US", false).DateTimeFormat;
            pdamxSearchKeyGen  mxSearchKeyGen;
            FileInfo           fiFileSummary;
            Hashtable          hProgramInfo;

            int iNumberOfsActiveRecordings = 0;
            int iNumberOfUpCommingShows    = 0;

            String sBTVNetworkLicense     = "";
            String sBTVNetworkLicenseFile = "";
            String sBTVUserAccessFile     = "";
            String sWebGuideURL           = "";
            String sWebGuideFile          = "";
            String sXMLOutFile            = "";
            String sTVGuideSearchUrl      = "";
            String sTVComSearchUrl        = "";
            String spubDate = "";

            String rootXMLNodeTemplate =
                "&[JobInfo]&"
                + "\n   <ActiveRecordings>&[ActiveRecordings]&\n   </ActiveRecordings>"
                + "\n   <NextRecording>&[NextRecording]&\n   </NextRecording>"
                + "\n   <LastRecording>&[LastRecording]&\n   </LastRecording>"
                + "\n   <UpcomingRecordings NumberOfShows=''>&[UpcommingRecordings]&\n   </UpcomingRecordings>";

            String jobInfoXMLTemplate =
                "\n   <JobInfo>"
                + "\n      <Generated></Generated>"
                + "\n      <Generator></Generator>"
                + "\n      <Machine></Machine>"
                + "\n      <OS></OS>"
                + "\n      <OSVersion></OSVersion>"
                + "\n      <WebGuideServer>"
                + "\n         <WGHost></WGHost>"
                + "\n         <WGPort></WGPort>"
                + "\n         <WGVersion></WGVersion>"
                + "\n      </WebGuideServer>"
                + "\n   </JobInfo>";

            String recordingsXMLTemplate =
                "\n      <Show>"
                + "\n         <Title></Title>"
                + "\n         <EpisodeTitle></EpisodeTitle>"
                + "\n         <Description></Description>"
                + "\n         <Actors></Actors>"
                + "\n         <Credits></Credits>"
                + "\n         <Genre></Genre>"
                + "\n         <Channel></Channel>"
                + "\n         <StationCallSign></StationCallSign>"
                + "\n         <StationName></StationName>"
                + "\n         <TargetStartTime></TargetStartTime>"
                + "\n         <TargetDuration></TargetDuration>"
                + "\n         <ActualStartTime></ActualStartTime>"
                + "\n         <ActualDuration></ActualDuration>"
                + "\n         <OriginalAirDate></OriginalAirDate>"
                + "\n         <Rating></Rating>"
                + "\n         <MovieYear></MovieYear>"
                + "\n         <IsHDBroadcast></IsHDBroadcast>"
                + "\n         <IsHDRecording></IsHDRecording>"
                + "\n         <IsEpisode></IsEpisode>"
                + "\n         <TVGuideSearch></TVGuideSearch>"
                + "\n         <TVDotComSearch></TVDotComSearch>"
                + "\n         <TitleStrongSearchKey></TitleStrongSearchKey>"
                + "\n         <EpisodeStrongSearchKey></EpisodeStrongSearchKey>"
                + "\n      </Show>";

            // Load XML templates into memory...
            XMLWriter.LoadXMLTemplate("rootXMLNodeTemplate", rootXMLNodeTemplate);
            XMLWriter.LoadXMLTemplate("jobInfoXMLTemplate", jobInfoXMLTemplate);
            XMLWriter.LoadXMLTemplate("recordingsXMLTemplate", recordingsXMLTemplate);
            XMLWriter.CopyXMLTemplate("rootXMLNodeTemplate");
            XMLWriter.CopyXMLTemplate("jobInfoXMLTemplate");

            // Check if content should be written to a file...
            if (args.Length > 0)
            {
                sXMLOutFile = args[0];
            }

            // Configuration based on file name + Config.xml automatically loaded...
            // Get BeyondTV network license...
            sBTVNetworkLicenseFile = GetSettings("/MCETV/BeyondTV/License/NetworkLicense");

            if (sBTVNetworkLicenseFile.ToLower().Contains(".edf"))
            {
                sBTVNetworkLicense = Crypter.DecryptFile(sBTVNetworkLicenseFile);
            }
            else
            {
                sBTVNetworkLicense = sBTVNetworkLicenseFile;
            }

            // Get BeyondTV user account...
            sBTVUserAccessFile = GetSettings("/MCETV/BeyondTV/License/User");

            // Get WebGuide url...
            sWebGuideURL = GetSettings("/MCETV/WebGuide/Url");

            // Get WebGuide data file name...
            sWebGuideFile = GetSettings("/MCETV/WebGuide/TempDataFile");

            // Get sechdule output file name...
            if (sXMLOutFile.Length == 0) //Not overriden by file name passed to program...
            {
                if (GetSettings("/MCETV/Schedule/FileWriteEnabled").ToUpper().Equals("YES"))
                {
                    sXMLOutFile = GetSettings("/MCETV/Schedule/ScheduleFile");
                }
            }
            // Get Google search Url...
            sTVGuideSearchUrl = GetSettings("/MCETV/SearchEngines/TVGuideUrl");

            // Get MSN Bing search Url...
            sTVComSearchUrl = GetSettings("/MCETV/SearchEngines/TVCOMUrl");

            // Get TV schedule for MCE from WebGuide services...
            mxBeyondTV = new pdamxBeyondTV(sBTVNetworkLicense, sBTVUserAccessFile);
            getScheduleFromWebGuide(sWebGuideURL, sWebGuideFile);
            XMLReader.Open(sWebGuideFile);
            XMLWriter.SetXMLTemplateElement("jobInfoXMLTemplate", "WGVersion", XMLReader.GetNodeValue("/rss/channel/generator"));
            XMLWriter.SetXMLTemplateElement("jobInfoXMLTemplate", "WGHost", sWebGuideURL.Substring(sWebGuideURL.LastIndexOf("//") + 2, sWebGuideURL.LastIndexOf(":") - (sWebGuideURL.LastIndexOf("//") + 2)));
            XMLWriter.SetXMLTemplateElement("jobInfoXMLTemplate", "WGPort", sWebGuideURL.Substring(sWebGuideURL.LastIndexOf(":") + 1, sWebGuideURL.LastIndexOf(":", (sWebGuideURL.LastIndexOf("/") + 1) - (sWebGuideURL.LastIndexOf(":") + 1))));

            // Get Schedule Information...
            XMLReader.GetNodePath("/rss/channel/item/*");
            String sGenre           = "";
            String sTitle           = "";
            String sEpisodeTitle    = "";
            bool   bActiveRecording = false;

            XMLWriter.CopyXMLTemplate("recordingsXMLTemplate");
            while (XMLReader.MoveNext())
            {
                if (XMLReader.GetXPathNodeIterator().Current.Name.Equals("title"))
                {
                    sEpisodeTitle = "";
                    sTitle        = XMLReader.GetXPathNodeIterator().Current.Value;
                    if (sTitle.Contains(": \""))
                    {
                        int nStartIdx = sTitle.IndexOf(": \"") + 1;
                        sEpisodeTitle = sTitle.Substring(nStartIdx + 2, sTitle.Length - (nStartIdx + 3));
                        sTitle        = sTitle.Substring(0, sTitle.IndexOf(": \""));
                    }
                    if (iNumberOfUpCommingShows > 0)
                    {
                        XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "Genre", sGenre);
                        XMLWriter.InsertXMLAtTemplateElementMarker("rootXMLNodeTemplate", "UpcommingRecordings", "recordingsXMLTemplate");
                        if (bActiveRecording)
                        {
                            bActiveRecording = false;
                            XMLWriter.InsertXMLAtTemplateElementMarker("rootXMLNodeTemplate", "ActiveRecordings", "recordingsXMLTemplate");
                            iNumberOfsActiveRecordings++;
                        }
                        if ((iNumberOfUpCommingShows == 1) && (iNumberOfsActiveRecordings == 0))
                        {
                            XMLWriter.InsertXMLAtTemplateElementMarker("rootXMLNodeTemplate", "NextRecording", "recordingsXMLTemplate");
                        }
                        else if ((iNumberOfUpCommingShows == 2) && (XMLWriter.GetXMLTemplate("NextRecording") == null))
                        {
                            XMLWriter.InsertXMLAtTemplateElementMarker("rootXMLNodeTemplate", "NextRecording", "recordingsXMLTemplate");
                        }
                    }
                    sGenre = "";
                    XMLWriter.CopyXMLTemplate("recordingsXMLTemplate");
                    mxSearchKeyGen = new pdamxSearchKeyGen();
                    mxSearchKeyGen.GenerateKey(sTitle);
                    XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "Title", sTitle);
                    XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "TitleStrongSearchKey", mxSearchKeyGen.StrongKey);
                    XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "TVGuideSearch", sTVGuideSearchUrl + XMLReader.GetXPathNodeIterator().Current.Value);
                    XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "TVDotComSearch", sTVComSearchUrl + XMLReader.GetXPathNodeIterator().Current.Value);

                    if (sEpisodeTitle.Length > 0)
                    {
                        mxSearchKeyGen.GenerateKey(sEpisodeTitle);
                        XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "EpisodeTitle", sEpisodeTitle);
                        XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "EpisodeStrongSearchKey", mxSearchKeyGen.StrongKey);
                    }
                    iNumberOfUpCommingShows++;
                }
                if (XMLReader.GetXPathNodeIterator().Current.Name.Equals("description"))
                {
                    XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "Description", XMLReader.GetXPathNodeIterator().Current.Value);
                }
                if (XMLReader.GetXPathNodeIterator().Current.Name.Equals("pubDate"))
                {
                    int result = DateTime.Compare(Convert.ToDateTime(XMLReader.GetXPathNodeIterator().Current.Value), System.DateTime.Now);
                    if (result < 0)
                    {
                        bActiveRecording = true;
                    }
                    spubDate = XMLReader.GetXPathNodeIterator().Current.Value;
                }
                if (XMLReader.GetXPathNodeIterator().Current.Name.Equals("dc:creator"))
                {
                    String sChannel         = XMLReader.GetXPathNodeIterator().Current.Value.Substring(0, XMLReader.GetXPathNodeIterator().Current.Value.IndexOf(" "));
                    String sStationCallSign = XMLReader.GetXPathNodeIterator().Current.Value.Substring(XMLReader.GetXPathNodeIterator().Current.Value.IndexOf(" ") + 1, (XMLReader.GetXPathNodeIterator().Current.Value.IndexOf("-") - 1) - XMLReader.GetXPathNodeIterator().Current.Value.IndexOf(" "));
                    String sStationName     = XMLReader.GetXPathNodeIterator().Current.Value.Substring(XMLReader.GetXPathNodeIterator().Current.Value.IndexOf("-") + 2, (XMLReader.GetXPathNodeIterator().Current.Value.Length - XMLReader.GetXPathNodeIterator().Current.Value.IndexOf("-")) - 2);

                    hProgramInfo = GetBTVProgramInfo(mxBeyondTV.SearchGuideAll(sTitle.Trim()), spubDate, sChannel);
                    if (hProgramInfo != null)
                    {
                        XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "Actors", (hProgramInfo["Actors"] != null ? hProgramInfo["Actors"].ToString() : ""));
                        XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "Credits", (hProgramInfo["Credits"] != null ? hProgramInfo["Credits"].ToString() : ""));
                        XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "Genre", (hProgramInfo["Genre"] != null ? hProgramInfo["Genre"].ToString() : ""));
                        XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "TargetStartTime", DateTime.FromFileTime(Convert.ToInt64(hProgramInfo["Start"].ToString())).ToString("MM/dd/yyyy (hh:mm:ss tt)", dtFormat));
                        XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "TargetDuration", pdamxUtility.FormatNanoseconds(hProgramInfo["Duration"].ToString()));
                        XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "ActualStartTime", DateTime.FromFileTime(Convert.ToInt64(hProgramInfo["Start"].ToString())).ToString("MM/dd/yyyy (hh:mm:ss tt)", dtFormat));
                        XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "ActualDuration", pdamxUtility.FormatNanoseconds(hProgramInfo["Duration"].ToString()));

                        if (hProgramInfo["OriginalAirDate"] == null)
                        {
                            XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "OriginalAirDate", "");
                        }
                        else
                        {
                            if (hProgramInfo["OriginalAirDate"].ToString() == "")
                            {
                                XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "OriginalAirDate", "");
                            }
                            else
                            {
                                DateTime startTime = new DateTime(Convert.ToInt32(hProgramInfo["OriginalAirDate"].ToString().Substring(0, 4)),
                                                                  Convert.ToInt32(hProgramInfo["OriginalAirDate"].ToString().Substring(4, 2)),
                                                                  Convert.ToInt32(hProgramInfo["OriginalAirDate"].ToString().Substring(6, 2)));
                                XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "OriginalAirDate", startTime.ToString("d", dtFormat));
                            }
                        }
                        XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "OriginalAirDate", (hProgramInfo["OriginalAirDate"] != null ? hProgramInfo["OriginalAirDate"].ToString() : ""));
                        XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "Rating", (hProgramInfo["Rating"] != null ? hProgramInfo["Rating"].ToString() : ""));
                        XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "MovieYear", (hProgramInfo["MovieYear"] != null ? hProgramInfo["MovieYear"].ToString() : ""));
                        XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "IsHDBroadcast", (hProgramInfo["IsHD"] != null ? (hProgramInfo["IsHD"].ToString() == "Y" ? "Yes" : "No") : "No"));
                        XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "IsHDRecording", "No");
                        XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "IsEpisode", (hProgramInfo["EpisodeDescription"] != null ? "Yes" : "No"));
                    }
                    else
                    {
                        DateTime startTime = Convert.ToDateTime(spubDate);
                        XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "Actors", "");
                        XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "Credits", "");
                        XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "Genre", sGenre);
                        XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "TargetStartTime", startTime.ToString("MM/dd/yyyy (hh:mm:ss tt)", dtFormat));
                        XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "TargetDuration", "");
                        XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "ActualStartTime", startTime.ToString("MM/dd/yyyy (hh:mm:ss tt)", dtFormat));
                        XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "ActualDuration", "");
                        XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "OriginalAirDate", "");
                        XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "Rating", "");
                        XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "MovieYear", "");
                        XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "IsHDBroadcast", "No");
                        XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "IsHDRecording", "No");
                        XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "IsEpisode", "No");
                    }
                    XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "Channel", sChannel.Trim());
                    XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "StationCallSign", sStationCallSign.Trim());
                    XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "StationName", sStationName.Trim());
                }
                if (XMLReader.GetXPathNodeIterator().Current.Name.Equals("category"))
                {
                    if (sGenre != "")
                    {
                        sGenre = sGenre + "/";
                    }
                    sGenre = sGenre + XMLReader.GetXPathNodeIterator().Current.Value.Trim();
                }
            }
            // Delete WebGuide data file...
            FileInfo fiTempFileInfo = new FileInfo(sWebGuideFile);

            fiTempFileInfo.Delete();

            // Get last recording...
            XMLWriter.SetXMLTemplateElement("recordingsXMLTemplate", "Genre", sGenre);
            XMLWriter.InsertXMLAtTemplateElementMarker("rootXMLNodeTemplate", "LastRecording", "recordingsXMLTemplate");

            //Write XML content to console stream or file...
            XMLWriter.SetXMLTemplateElement("jobInfoXMLTemplate", "Generated", StartTime);
            XMLWriter.SetXMLTemplateElement("jobInfoXMLTemplate", "Generator", Program);
            XMLWriter.SetXMLTemplateElement("jobInfoXMLTemplate", "Machine", Machine);
            XMLWriter.SetXMLTemplateElement("jobInfoXMLTemplate", "OS", OS);
            XMLWriter.SetXMLTemplateElement("jobInfoXMLTemplate", "OSVersion", OSVersion);

            XMLWriter.SetXMLTemplateElementAttribute("rootXMLNodeTemplate", "UpcomingRecordings", "NumberOfShows", Convert.ToString(iNumberOfUpCommingShows));
            XMLWriter.ReplactXMPTemplateElementMarker("rootXMLNodeTemplate", "JobInfo", "jobInfoXMLTemplate");

            if (sXMLOutFile != "") //Write to file...
            {
                XMLWriter.Open(sXMLOutFile);
                XMLWriter.RootNode  = "MCETV";
                XMLWriter.DTD       = "DTD/" + pdamxUtility.StripPath(sXMLOutFile, true);
                XMLWriter.Namespace = "http://www.pdamediax.com/mce";
                XMLWriter.Write(XMLWriter.GetXMLTemplate("rootXMLNodeTemplate"));
                XMLWriter.Close();
            }
            else
            {
                Console.WriteLine(XMLWriter.GetXMLTemplate("rootXMLNodeTemplate"));
            }
            WriteEndofJobSummaryToFile = true;
            AddSummaryExtra("");
            AddSummaryExtra("MCE Scheduling Summary");
            AddSummaryExtra("");
            AddSummaryExtra("  Number of Up Comming Shows:  " + pdamxUtility.FormatNumber(iNumberOfUpCommingShows));
            AddSummaryExtra("  Number of Active Shows:      " + pdamxUtility.FormatNumber(iNumberOfsActiveRecordings));

            if (sXMLOutFile != "") //Write to file...
            {
                fiFileSummary = new FileInfo(sXMLOutFile);
                AddSummaryExtra("");
                AddSummaryExtra("MCE XML Schedule Data File Information");
                AddSummaryExtra("");
                AddSummaryExtra("  Name:      " + fiFileSummary.Name);
                AddSummaryExtra("  Location:  " + fiFileSummary.Directory);
                AddSummaryExtra("  Size:      " + pdamxUtility.FormatStorageSize(Convert.ToString(fiFileSummary.Length)));
                AddSummaryExtra("  Created:   " + fiFileSummary.LastWriteTime.ToString("MM/dd/yyyy (hh:mm:ss tt)", dtFormat));
            }
            PrintEndofJobSummary();
            return;
        }
Beispiel #7
0
        public TivoNowPlaying()
        {
            pdamxTivo mxTivo;
            Hashtable hResultSet;
            FileInfo  fiFileInfo;
            String    sNowPlayingFile;
            String    sSettopName = "";

            String jobInfoXMLTemplate =
                "\n   <JobInfo>"
                + "\n      <Generated></Generated>"
                + "\n      <Generator></Generator>"
                + "\n      <Machine></Machine>"
                + "\n      <OS></OS>"
                + "\n      <OSVersion></OSVersion>"
                + "\n   </JobInfo>";

            String summaryXMLTemplate =
                "\n    <Summary>"
                + "\n      <SettopName></SettopName>"
                + "\n      <SettopIP></SettopIP>"
                + "\n      <SettopUrl></SettopUrl>"
                + "\n      <MediaKey></MediaKey>"
                + "\n      <ScheduledRecordings></ScheduledRecordings>"
                + "\n      <TotalItems></TotalItems>"
                + "\n      <GlobalSort></GlobalSort>"
                + "\n      <SortOrder></SortOrder>"
                + "\n      <TotalStorageUsed></TotalStorageUsed>"
                + "\n      <TotalStoragedUsedByTivoSuggestions></TotalStoragedUsedByTivoSuggestions>"
                + "\n      <TotalSStorageUsedByScheduledRecordings></TotalSStorageUsedByScheduledRecordings>"
                + "\n      <TotalRecordingTime></TotalRecordingTime>"
                + "\n      <TotalRecordingTimeOfTivoSuggestions></TotalRecordingTimeOfTivoSuggestions>"
                + "\n      <TotalRecordingTimeOfScheduledRecordings></TotalRecordingTimeOfScheduledRecordings>"
                + "\n      <UFTotalStorageUsed></UFTotalStorageUsed>"
                + "\n      <UFTotalStoragedUsedByTivoSuggestions></UFTotalStoragedUsedByTivoSuggestions>"
                + "\n      <UFTotalSStorageUsedByScheduledRecordings></UFTotalSStorageUsedByScheduledRecordings>"
                + "\n      <UFTotalRecordingTime></UFTotalRecordingTime>"
                + "\n      <UFTotalRecordingTimeOfTivoSuggestions></UFTotalRecordingTimeOfTivoSuggestions>"
                + "\n      <UFTotalRecordingTimeOfScheduledRecordings></UFTotalRecordingTimeOfScheduledRecordings>"
                + "\n    </Summary>";

            String showXMLTemplate =
                "\n    <Show>"
                + "\n      <Title></Title>"
                + "\n      <ProgramId></ProgramId>"
                + "\n      <EpisodeTitle></EpisodeTitle>"
                + "\n      <EpisodeNumber></EpisodeNumber>"
                + "\n      <Description></Description>"
                + "\n      <Credits></Credits>"
                + "\n      <Genre></Genre>"
                + "\n      <MovieYear></MovieYear>"
                + "\n      <Channel></Channel>"
                + "\n      <StationName></StationName>"
                + "\n      <NetworkAffiliate></NetworkAffiliate>"
                + "\n      <PlayTime></PlayTime>"
                + "\n      <UFPlayTime></UFPlayTime>"
                + "\n      <ParentalRating></ParentalRating>"
                + "\n      <Advisory></Advisory>"
                + "\n      <StarRating></StarRating>"
                + "\n      <IsHDContent></IsHDContent>"
                + "\n      <IsRecording></IsRecording>"
                + "\n      <Recorded></Recorded>"
                + "\n      <StartTime></StartTime>"
                + "\n      <StopTime></StopTime>"
                + "\n      <TivoSuggestion></TivoSuggestion>"
                + "\n      <VidoeSize></VidoeSize>"
                + "\n      <UFVidoeSize></UFVidoeSize>"
                + "\n      <DownloadUrl></DownloadUrl>"
                + "\n      <SearchAll>All</SearchAll>"
                + "\n      <TitleStrongSearchKey></TitleStrongSearchKey>"
                + "\n      <EpisodeStrongSearchKey></EpisodeStrongSearchKey>"
                + "\n    </Show>";

            // Load XML templates into memory...
            XMLWriter.LoadXMLTemplate("jobInfoXMLTemplate", jobInfoXMLTemplate);
            XMLWriter.LoadXMLTemplate("summaryXMLTemplate", summaryXMLTemplate);
            XMLWriter.LoadXMLTemplate("showXMLTemplate", showXMLTemplate);

            sNowPlayingFile = GetSettings("/Tivo/NowPlayingFile");
            mxTivo          = new pdamxTivo();

            hResultSet = mxTivo.GetTivoNowPlayingList(GetSettings("/Tivo/TivoBoxUrl").Replace("Container=", "Container1="),
                                                      GetSettings("/Tivo/Credentals"),
                                                      GetSettings("/Tivo/TempDataFile"));

            if (hResultSet != null)
            {
                /*
                 * if (hResultSet.Count > 0)
                 * {
                 *  Hashtable hRecord = (Hashtable)hResultSet["1"];
                 *  if (hRecord != null)
                 *  {
                 *      if (hRecord["Title"] != null)
                 *          sSettopName = hRecord["Title"].ToString();
                 *  }
                 * }
                 * */
                if (hResultSet["Title"] != null)
                {
                    sSettopName = hResultSet["Title"].ToString();
                }
            }
            hResultSet = mxTivo.GetTivoNowPlayingList(GetSettings("/Tivo/TivoBoxUrl"),
                                                      GetSettings("/Tivo/Credentals"),
                                                      GetSettings("/Tivo/TempDataFile"));

            if (hResultSet != null)
            {
                if (hResultSet.Count > 0)
                {
                    XMLWriter.Open("result-" + GetSettings("/Tivo/TempDataFile"));
                    XMLWriter.RootNode  = "TivoNowPlaying";
                    XMLWriter.Namespace = "http://www.pdamediax.com/tivonowplaying";

                    XMLWriter.CopyXMLTemplate("jobInfoXMLTemplate");
                    XMLWriter.SetXMLTemplateElement("jobInfoXMLTemplate", "Generated", StartTime);
                    XMLWriter.SetXMLTemplateElement("jobInfoXMLTemplate", "Generator", Program);
                    XMLWriter.SetXMLTemplateElement("jobInfoXMLTemplate", "Machine", Machine);
                    XMLWriter.SetXMLTemplateElement("jobInfoXMLTemplate", "OS", OS);
                    XMLWriter.SetXMLTemplateElement("jobInfoXMLTemplate", "OSVersion", OSVersion);
                    XMLWriter.Write(XMLWriter.GetXMLTemplate("jobInfoXMLTemplate"));

                    XMLWriter.CopyXMLTemplate("summaryXMLTemplate");
                    XMLWriter.SetXMLTemplateElement("summaryXMLTemplate", "SettopName", sSettopName);
                    XMLWriter.SetXMLTemplateElement("summaryXMLTemplate", "SettopIP", hResultSet["SettopIP"].ToString());
                    XMLWriter.SetXMLTemplateElement("summaryXMLTemplate", "SettopUrl", hResultSet["SettopUrl"].ToString());
                    XMLWriter.SetXMLTemplateElement("summaryXMLTemplate", "MediaKey", hResultSet["MediaKey"].ToString());
                    XMLWriter.SetXMLTemplateElement("summaryXMLTemplate", "ScheduledRecordings", hResultSet["ScheduledRecordings"].ToString());
                    XMLWriter.SetXMLTemplateElement("summaryXMLTemplate", "TotalItems", hResultSet["ProcessCount"].ToString());
                    XMLWriter.SetXMLTemplateElement("summaryXMLTemplate", "GlobalSort", hResultSet["GlobalSort"].ToString());
                    XMLWriter.SetXMLTemplateElement("summaryXMLTemplate", "SortOrder", hResultSet["SortOrder"].ToString());
                    XMLWriter.SetXMLTemplateElement("summaryXMLTemplate", "TotalStorageUsed", hResultSet["TotalStorageUsed"].ToString());
                    XMLWriter.SetXMLTemplateElement("summaryXMLTemplate", "TotalStoragedUsedByTivoSuggestions", hResultSet["TotalStoragedUsedByTivoSuggestions"].ToString());
                    XMLWriter.SetXMLTemplateElement("summaryXMLTemplate", "TotalSStorageUsedByScheduledRecordings", hResultSet["TotalSStorageUsedByScheduledRecordings"].ToString());
                    XMLWriter.SetXMLTemplateElement("summaryXMLTemplate", "UFTotalStorageUsed", hResultSet["UFTotalStorageUsed"].ToString());
                    XMLWriter.SetXMLTemplateElement("summaryXMLTemplate", "UFTotalStoragedUsedByTivoSuggestions", hResultSet["UFTotalStoragedUsedByTivoSuggestions"].ToString());
                    XMLWriter.SetXMLTemplateElement("summaryXMLTemplate", "UFTotalSStorageUsedByScheduledRecordings", hResultSet["UFTotalSStorageUsedByScheduledRecordings"].ToString());
                    XMLWriter.SetXMLTemplateElement("summaryXMLTemplate", "TotalRecordingTime", hResultSet["TotalRecordingTime"].ToString());
                    XMLWriter.SetXMLTemplateElement("summaryXMLTemplate", "TotalRecordingTimeOfTivoSuggestions", hResultSet["TotalRecordingTimeOfTivoSuggestions"].ToString());
                    XMLWriter.SetXMLTemplateElement("summaryXMLTemplate", "TotalRecordingTimeOfScheduledRecordings", hResultSet["TotalRecordingTimeOfScheduledRecordings"].ToString());
                    XMLWriter.SetXMLTemplateElement("summaryXMLTemplate", "UFTotalRecordingTime", hResultSet["UFTotalRecordingTime"].ToString());
                    XMLWriter.SetXMLTemplateElement("summaryXMLTemplate", "UFTotalRecordingTimeOfTivoSuggestions", hResultSet["UFTotalRecordingTimeOfTivoSuggestions"].ToString());
                    XMLWriter.SetXMLTemplateElement("summaryXMLTemplate", "UFTotalRecordingTimeOfScheduledRecordings", hResultSet["UFTotalRecordingTimeOfScheduledRecordings"].ToString());
                    XMLWriter.Write(XMLWriter.GetXMLTemplate("summaryXMLTemplate"));

                    int nMaxRows = Convert.ToInt32(hResultSet["ProcessCount"].ToString());
                    XMLWriter.Write("\n  <ShowList>");
                    for (int nRowCnt = 0; nRowCnt < nMaxRows;)
                    {
                        XMLWriter.CopyXMLTemplate("showXMLTemplate");
                        Hashtable hRecord = (Hashtable)hResultSet[Convert.ToString(++nRowCnt)];
                        XMLWriter.SetXMLTemplateElement("showXMLTemplate", "Title", hRecord["Title"].ToString());
                        XMLWriter.SetXMLTemplateElement("showXMLTemplate", "ProgramId", hRecord["ProgramId"].ToString());
                        XMLWriter.SetXMLTemplateElement("showXMLTemplate", "EpisodeTitle", hRecord["EpisodeTitle"].ToString());
                        XMLWriter.SetXMLTemplateElement("showXMLTemplate", "EpisodeNumber", hRecord["EpisodeNumber"].ToString());
                        XMLWriter.SetXMLTemplateElement("showXMLTemplate", "Description", hRecord["Description"].ToString());
                        XMLWriter.SetXMLTemplateElement("showXMLTemplate", "Credits", hRecord["Credits"].ToString());
                        XMLWriter.SetXMLTemplateElement("showXMLTemplate", "Genre", hRecord["Genre"].ToString());
                        XMLWriter.SetXMLTemplateElement("showXMLTemplate", "MovieYear", hRecord["MovieYear"].ToString());
                        XMLWriter.SetXMLTemplateElement("showXMLTemplate", "Channel", hRecord["Channel"].ToString());
                        XMLWriter.SetXMLTemplateElement("showXMLTemplate", "StationName", hRecord["StationName"].ToString());
                        XMLWriter.SetXMLTemplateElement("showXMLTemplate", "NetworkAffiliate", hRecord["NetworkAffiliate"].ToString());
                        XMLWriter.SetXMLTemplateElement("showXMLTemplate", "PlayTime", hRecord["Duration"].ToString());
                        XMLWriter.SetXMLTemplateElement("showXMLTemplate", "UFPlayTime", hRecord["UFDuration"].ToString());
                        XMLWriter.SetXMLTemplateElement("showXMLTemplate", "ParentalRating", hRecord["ParentalRating"].ToString());
                        XMLWriter.SetXMLTemplateElement("showXMLTemplate", "Advisory", hRecord["Advisory"].ToString());
                        XMLWriter.SetXMLTemplateElement("showXMLTemplate", "StarRating", hRecord["StarRating"].ToString());
                        XMLWriter.SetXMLTemplateElement("showXMLTemplate", "IsHDContent", hRecord["IsHDContent"].ToString());
                        XMLWriter.SetXMLTemplateElement("showXMLTemplate", "IsRecording", hRecord["IsRecording"].ToString());
                        XMLWriter.SetXMLTemplateElement("showXMLTemplate", "Recorded", hRecord["Recorded"].ToString());
                        XMLWriter.SetXMLTemplateElement("showXMLTemplate", "StartTime", hRecord["StartTime"].ToString());
                        XMLWriter.SetXMLTemplateElement("showXMLTemplate", "StopTime", hRecord["StopTime"].ToString());
                        XMLWriter.SetXMLTemplateElement("showXMLTemplate", "TivoSuggestion", hRecord["TivoSuggestion"].ToString());
                        XMLWriter.SetXMLTemplateElement("showXMLTemplate", "VidoeSize", hRecord["VidoeSize"].ToString());
                        XMLWriter.SetXMLTemplateElement("showXMLTemplate", "UFVidoeSize", hRecord["UFVidoeSize"].ToString());


                        XMLWriter.SetXMLTemplateElement("showXMLTemplate", "DownloadUrl", hRecord["DownloadUrl"].ToString());
                        XMLWriter.SetXMLTemplateElement("showXMLTemplate", "TitleStrongSearchKey", hRecord["TitleStrongSearchKey"].ToString());
                        XMLWriter.SetXMLTemplateElement("showXMLTemplate", "EpisodeStrongSearchKey", hRecord["EpisodeStrongSearchKey"].ToString());
                        XMLWriter.Write(XMLWriter.GetXMLTemplate("showXMLTemplate"));
                    }
                    XMLWriter.Write("\n  </ShowList>");
                    XMLWriter.Close();
                    File.Copy("result-" + GetSettings("/Tivo/TempDataFile"), sNowPlayingFile, true);
                    fiFileInfo = new FileInfo("result-" + GetSettings("/Tivo/TempDataFile"));
                    fiFileInfo.Delete();
                }
            }
        }
Beispiel #8
0
 private void bttGenerateXML_Click(object sender, EventArgs e)
 {
     XMLWriter x = new XMLWriter(txtDatabaseName.Text, txtUserName.Text, RijandaelClass.EncryptRijandel(txtPassword.Text));
     x.WriteXML();
 }
Beispiel #9
0
        public static void WriteConfig(ConfigData data, string file)
        {
            XMLWriter configWriter = new XMLWriter(file);

            configWriter.CreateDocWithRoot("Settings", "Configuration definition of Sprite Vortex");
            //-----------------------------------------------------------------------------------------------------
            configWriter.OpenNewElement("GeneralSettings");


            //-----------------------------------------------------------------------------------------------------
            configWriter.AddCompleteElementWithAttribute("CameraSpeed", "Value",
                                                         GlobalizationHelper.FormatNumber(data.CameraSpeed));
            configWriter.AddCompleteElementWithAttribute("BackgroundColor", "Value",
                                                         data.BackgroundColor.Argb.ToString());
            configWriter.AddCompleteElementWithAttribute("FrameRectColor", "Value", data.FrameRectColor.Argb.ToString());
            configWriter.AddCompleteElementWithAttribute("HoverFrameRectColor", "Value",
                                                         data.HoverFrameRectColor.Argb.ToString());
            configWriter.AddCompleteElementWithAttribute("SelectedFrameRectColor", "Value",
                                                         data.SelectedFrameRectColor.Argb.ToString());
            configWriter.AddCompleteElementWithAttribute("TextureFilterMode", "Value",
                                                         Enum.GetName(typeof(TextureFilter), data.TextureFilterMode));
            configWriter.AddCompleteElementWithAttribute("FrameMargin", "Value",
                                                         GlobalizationHelper.FormatNumber(data.FrameMargin));
            //-----------------------------------------------------------------------------------------------------

            configWriter.CloseCurrentElement();
            //-----------------------------------------------------------------------------------------------------
            //-----------------------------------------------------------------------------------------------------

            configWriter.OpenNewElement("CommandSettings");
            //-----------------------------------------------------------------------------------------------------

            configWriter.OpenNewElement("SpriteMarkup");
            configWriter.AddAttribute("Key",
                                      data.SpriteMarkUpControl.Key != null
                                          ? data.SpriteMarkUpControl.Key.ToString()
                                          : "none");
            configWriter.AddAttribute("Button", Enum.GetName(typeof(MouseButton), data.SpriteMarkUpControl.MouseButton));
            configWriter.CloseCurrentElement();
            //-----------------------------------------------------------------------------------------------------
            //-----------------------------------------------------------------------------------------------------
            configWriter.OpenNewElement("DragCamera");
            configWriter.AddAttribute("Key",
                                      data.DragCameraControl.Key != null
                                          ? data.DragCameraControl.Key.ToString()
                                          : "none");
            configWriter.AddAttribute("Button", Enum.GetName(typeof(MouseButton), data.DragCameraControl.MouseButton));
            configWriter.CloseCurrentElement();
            //-----------------------------------------------------------------------------------------------------
            //-----------------------------------------------------------------------------------------------------
            configWriter.OpenNewElement("SelectSprite");
            configWriter.AddAttribute("Key",
                                      data.SelectSpriteControl.Key != null
                                          ? data.SelectSpriteControl.Key.ToString()
                                          : "none");
            configWriter.AddAttribute("Button", Enum.GetName(typeof(MouseButton), data.SelectSpriteControl.MouseButton));
            configWriter.CloseCurrentElement();
            //-----------------------------------------------------------------------------------------------------
            //-----------------------------------------------------------------------------------------------------
            configWriter.OpenNewElement("ViewZoom");
            configWriter.AddAttribute("Key",
                                      data.ViewZoomControl.Key != null ? data.ViewZoomControl.Key.ToString() : "none");
            configWriter.AddAttribute("Button", Enum.GetName(typeof(MouseButton), data.ViewZoomControl.MouseButton));
            configWriter.CloseCurrentElement();
            //-----------------------------------------------------------------------------------------------------


            configWriter.CloseCurrentElement();

            //-----------------------------------------------------------------------------------------------------
            configWriter.OpenNewElement("ExportingSettings");

            //-----------------------------------------------------------------------------------------------------
            configWriter.OpenNewElement("ImageOverwriteWhenTransparencyModified");
            configWriter.AddAttribute("Value", data.OverwriteImageWhenTransparencyModified.ToString());
            configWriter.CloseCurrentElement();
            //-----------------------------------------------------------------------------------------------------

            //-----------------------------------------------------------------------------------------------------
            configWriter.OpenNewElement("PackSpriteSheet");
            configWriter.AddAttribute("Value", data.PackSpriteSheetWhenExportingSpriteMap.ToString());
            configWriter.CloseCurrentElement();
            //-----------------------------------------------------------------------------------------------------

            //-----------------------------------------------------------------------------------------------------
            configWriter.OpenNewElement("ForcePowTwo");
            configWriter.AddAttribute("Value", data.ForcePowTwo.ToString());
            configWriter.CloseCurrentElement();
            //-----------------------------------------------------------------------------------------------------


            //-----------------------------------------------------------------------------------------------------
            configWriter.OpenNewElement("ForceSquare");
            configWriter.AddAttribute("Value", data.ForceSquare.ToString());
            configWriter.CloseCurrentElement();
            //-----------------------------------------------------------------------------------------------------

            //-----------------------------------------------------------------------------------------------------
            configWriter.OpenNewElement("Padding");
            configWriter.AddAttribute("Value", data.Padding.ToString());
            configWriter.CloseCurrentElement();
            //-----------------------------------------------------------------------------------------------------

            configWriter.CloseCurrentElement();

            configWriter.Save();
        }
Beispiel #10
0
        // example args: -input.path=D:\some\path\to\images\here -filter=*.jpg -prefix=team -output.extension=jpg -output.path= -output.resize=240
        static void Main(string[] args)
        {
            string folder         = null;
            string filter         = "*.*";
            string atlasPath      = Directory.GetCurrentDirectory();
            string cssPath        = null;
            string jsonPath       = null;
            string xmlPath        = null;
            string csvPath        = null;
            string atlasExtension = "jpg";
            string prefix         = null;
            int    resize         = 0;

            var  globalMargin = new Margin();
            bool normalize    = false;

            foreach (var entry in args)
            {
                var arg = entry;

                if (!arg.StartsWith("-"))
                {
                    Console.WriteLine("Invalid argument: " + arg);
                    return;
                }

                arg = arg.Substring(1);

                var temp = arg.Split(new char[] { '=' }, 2);

                var key = temp[0].ToLower();
                var val = temp.Length == 2 ? temp[1] : null;

                switch (key)
                {
                case "input.path": folder = val; break;

                case "input.filter": filter = val; break;

                case "prefix": prefix = val; break;

                case "atlas.extension": atlasExtension = val.Replace(".", ""); break;

                case "atlas.path": atlasPath = val; break;

                case "resize": resize = int.Parse(val); break;

                case "css.path": cssPath = val; break;

                case "json.path": jsonPath = val; break;

                case "xml.path": xmlPath = val; break;

                case "csv.path": csvPath = val; break;

                case "margin.X": globalMargin.X = int.Parse(val); break;

                case "margin.Y": globalMargin.Y = int.Parse(val); break;

                case "margin": globalMargin.X = int.Parse(val); globalMargin.Y = globalMargin.X; break;

                case "normalize": normalize = bool.Parse(val); break;
                }
            }

            if (normalize && resize > 0)
            {
                Console.WriteLine("Normalize and resize options are mutually exclusive.");
                return;
            }

            FixPath(ref atlasPath);
            FixPath(ref cssPath);
            FixPath(ref jsonPath);
            FixPath(ref xmlPath);
            FixPath(ref csvPath);

            if (folder == null)
            {
                Console.WriteLine("Please specify a folder. Eg: -input.path=some_path");
                return;
            }

            if (prefix == null)
            {
                Console.WriteLine("Please specify a atlas prefix. Eg: --prefix=something");
                return;
            }

            var outPicName = prefix + "." + atlasExtension;
            var outCSSName = prefix + ".css";

            var files = Directory.GetFiles(folder, filter);

            var images = new Dictionary <string, Bitmap>();

            int count = 0;

            int avgWidth  = 0;
            int avgHeight = 0;

            int maxWidth  = 0;
            int maxHeight = 0;

            foreach (var file in files)
            {
                var img = new Bitmap(Bitmap.FromFile(file));

                if (resize != 0)
                {
                    img = new Bitmap(img, new Size(resize, resize));
                }

                images[file] = img;
                count++;

                maxWidth  = Math.Max(maxWidth, img.Width);
                maxHeight = Math.Max(maxHeight, img.Height);

                avgWidth  += img.Width;
                avgHeight += img.Height;
            }

            int maxSize = Math.Max(maxHeight, maxWidth);

            avgWidth  /= count;
            avgHeight /= count;

            int side = (int)Math.Ceiling(Math.Sqrt(count));

            int atlasWidth  = avgWidth * side;
            int atlasHeight = avgHeight * side;

            int tot;

            int tries = 0;
            RectanglePacker <string> packer;

            var margins = new Dictionary <string, Margin>();

            if (normalize)
            {
                foreach (var file in files)
                {
                    var img    = images[file];
                    var margin = new Margin()
                    {
                        X = (maxSize - img.Width) / 2 + globalMargin.X,
                        Y = (maxSize - img.Height) / 2 + globalMargin.Y,
                    };
                    margins[file] = margin;
                }
            }
            else
            {
                foreach (var file in files)
                {
                    margins[file] = globalMargin;
                }
            }

            do
            {
                packer = new RectanglePacker <string>();


                foreach (var entry in images)
                {
                    var margin = margins[entry.Key];
                    packer.AddRect(entry.Value.Width + margin.X * 2, entry.Value.Height + margin.Y * 2, entry.Key);
                }

                tot = packer.Pack(0, 0, atlasWidth, atlasHeight);
                if (tot == 0)
                {
                    break;
                }

                if (tries % 2 == 0)
                {
                    atlasWidth *= 2;
                }
                else
                {
                    atlasHeight *= 2;
                }

                tries++;
                if (tries > 5)
                {
                    break;
                }
            } while (true);

            if (tot == 0)
            {
                var output = new Bitmap(atlasWidth, atlasHeight);

                using (Graphics g = Graphics.FromImage(output))
                {
                    foreach (var file in files)
                    {
                        int x, y;
                        packer.GetRect(file, out x, out y);

                        var margin = margins[file];
                        x += margin.X;
                        y += margin.Y;

                        var img = images[file];
                        g.DrawImage(img, x, y, img.Width, img.Height);

                        Console.WriteLine("Merged " + file);
                    }
                }

                output.Save(atlasPath + outPicName);

                Console.WriteLine("Generated " + atlasPath + outPicName);

                if (cssPath != null)
                {
                    var sb = new StringBuilder();

                    int index = 0;
                    foreach (var file in files)
                    {
                        var name = Path.GetFileNameWithoutExtension(file).ToLower();

                        if (index > 0)
                        {
                            sb.Append(", ");
                        }

                        if (index % side == side - 1)
                        {
                            sb.AppendLine();
                        }

                        sb.Append($".{prefix}-{name}");

                        index++;
                    }

                    sb.Append('{');
                    sb.AppendLine();
                    sb.AppendLine($"\tbackground-image: url('{outPicName}');");
                    sb.AppendLine("\tbackground-repeat: no-repeat;");
                    sb.Append('}');
                    sb.AppendLine();

                    foreach (var file in files)
                    {
                        int x, y;
                        packer.GetRect(file, out x, out y);

                        var margin = margins[file];
                        x += margin.X;
                        y += margin.Y;

                        var name = Path.GetFileNameWithoutExtension(file).ToLower();
                        var img  = images[file];

                        sb.AppendLine();
                        sb.AppendLine("." + prefix + "-" + name + " {");
                        sb.AppendLine($"\twidth: {img.Width}px;");
                        sb.AppendLine($"\theight: {img.Height}px;");
                        sb.AppendLine($"\tbackground-position: -{x}px -{y}px;");
                        sb.Append('}');
                        sb.AppendLine();
                    }

                    File.WriteAllText(cssPath + outCSSName, sb.ToString());

                    Console.WriteLine("Generated " + cssPath + outCSSName);
                }

                if (xmlPath != null || csvPath != null || jsonPath != null)
                {
                    if (jsonPath != null)
                    {
                        var node = ExportToNode(files, images, margins, packer, false);
                        var json = JSONWriter.WriteToString(node);
                        File.WriteAllText(jsonPath + prefix + ".json", json);
                    }

                    if (xmlPath != null)
                    {
                        var node = ExportToNode(files, images, margins, packer, true);
                        var xml  = XMLWriter.WriteToString(node);
                        File.WriteAllText(xmlPath + prefix + ".xml", xml);
                    }

                    if (csvPath != null)
                    {
                        var node = ExportToNode(files, images, margins, packer, false);
                        var csv  = CSVWriter.WriteToString(node);
                        File.WriteAllText(csvPath + prefix + ".csv", csv);
                    }
                }
            }
            else
            {
                Console.WriteLine("Failed packing...");
            }
        }