Ejemplo n.º 1
0
        private void OldSchoolGrabbing(OfflineCacheData ocd2)
        {
            // La vielle méthode un peu incimpréhensible qui marche
            bool bSpoilersAlreadyInDescription = false;

            // Build images to download from description
            if (ocd2._descHTML == "")
            {
                // Nothing to do for the description
            }
            else
            {
                // Description present, looking for img url's
                ocd2._descHTML = "<html><body>" + ocd2._descHTML + "</body></html>";
                // Parse HTML description  to retrieve images
                // Load the Html into the agility pack
                HtmlAgilityPack.HtmlDocument doc = new HtmlAgilityPack.HtmlDocument();
                doc.LoadHtml(ocd2._descHTML);
                // Now, using LINQ to get all Images
                var imageNodes = doc.DocumentNode.SelectNodes("//img");
                if (imageNodes != null)
                {
                    foreach (HtmlAgilityPack.HtmlNode node in imageNodes)
                    {
                        if (node.Attributes.Contains("src"))
                        {
                            String url = node.Attributes["src"].Value;
                            if (ocd2._ImageFilesFromDescription.ContainsKey(url) == false)
                            {
                                String file = ocd2._Code + "_" + Guid.NewGuid();
                                ocd2._ImageFilesFromDescription.Add(url, file);
                            }
                        }
                    }
                }

                // Surfoo style: try to get spoilers from the description
                bSpoilersAlreadyInDescription = GetSpoilersFromDescription(ocd2);

                // Free some memory :-)
                ocd2._descHTML = "";
            }

            _daddy.Log("Retrieving spoilers from cache " + ocd2._Code);
            if (!bSpoilersAlreadyInDescription)
            {
                _daddy.Log("Spoilers taken from HTML parsing");
                // Parse html page and detect image to download in addition to the ones in the description
                // Spoilers ?
                GetImageFromParsing(ocd2);
            }
            else
            {
                _daddy.Log("Spoilers taken from GPX description");
            }
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Fetch geocache base on ocd._Code and download HTML page to list images to grab
        /// Images will be stored in ocd._ImageFilesSpoilers
        /// </summary>
        /// <param name="ocd">OCD object to complete</param>
        /// <param name="bUseKeyWords">If true, spoilers will be downloaded based on keywords provided in keywordsspoiler</param>
        /// <param name="htmlCode">Cache html page</param>
        public void GetImageFromParsingImpl(OfflineCacheData ocd, bool bUseKeyWords, string htmlCode)
        {
            // Patch
            String chunk = MyTools.GetSnippetFromText("<ul class=\"CachePageImages NoPrint\">", "</ul>", htmlCode);

            chunk = "<html><body>" + chunk + "</body></html>";

            // Parse HTML to retrieve links
            // Load the Html into the agility pack
            HtmlAgilityPack.HtmlDocument doc = new HtmlAgilityPack.HtmlDocument();
            doc.LoadHtml(chunk);
            // Now, using LINQ to get all Images
            var linkNodes = doc.DocumentNode.SelectNodes("//a[@href]");

            if (linkNodes != null)
            {
                //String ahref = "";
                foreach (HtmlAgilityPack.HtmlNode node in linkNodes)
                {
                    if (node.Attributes.Contains("href"))
                    {
                        String name  = HtmlAgilityPack.HtmlEntity.DeEntitize(node.InnerText);
                        bool   bKeep = true;
                        if (bUseKeyWords)
                        {
                            bKeep = false;
                            // Check if one keyword is contained in the name
                            String n = name.ToLower();
                            foreach (String s in keywordsspoiler)
                            {
                                if (n.Contains(s))
                                {
                                    bKeep = true;
                                    break;
                                }
                            }
                        }

                        if (bKeep)
                        {
                            String          url = node.Attributes["href"].Value;
                            OfflineImageWeb oiw = new OfflineImageWeb();
                            oiw._url       = url;
                            oiw._localfile = ocd._Code + "_P_" + Guid.NewGuid();
                            oiw._name      = name;
                            ocd._ImageFilesSpoilers.Add(oiw._url, oiw);
                        }
                    }
                }
            }
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Merge stats from existing OfflineCacheData if they are better defined
        /// use new stats IF
        /// - more _iNbFounds
        /// - or more _iNbNotFounds
        /// - or more _iNbFavs
        /// - don't bother using the date, it's wrong anyway
        /// If altitude of ocd is valid, we will merge it anyway
        /// </summary>
        /// <param name="ocd">existing OfflineCacheData with stats</param>
        /// <returns>true if stats have been merged</returns>
        public bool MergeStats(OfflineCacheData ocd)
        {
            // Simple check
            if ((this == ocd) || (this._Code != ocd._Code))
            {
                return(false);
            }


            bool merged = false;

            // use new stats IF
            // more _iNbFounds
            // or more _iNbNotFounds
            // or more _iNbFavs
            // don't bother using the date, it's wrong anyway
            if ((ocd._iNbFavs > this._iNbFavs) ||
                (ocd._iNbFounds > this._iNbFounds) ||
                (ocd._iNbNotFounds > this._iNbNotFounds))
            {
                // We merge it
                this._iNbFavs             = ocd._iNbFavs;
                this._iNbFounds           = ocd._iNbFounds;
                this._iNbFoundsPremium    = ocd._iNbFoundsPremium;
                this._iNbNotFounds        = ocd._iNbNotFounds;
                this._iNbNotFoundsPremium = ocd._iNbNotFoundsPremium;
                this._dRating             = ocd._dRating;
                this._dRatingSimple       = ocd._dRatingSimple;
                merged = true;
            }
            else
            {
                merged = false;
            }

            // Si l'altitude est valide, on l'utilise
            if (ocd._dAltiMeters != Double.MaxValue)
            {
                this._dAltiMeters = ocd._dAltiMeters;
                merged            = true;
            }

            return(merged);
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Fetch geocache base on ocd._Code and download HTML page to list images to grab
        /// Images will be stored in ocd._ImageFilesSpoilers
        /// </summary>
        /// <param name="ocd">OCD object to complete</param>
        private void GetImageFromParsing(OfflineCacheData ocd)
        {
            bool bUseKeyWords = false;

            if ((keywordsspoiler != null) && (keywordsspoiler.Count != 0))
            {
                bUseKeyWords = true;
            }

            try
            {
                Geocache geo = _daddy._caches[ocd._Code];
                String   url = geo._Url;

                /*
                 * WebClient client = new WebClient();
                 * AssignProxy(client);
                 * string htmlCode = client.DownloadString(url);
                 */

                // nouvelle méthode utilisant le cookie si besoin
                HttpWebRequest objRequest = (HttpWebRequest)WebRequest.Create(url);
                objRequest.Proxy = _daddy.GetProxy();
                if (cookieJar != null)
                {
                    objRequest.CookieContainer = cookieJar;
                }
                HttpWebResponse objResponse = (HttpWebResponse)objRequest.GetResponse();
                string          htmlCode;
                using (StreamReader responseStream = new StreamReader(objResponse.GetResponseStream()))
                {
                    htmlCode = responseStream.ReadToEnd();
                    responseStream.Close();
                }

                GetImageFromParsingImpl(ocd, bUseKeyWords, htmlCode);
            }
            catch (Exception)
            {
            }
        }
Ejemplo n.º 5
0
 /// <summary>
 /// Read stats from a file (for import)
 /// </summary>
 /// <param name="line">Stats for ONE OfflineCacheData</param>
 /// <returns>New OfflineCacheData with stats from file</returns>
 public static OfflineCacheData ReadStats(String line)
 {
     if (line != "")
     {
         List <string> myList = line.Split(';').ToList();
         if (myList.Count == 10)
         {
             OfflineCacheData ocd = new OfflineCacheData();
             ocd._Code = myList[0];
             DateTime dt;
             DateTime.TryParseExact(myList[1], "yyyy/MM/dd HH:mm:ss", null, System.Globalization.DateTimeStyles.None, out dt);
             ocd._dateExport          = dt;
             ocd._iNbFavs             = Int32.Parse(myList[2]);
             ocd._iNbFounds           = Int32.Parse(myList[3]);
             ocd._iNbNotFounds        = Int32.Parse(myList[4]);
             ocd._iNbFoundsPremium    = Int32.Parse(myList[5]);
             ocd._iNbNotFoundsPremium = Int32.Parse(myList[6]);
             ocd._dRating             = Double.Parse(myList[7], CultureInfo.CreateSpecificCulture("en-GB"));
             ocd._dRatingSimple       = Double.Parse(myList[8], CultureInfo.CreateSpecificCulture("en-GB"));
             try
             {
                 ocd._dAltiMeters = Double.Parse(myList[9], CultureInfo.CreateSpecificCulture("en-GB"));
             }
             catch (Exception) { }
             return(ocd);
         }
         else
         {
             return(null);
         }
     }
     else
     {
         return(null);
     }
 }
Ejemplo n.º 6
0
        public bool DoIt()
        {
            if (_Daddy != null)
            {
                String exePath = Path.GetDirectoryName(Application.ExecutablePath);
                Directory.SetCurrentDirectory(exePath);
                String imgPath = "ExportedImages";
                Directory.CreateDirectory(imgPath);

                // Now export
                List <Geocache> lst         = _Daddy.GetDisplayedCaches();
                String          offdatapath = ConfigurationManager.AppSettings["datapath"] + "\\Offline\\";
                int             nb          = 0;
                foreach (Geocache geo in lst)
                {
                    // Save images & spoilers and geotag them
                    if (_Daddy._od._OfflineData.ContainsKey(geo._Code))
                    {
                        _Daddy.Log(">>>>>>> Exporting " + geo._Code);

                        // Do we have images to load and save?
                        OfflineCacheData ocd      = _Daddy._od._OfflineData[geo._Code];
                        String           lastS    = geo._Code.Substring(geo._Code.Length - 1, 1);
                        String           prelastS = geo._Code.Substring(geo._Code.Length - 2, 1);

                        if (ocd._ImageFilesSpoilers.Count != 0)
                        {
                            _Daddy.Log("Go with spoilers");

                            int ipic = 0;
                            foreach (KeyValuePair <string, OfflineImageWeb> paire in ocd._ImageFilesSpoilers)
                            {
                                String radix = geo._Code + "_" + String.Format("{0:000}", ipic) + "_" +
                                               HtmlAgilityPack.HtmlEntity.DeEntitize(paire.Value._name) + ".jpg";
                                radix = _Daddy.SanitizeFilename(radix);

                                String fjpeg = imgPath + "\\" + radix;
                                ipic++;
                                try
                                {
                                    // Load image
                                    Image img = Image.FromFile(offdatapath + paire.Value._localfile);

                                    // Save to Jpeg
                                    try
                                    {
                                        // Test with this filename
                                        img.Save(fjpeg, System.Drawing.Imaging.ImageFormat.Jpeg);
                                    }
                                    catch (Exception)
                                    {
                                        // Ok standard filename, something wrong happened
                                        fjpeg = imgPath + "\\" + geo._Code + "_" + String.Format("{0:000}", ipic) + ".jpg";
                                        img.Save(fjpeg, System.Drawing.Imaging.ImageFormat.Jpeg);
                                    }
                                    img.Dispose();

                                    _Daddy.WriteCoordinatesToImage(fjpeg, geo._dLatitude, geo._dLongitude);
                                    nb++;
                                }
                                catch (Exception e1)
                                {
                                    // Do nothing
                                    _Daddy.Log(e1.Message);
                                }
                            }
                        }
                    }
                }
                _Daddy.MSG(nb.ToString() + " Image(s) exported");
                return(true);
            }
            else
            {
                MessageBox.Show("Nothing exported");
                return(false);
            }
        }
Ejemplo n.º 7
0
        public bool DoIt()
        {
            /*
             * http://garmin.blogs.com/softwareupdates/2012/01/geocaching-with-photos.html
             *
             * Works With All Geocaches
             * You can also take advantage of geocache photos on your Garmin handheld for geocaches obtained from a source other than OpenCaching.com, it just takes some work. A geocache’s photos, JPEG only, need to be placed on the handheld’s mass storage in the following manner
             *
             * Photos
             * \Garmin\GeocachePhotos\Last Character\Second To Last Character\Full Code\
             *
             * Spoiler Photos
             * <Photos Path>\Spoilers\
             * For example, photos for a geocache with code OXZTXGC would be placed under the path
             *
             * \Garmin\GeocachePhotos\C\G\OXZTXGC\
             *
             * And spoilers would be placed under
             *
             * \Garmin\GeocachePhotos\C\G\OXZTXGC\Spoilers
             *
             * If the geocache has only three characters total, a 0 (zero) is used for the second to last character. For example, photos for a geocache with code OXR would be placed under the path
             *
             * \Garmin\GeocachePhotos\R\0\OXR\
             */
            if (_Daddy != null)
            {
                String exePath = Path.GetDirectoryName(Application.ExecutablePath);
                Directory.SetCurrentDirectory(exePath);
                String imgGarmin = "Garmin";
                imgGarmin = "Garmin\\GeocachePhotos";
                Directory.CreateDirectory(imgGarmin);
                Directory.SetCurrentDirectory(imgGarmin);

                // Now export
                List <Geocache> lst         = _Daddy.GetDisplayedCaches();
                String          offdatapath = ConfigurationManager.AppSettings["datapath"] + "\\Offline\\";
                int             nb          = 0;
                foreach (Geocache geo in lst)
                {
                    // Save images & spoilers and geotag them
                    if (_Daddy._od._OfflineData.ContainsKey(geo._Code))
                    {
                        _Daddy.Log(">>>>>>> Exporting " + geo._Code);

                        // Do we have images to load and save?
                        OfflineCacheData ocd      = _Daddy._od._OfflineData[geo._Code];
                        String           lastS    = geo._Code.Substring(geo._Code.Length - 1, 1);
                        String           prelastS = geo._Code.Substring(geo._Code.Length - 2, 1);

                        if ((ocd._ImageFilesSpoilers.Count != 0) || (ocd._ImageFilesFromDescription.Count != 0))
                        {
                            int ipic = 0;
                            _Daddy.Log("Images found !");
                            // Spoilers
                            _Daddy.Log("Spoilers ?");
                            if (ocd._ImageFilesSpoilers.Count != 0)
                            {
                                _Daddy.Log("Go with spoilers");
                                String imgPath = lastS + "\\" + prelastS + "\\" + geo._Code + "\\Spoilers";
                                Directory.CreateDirectory(imgPath);

                                foreach (KeyValuePair <string, OfflineImageWeb> paire in ocd._ImageFilesSpoilers)
                                {
                                    String radix = geo._Code + "_" + String.Format("{0:000}", ipic) + "_" +
                                                   HtmlAgilityPack.HtmlEntity.DeEntitize(paire.Value._name) + ".jpg";
                                    radix = _Daddy.SanitizeFilename(radix);

                                    String fjpeg = imgPath + "\\" + radix;
                                    ipic++;
                                    try
                                    {
                                        // Load image
                                        Image img = Image.FromFile(offdatapath + paire.Value._localfile);

                                        // Save to Jpeg
                                        try
                                        {
                                            // Test with this filename
                                            img.Save(fjpeg, System.Drawing.Imaging.ImageFormat.Jpeg);
                                        }
                                        catch (Exception)
                                        {
                                            // Ok standard filename, something wrong happened
                                            fjpeg = imgPath + "\\" + geo._Code + "_" + String.Format("{0:000}", ipic) + ".jpg";
                                            img.Save(fjpeg, System.Drawing.Imaging.ImageFormat.Jpeg);
                                        }
                                        img.Dispose();

                                        _Daddy.WriteCoordinatesToImage(fjpeg, geo._dLatitude, geo._dLongitude);
                                        nb++;
                                    }
                                    catch (Exception e1)
                                    {
                                        // Do nothing
                                        _Daddy.Log(e1.Message);
                                    }
                                }
                            }

                            // Images from description
                            _Daddy.Log("Description ?");
                            if (ocd._ImageFilesFromDescription.Count != 0)
                            {
                                _Daddy.Log("Go with description");
                                String imgPath = lastS + "\\" + prelastS + "\\" + geo._Code;
                                Directory.CreateDirectory(imgPath);

                                foreach (KeyValuePair <string, string> paire in ocd._ImageFilesFromDescription)
                                {
                                    String fjpeg = imgPath + "\\" + geo._Code + "_" + String.Format("{0:000}", ipic) + ".jpg";
                                    ipic++;
                                    try
                                    {
                                        // Load image
                                        Image img = Image.FromFile(offdatapath + paire.Value);

                                        // Save to Jpeg
                                        img.Save(fjpeg, System.Drawing.Imaging.ImageFormat.Jpeg);
                                        img.Dispose();

                                        nb++;
                                    }
                                    catch (Exception e1)
                                    {
                                        // Do nothing
                                        _Daddy.Log(e1.Message);
                                    }
                                }
                            }
                        }
                    }
                }
                _Daddy.MSG(nb.ToString() + " Image(s) exported");
                return(true);
            }
            else
            {
                MessageBox.Show("Nothing exported");
                return(false);
            }
        }
Ejemplo n.º 8
0
        private void button1_Click(object sender, EventArgs e)
        {
            // Look for tags to add
            foreach (ListViewItem item in listView1tagmgr.Items)
            {
                // To be added if not already present in the initial list
                if (_TagsInit.Contains(item.Text) == false)
                {
                    _TagsToAdd.Add(item.Text);
                }
            }

            // Look for tag to remove
            foreach (String t in _TagsInit)
            {
                // to be removed if not present in the listview
                if (listView1tagmgr.FindItemWithText(t) == null)
                {
                    _TagsToDel.Add(t);
                }
            }

            // Ok, now parse all the caches and update their tags
            foreach (Geocache cache in _selCaches)
            {
                // Create ocd is not existing
                if (cache._Ocd == null)
                {
                    OfflineCacheData ocd1 = new OfflineCacheData();
                    ocd1._dateExport  = DateTime.Now;
                    ocd1._Comment     = "";
                    ocd1._Code        = cache._Code;
                    ocd1._bBookmarked = false;
                    _daddy.AssociateOcdCache(cache._Code, ocd1, cache);
                }

                // Add tags
                cache._Ocd.AddTags(_TagsToAdd);

                // Remove Tags
                cache._Ocd.RemoveTags(_TagsToDel);

                // Check if need to remove ocd data?
                if (cache._Ocd.IsEmpty())
                {
                    _daddy.RemoveAssociationOcdCache(cache._Code);
                }
            }

            // update tag list
            _daddy.CreateListStringTags();

            // Update listview
            foreach (ListViewItem item in _selLVItems)
            {
                String   code = item.Text;
                Geocache geo  = _daddy._caches[code];
                EXMultipleImagesListViewSubItem subitem = ((EXMultipleImagesListViewSubItem)(item.SubItems[_daddy._ID_LVTag]));
                //if (true)
                {
                    ArrayList imgitem = _daddy.GetListImageTags(geo._Ocd);
                    if ((imgitem != null) && (imgitem.Count != 0))
                    {
                        subitem.MyImages = imgitem;
                        subitem.MyValue  = geo._Ocd.GetTags();
                    }
                    else
                    {
                        subitem.MyImages = null;
                        subitem.MyValue  = "";
                    }
                }/*
                  * else
                  * {
                  * String t = "";
                  * if (geo._Ocd != null)
                  *     t = geo._Ocd.GetTags();
                  * subitem.Text = t;
                  * subitem.MyValue = t;
                  * }*/
            }
        }
Ejemplo n.º 9
0
        private String ExportExploristGC(String path)
        {
            Directory.SetCurrentDirectory(path);
            String imgMagellan = "MAGELLAN";

            if (Directory.Exists(imgMagellan))
            {
                try
                {
                    Directory.Delete(imgMagellan, true);
                }
                catch (Exception) {}
            }
            String gpxmagellan = "MAGELLAN\\Geocaches";

            Directory.CreateDirectory(gpxmagellan);
            imgMagellan = "MAGELLAN\\Images\\Geocaches";
            Directory.CreateDirectory(imgMagellan);
            Directory.SetCurrentDirectory(imgMagellan);

            String fileRadix   = path + "\\" + gpxmagellan + "\\GPX_ExploristGC.gpx";
            String offdatapath = ConfigurationManager.AppSettings["datapath"] + "\\Offline\\";

            System.IO.StreamWriter file = new System.IO.StreamWriter(fileRadix, false);

            file.WriteLine("<?xml version=\"1.0\" encoding=\"utf-8\"?>");
            file.WriteLine("<gpx xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" version=\"1.0\" creator=\"Groundspeak, Inc. All Rights Reserved. http://www.groundspeak.com\" xsi:schemaLocation=\"http://www.topografix.com/GPX/1/0 http://www.topografix.com/GPX/1/0/gpx.xsd http://www.groundspeak.com/cache/1/0/1 http://www.groundspeak.com/cache/1/0/1/cache.xsd\" xmlns=\"http://www.topografix.com/GPX/1/0\">");
            file.WriteLine("  <name>Cache Listing Generated from Geocaching.com</name>");
            file.WriteLine("  <desc>This is an individual cache generated from Geocaching.com</desc>");
            file.WriteLine("  <author>Account \"" + ConfigurationManager.AppSettings["owner"] + "\" From Geocaching.com</author>");
            file.WriteLine("  <email>[email protected]</email>");
            file.WriteLine("  <url>http://www.geocaching.com</url>");
            file.WriteLine("  <urlname>Geocaching - My Geocaching Manager Export " + DateTime.Now.ToLongDateString() + "</urlname>");
            // 2011-09-18T07:00:00Z
            String date = DateTime.Now.ToString("yyyy-MM-ddThh:mm:ssZ");

            file.WriteLine("  <time>" + date + "</time>");
            file.WriteLine("  <keywords>cache, geocache</keywords>");

            double minlat = 90.0;
            double minlon = 180.0;
            double maxlat = -90.0;
            double maxlon = -180.0;

            String          bigtext = "";
            List <Geocache> lst     = _Daddy.GetSelectedCaches();

            foreach (Geocache geo in lst)
            {
                if (geo._dLatitude < minlat)
                {
                    minlat = geo._dLatitude;
                }
                if (geo._dLongitude < minlon)
                {
                    minlon = geo._dLongitude;
                }
                if (geo._dLatitude > maxlat)
                {
                    maxlat = geo._dLatitude;
                }
                if (geo._dLongitude > maxlon)
                {
                    maxlon = geo._dLongitude;
                }

                String chunk = geo.ToGPXChunk();
                // Save images & spoilers in base 64?
                if (_Daddy._od._OfflineData.ContainsKey(geo._Code))
                {
                    OfflineCacheData ocd = _Daddy._od._OfflineData[geo._Code];
                    if ((ocd._ImageFilesSpoilers.Count != 0) || (ocd._ImageFilesFromDescription.Count != 0))
                    {
                        int    ipic  = 0;
                        String fjpeg = "";
                        if (ocd._ImageFilesSpoilers.Count != 0)
                        {
                            String spoilersImg = "";
                            foreach (KeyValuePair <string, OfflineImageWeb> paire in ocd._ImageFilesSpoilers)
                            {
                                try
                                {
                                    // Load image
                                    fjpeg = geo._Code + "_" + String.Format("{0:000}", ipic) + ".jpg";
                                    Image img = Image.FromFile(offdatapath + paire.Value._localfile);
                                    img.Save(fjpeg, System.Drawing.Imaging.ImageFormat.Jpeg);
                                    img.Dispose();

                                    String imgsrc = "&lt;br&gt;&lt;li&gt;" + paire.Value._name + "&lt;br&gt;&lt;img src=\"" + fjpeg + "\"&gt;&lt;/li&gt;";
                                    spoilersImg += imgsrc;

                                    ipic++;
                                }
                                catch (Exception e1)
                                {
                                    // Do nothing
                                    _Daddy.Log("!!!!!! Spoiler " + e1.Message);
                                }
                            }

                            chunk = chunk.Replace("</groundspeak:long_description>", spoilersImg + "</groundspeak:long_description>");
                        }

                        if (ocd._ImageFilesFromDescription.Count != 0)
                        {
                            foreach (KeyValuePair <string, string> paire in ocd._ImageFilesFromDescription)
                            {
                                try
                                {
                                    // Load image
                                    fjpeg = geo._Code + "_" + String.Format("{0:000}", ipic) + ".jpg";
                                    Image img = Image.FromFile(offdatapath + paire.Value);
                                    img.Save(fjpeg, System.Drawing.Imaging.ImageFormat.Jpeg);
                                    img.Dispose();

                                    // Save to Jpeg
                                    chunk = chunk.Replace(paire.Key, fjpeg);

                                    ipic++;
                                }
                                catch (Exception e1)
                                {
                                    // Do nothing
                                    _Daddy.Log("!!!!!! Description " + e1.Message);
                                }
                            }
                        }
                    }
                }

                bigtext += chunk;
            }
            //   <bounds minlat="-12.03455" minlon="-77.017917" maxlat="-12.03455" maxlon="-77.017917" />
            String bounds = "";

            bounds = "  <bounds minlat=\"" + minlat
                     + "\" minlon=\"" + minlon
                     + "\" maxlat=\"" + maxlat
                     + "\" maxlon=\"" + maxlon + "\" />";
            bounds = bounds.Replace(",", ".");
            file.WriteLine(bounds);
            file.Write(bigtext);
            file.WriteLine("</gpx>");

            file.Close();

            System.Diagnostics.Process.Start(path + "\\MAGELLAN");
            MessageBox.Show("Export done in " + fileRadix,
                            "Attention!",
                            MessageBoxButtons.OK,
                            MessageBoxIcon.Information);
            return(fileRadix);
        }
Ejemplo n.º 10
0
        private bool GetSpoilersFromDescription(OfflineCacheData ocd) // cf. Surfoo
        {
            List <KeyValuePair <String, String> > spoilers = new List <KeyValuePair <string, string> >();

            try
            {
                HtmlAgilityPack.HtmlDocument doc = new HtmlAgilityPack.HtmlDocument();
                doc.LoadHtml(ocd._descHTML);
                var commentNodes = doc.DocumentNode.SelectNodes("//comment()");
                if (commentNodes != null)
                {
                    foreach (HtmlAgilityPack.HtmlNode node in commentNodes)
                    {
                        String cmt = node.InnerHtml;
                        if (cmt.StartsWith("<!-- Spoiler4Gpx ["))
                        {
                            int    ipos1, ipos2;
                            String sName = "", sLink = "";
                            ipos1 = cmt.IndexOf("[");
                            ipos2 = cmt.IndexOf("](http");
                            if ((ipos1 != -1) && (ipos2 != -1) && (ipos1 < ipos2))
                            {
                                sName = cmt.Substring(ipos1 + 1, ipos2 - ipos1 - 1);
                            }

                            ipos1 = cmt.IndexOf("](http");
                            ipos2 = cmt.IndexOf(") -->");
                            if ((ipos1 != -1) && (ipos2 != -1) && (ipos1 < ipos2))
                            {
                                sLink = cmt.Substring(ipos1 + 2, ipos2 - ipos1 - 2);
                            }

                            if ((sName != "") && (sLink != ""))
                            {
                                spoilers.Add(new KeyValuePair <string, string>(sName, sLink));
                            }
                        }
                    }
                }
                if (spoilers.Count == 0)
                {
                    return(false);
                }
                else
                {
                    // Now, deal with these spoilers
                    bool bUseKeyWords = false;
                    if ((keywordsspoiler != null) && (keywordsspoiler.Count != 0))
                    {
                        bUseKeyWords = true;
                    }

                    foreach (KeyValuePair <String, String> paire in spoilers)
                    {
                        String name = paire.Key;
                        String url  = paire.Value;

                        bool bKeep = true;
                        if (bUseKeyWords)
                        {
                            bKeep = false;
                            // Check if one keyword is contained in the name
                            String n = name.ToLower();
                            foreach (String s in keywordsspoiler)
                            {
                                if (n.Contains(s))
                                {
                                    bKeep = true;
                                    break;
                                }
                            }
                        }

                        if (bKeep)
                        {
                            OfflineImageWeb oiw = new OfflineImageWeb();
                            oiw._url       = url;
                            oiw._localfile = ocd._Code + "_P_" + Guid.NewGuid();
                            oiw._name      = name;
                            ocd._ImageFilesSpoilers.Add(oiw._url, oiw);
                        }
                    }
                }

                return(true);
            }
            catch (Exception)
            {
                return(false);
            }
        }