src/data.cpp

@@ -101,7 +101,8 @@ void ProgramData::loadBuilds() {
       File file = data_->ngdp_->load(cdn_hash);
       if (!file) return -1;
       data_->cdn_config = NGDP::ParseConfig(file);
-      data_->builds = split(data_->cdn_config["builds"]);
+      //data_->builds = split(data_->cdn_config["builds"]);
+      data_->builds.push_back(data_->ngdp_->version()->build);
       notify(0);
       for (size_t i = 0; i < data_->builds.size() && !terminate_; ++i) {
         std::string build = data_->builds[i];
@@ -118,9 +119,32 @@ void ProgramData::loadBuilds() {
   };
 
   builds_loaded.clear();
+  build_configs.clear();
   setTask(new BuildTask);
 }
 
+void ProgramData::loadBuild(std::string const& build) {
+  class BuildTask : public Task {
+  public:
+    BuildTask(std::string const& build)
+      : build_(build)
+    {}
+  private:
+    std::string build_;
+    uint32 run() {
+      File file = data_->ngdp_->load(build_);
+      if (file) {
+        data_->build_configs[build_] = NGDP::ParseConfig(file);
+      } else {
+        data_->build_configs[build_] = {};
+      }
+      return 1;
+    }
+  };
+
+  setTask(new BuildTask(build));
+}
+
 /////////////////////////////////////
 
 File ProgramData::Task::loadData(std::string const& hash, int idx) {
@@ -182,18 +206,41 @@ void ProgramData::loadTags() {
       file = loadData(NGDP::to_string(enc->keys[0]), 1);
       if (!file || terminate_) return -1;
       file = NGDP::DecodeBLTE(file, enc->usize);
+      //File("download2.bin", File::REWRITE).copy(file);
 
       // parse download file
       if (file.read16(true) != 'DL') return -1;
-      file.seek(3, SEEK_CUR);
+      uint8 version = file.read8();
+      uint8 hash_size_ekey = file.read8();
+      uint8 has_checksum_in_entry = file.read8();
       uint32 numEntries = file.read32(true);
       uint16 numTags = file.read16(true);
+      uint32 entryExtra = 6;
+      if (has_checksum_in_entry) {
+        entryExtra += 4;
+      }
+      if (version >= 2) {
+        uint8 number_of_flag_bytes = file.read8();
+        entryExtra += number_of_flag_bytes;
+        if (version >= 3) {
+          file.seek(4, SEEK_CUR);
+        }
+      }
       data_->file_sizes_.clear();
+      json::Value jsv;
+      uint32 tsize = 0;
       for (uint32 i = 0; i < numEntries; ++i) {
         file.read(hash, sizeof hash);
-        file.seek(10, SEEK_CUR);
+        //File ff = loadData(hash);
+        file.seek(entryExtra, SEEK_CUR);
         auto const* layout = data_->encoding_->getLayout(hash);
         data_->file_sizes_.push_back(layout ? layout->csize : 0);
+
+        //json::Value vv;
+        //vv["hash"] = NGDP::to_string(hash);
+        //vv["size"] = layout ? layout->csize : 0;
+        //jsv["files"].append(vv);
+        tsize += (layout ? layout->csize : 0);
       }
       data_->tags_ = ProgramData::loadTags(file, numTags, numEntries);
       std::sort(data_->tags_.begin(), data_->tags_.end(), [](Tag const& lhs, Tag const& rhs) {
@@ -205,8 +252,19 @@ void ProgramData::loadTags() {
           tags.emplace_back();
         }
         tags.back().push_back(data_->tags_[i].name);
+
+        //std::string tkey = fmtstring("tags%u", (uint32) data_->tags_[i].type);
+        //auto& mask = data_->tags_[i].mask;
+        //for (uint32 j = 0; j < numEntries; ++j) {
+        //  if (mask[j / 8] & (1 << (7 - (j & 7)))) {
+        //    jsv["files"][j][tkey].append(data_->tags_[i].name);
+        //  }
+        //}
       }
       data_->tags = tags;
+
+      jsv["size"] = tsize;
+      json::write(File(path::root() / "download.json", File::REWRITE), jsv);
       return 0;
     }
   };
@@ -215,15 +273,15 @@ void ProgramData::loadTags() {
   setTask(new TagTask);
 }
 
-std::vector<uint8> ProgramData::downloadMask() {
-  size_t maskSize = (file_sizes_.size() + 7) / 8;
+std::vector<uint8> ProgramData::downloadMask(size_t numFiles) {
+  size_t maskSize = (numFiles + 7) / 8;
   std::vector<uint8> mask(maskSize, 0);
   for (std::string const& tags : used_tags) {
     std::vector<uint8> cur_mask(maskSize, 0xFF);
     for (std::string const& tag : split(tags)) {
       for (size_t i = 0; i < tags_.size(); ++i) {
         if (tags_[i].name == tag) {
-          for (size_t j = 0; j < maskSize; ++j) {
+          for (size_t j = 0; j < maskSize && j < tags_[i].mask.size(); ++j) {
             cur_mask[j] &= tags_[i].mask[j];
           }
           break;
@@ -237,7 +295,7 @@ std::vector<uint8> ProgramData::downloadMask() {
   return mask;
 }
 uint64 ProgramData::downloadSize() {
-  auto mask = downloadMask();
+  auto mask = downloadMask(file_sizes_.size());
   uint64 size = 0;
   for (size_t i = 0; i < file_sizes_.size(); ++i) {
     if (mask[i / 8] & (1 << (7 - (i & 7)))) {
@@ -281,41 +339,43 @@ void ProgramData::download(std::string const& path) {
 
         // write .build.info
 
-        File info(path_ / ".build.info", File::REWRITE);
-        info.printf("Branch!STRING:0|Active!DEC:1|Build Key!HEX:16|CDN Key!HEX:16");
-        info.printf("|Install Key!HEX:16|IM Size!DEC:4|CDN Path!STRING:0");
-        info.printf("|CDN Hosts!STRING:0|Tags!STRING:0|Armadillo!STRING:0");
-        info.printf("|Last Activated!STRING:0|Version!STRING:0|Keyring!HEX:16|KeyService!STRING:0\n");
+        {
+          File info(path_ / ".build.info", File::REWRITE);
+          info.printf("Branch!STRING:0|Active!DEC:1|Build Key!HEX:16|CDN Key!HEX:16");
+          info.printf("|Install Key!HEX:16|IM Size!DEC:4|CDN Path!STRING:0");
+          info.printf("|CDN Hosts!STRING:0|Tags!STRING:0|Armadillo!STRING:0");
+          info.printf("|Last Activated!STRING:0|Version!STRING:0|Keyring!HEX:16|KeyService!STRING:0\n");
 
-        NGDP::from_string(hash, buildConfig["install"]);
-        auto const* enc = encoding->getEncoding(hash);
-        auto const* cdnData = ngdp->cdn();
-        info.printf("%s|1|%s|%s", ngdp->region().c_str(), data_->selected_build.c_str(), ngdp->version()->cdn.c_str());
-        info.printf("|%s|%u|%s", NGDP::to_string(enc->keys[0]).c_str(), enc->usize, cdnData ? cdnData->path.c_str() : "");
-        info.printf("|%s|%s|", cdnData ? join(cdnData->hosts, " ").c_str() : "", join(data_->used_tags, ":").c_str());
+          NGDP::from_string(hash, buildConfig["install"]);
+          auto const* enc = encoding->getEncoding(hash);
+          auto const* cdnData = ngdp->cdn();
+          info.printf("%s|1|%s|%s", ngdp->region().c_str(), data_->selected_build.c_str(), ngdp->version()->cdn.c_str());
+          info.printf("|%s|%u|%s", NGDP::to_string(enc->keys[0]).c_str(), enc->usize, cdnData ? cdnData->path.c_str() : "");
+          info.printf("|%s|%s|", cdnData ? join(cdnData->hosts, " ").c_str() : "", join(data_->used_tags, ":").c_str());
 
-        __time64_t curtime;
-        tm timestruct;
-        char timebuf[128];
-        _time64(&curtime);
-        _gmtime64_s(&timestruct, &curtime);
-        strftime(timebuf, sizeof timebuf, "%Y-%m-%dT%H:%M:%SZ", &timestruct);
-        std::vector<std::string> version;
-        std::string build_id;
-        for (auto const& p : split_multiple(buildConfig["build-name"], "_- ")) {
-          if (!p.empty() && std::isdigit((unsigned char) p[0])) {
-            std::string d;
-            for (size_t i = 0; i < p.size() && std::isdigit((unsigned char)p[i]); ++i) {
-              d.push_back(p[i]);
-            }
-            if (d.size() >= 4) {
-              build_id = d;
-            } else {
-              version.push_back(d);
+          __time64_t curtime;
+          tm timestruct;
+          char timebuf[128];
+          _time64(&curtime);
+          _gmtime64_s(&timestruct, &curtime);
+          strftime(timebuf, sizeof timebuf, "%Y-%m-%dT%H:%M:%SZ", &timestruct);
+          std::vector<std::string> version;
+          std::string build_id;
+          for (auto const& p : split_multiple(buildConfig["build-name"], "_- ")) {
+            if (!p.empty() && std::isdigit((unsigned char)p[0])) {
+              std::string d;
+              for (size_t i = 0; i < p.size() && std::isdigit((unsigned char)p[i]); ++i) {
+                d.push_back(p[i]);
+              }
+              if (d.size() >= 4) {
+                build_id = d;
+              } else {
+                version.push_back(d);
+              }
             }
           }
+          info.printf("|%s|%s||\n", timebuf, (join(version, ".") + "." + build_id).c_str());
         }
-        info.printf("|%s|%s||\n", timebuf, (join(version, ".") + "." + build_id).c_str());
 
         // load indices
 
@@ -326,19 +386,32 @@ void ProgramData::download(std::string const& path) {
         // fetch download file
 
         NGDP::from_string(hash, buildConfig["download"]);
-        enc = encoding->getEncoding(hash);
+        auto const* enc = encoding->getEncoding(hash);
         File download = NGDP::DecodeBLTE(data.addFile(enc->keys[0], loadData(enc->keys[0])));
         if (download.read16(true) != 'DL') {
           throw Exception("invalid download file");
         }
         if (terminate_) return 1;
-        download.seek(3, SEEK_CUR);
+        uint8 version = download.read8();
+        uint8 hash_size_ekey = download.read8();
+        uint8 has_checksum_in_entry = download.read8();
         uint32 numEntries = download.read32(true);
-        uint32 numTags = download.read16(true);
+        uint16 numTags = download.read16(true);
+        uint32 entryExtra = 6;
+        if (has_checksum_in_entry) {
+          entryExtra += 4;
+        }
+        if (version >= 2) {
+          uint8 number_of_flag_bytes = download.read8();
+          entryExtra += number_of_flag_bytes;
+          if (version >= 3) {
+            download.seek(4, SEEK_CUR);
+          }
+        }
         uint32 filesPos = download.tell();
-        download.seek(26 * numEntries, SEEK_CUR);
+        download.seek((16 + entryExtra) * numEntries, SEEK_CUR);
         data_->tags_ = ProgramData::loadTags(download, numTags, numEntries);
-        auto mask = data_->downloadMask();
+        auto mask = data_->downloadMask(numEntries);
 
         // calculate size
 
@@ -347,7 +420,7 @@ void ProgramData::download(std::string const& path) {
         download.seek(filesPos, SEEK_SET);
         for (uint32 i = 0; i < numEntries; ++i) {
           download.read(hash, sizeof hash);
-          download.seek(10, SEEK_CUR);
+          download.seek(entryExtra, SEEK_CUR);
           if (!(mask[i / 8] & (1 << (7 - (i & 7))))) continue;
           ++progress->filesTotal;
           auto const* layout = encoding->getLayout(hash);
@@ -361,7 +434,7 @@ void ProgramData::download(std::string const& path) {
         download.seek(filesPos, SEEK_SET);
         for (uint32 i = 0; i < numEntries && !terminate_; ++i) {
           download.read(hash, sizeof hash);
-          download.seek(10, SEEK_CUR);
+          download.seek(entryExtra, SEEK_CUR);
           if (!(mask[i / 8] & (1 << (7 - (i & 7))))) continue;
 
           File file = loadFile(hash);
@@ -397,7 +470,7 @@ void ProgramData::download(std::string const& path) {
         numTags = install.read16(true);
         numEntries = install.read32(true);
         data_->tags_ = ProgramData::loadTags(install, numTags, numEntries);
-        mask = data_->downloadMask();
+        mask = data_->downloadMask(numEntries);
 
         progress->filesTotal = 0;
         progress->filesDone = 0;

src/data.h

@@ -34,6 +34,7 @@ private:
 
 public:
   void loadBuilds();
+  void loadBuild(std::string const& build);
   NGDP::ConfigFile cdn_config;
   std::vector<std::string> builds;
   std::map<std::string, NGDP::ConfigFile> build_configs;
@@ -60,7 +61,7 @@ private:
   std::vector<Tag> tags_;
 
   static std::vector<Tag> loadTags(File& file, uint32 numTags, uint32 numEntries);
-  std::vector<uint8> downloadMask();
+  std::vector<uint8> downloadMask(size_t numFiles);
 
   // step 4
 

src/frameui/fontsys.cpp

@@ -54,7 +54,6 @@ HFONT FontSys::_getFont(int height, std::string const& face, int flags) {
   fs.size = height;
   fs.flags = flags;
   fs.face = face;
-
   auto pos = std::lower_bound(fonts.begin() + 1, fonts.end(), fs);
   if (pos != fonts.end() && *pos == fs) {
     return pos->font;

src/frameui/fontsys.h

@@ -1,15 +1,14 @@
 #pragma once
 
 #include <windows.h>
-#include <string>
-#include <vector>
-#include <map>
-#include "base/types.h"
+#include "base/common.h"
 
-#define FONT_BOLD       0x0001
-#define FONT_ITALIC     0x0002
-#define FONT_UNDERLINE  0x0004
-#define FONT_STRIKEOUT  0x0008
+enum {
+  FONT_BOLD = 0x0001,
+  FONT_ITALIC = 0x0002,
+  FONT_UNDERLINE = 0x0004,
+  FONT_STRIKEOUT = 0x0008,
+};
 
 class FontSys {
   struct FontStruct {
@@ -27,6 +26,17 @@ class FontSys {
     {
       fs.font = nullptr;
     }
+    FontStruct& operator=(FontStruct&& fs) {
+      if (&fs != this) {
+        if (font) DeleteObject(font);
+        font = fs.font;
+        face = std::move(fs.face);
+        size = fs.size;
+        flags = fs.flags;
+        fs.font = nullptr;
+      }
+      return *this;
+    }
     FontStruct(FontStruct const& fs) = delete;
     ~FontStruct() {
       if (font) DeleteObject(font);

src/ngdp.cpp

@@ -6,31 +6,40 @@
 
 namespace NGDP {
 
-  const std::string HOST = "http://cn.patch.battle.net:1119";
+  const std::string HOST = "http://us.patch.battle.net:1119";
 
   const std::map<std::string, std::string> ProgramCodes = {
-    {"agent", "Battle.net Agent"},
-    {"bna", "Battle.net App"},
-    {"bnt", "Heroes of the Storm Alpha (Deprecated)"},
-    {"d3", "Diablo 3 Retail"},
-    {"d3cn", "Diablo 3 China"},
-    {"d3t", "Diablo 3 Test"},
-    {"demo", "Demo (Partial)"},
-    {"hero", "Heroes of the Storm Retail"},
-    {"herot", "Heroes of the Storm Test"},
-    {"hsb", "Hearthstone"},
-    {"pro", "Overwatch Retail"},
-    {"prodev", "Overwatch Dev"},
-    {"sc2", "StarCraft II (Partial)"},
-    {"s2", "StarCraft II"},
-    {"s2t", "StarCraft II Test (Partial)"},
-    {"s2b", "StarCraft II Beta"},
-    {"test", "Test (Partial)"},
-    {"storm", "Heroes of the Storm (Deprecated)"},
-    {"war3", "Warcraft III (Partial)"},
-    {"wow", "World of Warcraft Retail"},
-    {"wowt", "World of Warcraft Test"},
-    {"wow_beta", "World of Warcraft Beta"},
+    { "agent", "Battle.net Agent" },
+    { "bna", "Battle.net App" },
+    { "bnt", "Heroes of the Storm Alpha (Deprecated)" },
+    { "d3", "Diablo 3 Retail" },
+    { "d3cn", "Diablo 3 China" },
+    { "d3t", "Diablo 3 Test" },
+    { "demo", "Demo (Partial)" },
+    { "dst2a", "Destiny 2 Alpha (Encrypted)" },
+    { "hero", "Heroes of the Storm Retail" },
+    { "herot", "Heroes of the Storm Test" },
+    { "heroc", "Heroes of the Storm Tournament" },
+    { "hsb", "Hearthstone" },
+    { "hst", "Hearthstone Test (Partial)" },
+    { "pro", "Overwatch Retail" },
+    { "prot", "Overwatch Test" },
+    { "proc", "Overwatch Tournament" },
+    { "prodev", "Overwatch Dev (Encrypted)" },
+    { "s1", "StarCraft I" },
+    { "s1a", "StarCraft I Alpha (Encrypted)" },
+    { "s1t", "StarCraft I Test" },
+    { "sc2", "StarCraft II (Deprecated)" },
+    { "s2", "StarCraft II Retail" },
+    { "s2t", "StarCraft II Test (Deprecated)" },
+    { "s2b", "StarCraft II Beta (Deprecated)" },
+    { "test", "Test (Deprecated)" },
+    { "storm", "Heroes of the Storm (Deprecated)" },
+    { "war3", "Warcraft III Old Ver (Partial)" },
+    { "w3", "Warcraft III" },
+    { "wow", "World of Warcraft Retail" },
+    { "wowt", "World of Warcraft Test" },
+    { "wow_beta", "World of Warcraft Beta" },
   };
 
   NGDP::NGDP(std::string const& app)
@@ -41,6 +50,7 @@ namespace NGDP {
       throw Exception("failed to fetch cdns file");
     }
     for (std::string const& line : file) {
+      if (line.substr(0, 2) == "##") continue;
       if (line.find('!') != std::string::npos || line.empty()) continue;
       auto parts = split(line, '|');
       auto& config = cdns_[parts[0]];
@@ -53,13 +63,14 @@ namespace NGDP {
       throw Exception("failed to fetch versions file");
     }
     for (std::string const& line : file) {
+      if (line.substr(0, 2) == "##") continue;
       if (line.find('!') != std::string::npos || line.empty()) continue;
       auto parts = split(line, '|');
       auto& config = versions_[parts[0]];
       config.build = parts[1];
       config.cdn = parts[2];
-      config.id = std::stoi(parts[3]);
-      config.version = parts[4];
+      config.id = std::stoi(parts[4]);
+      config.version = parts[5];
       if (cdns_.count(parts[0])) {
         regions_.push_back(parts[0]);
       }

src/pages/build.cpp

@@ -11,7 +11,7 @@ enum {
 BuildPage::BuildPage(Wizard* wizard)
   : Page(wizard)
 {
-  build_ = new ComboFrame(this, ID_BUILD);
+  build_ = new ComboFrame(this, ID_BUILD, CBS_DROPDOWN);
   build_->addString("Loading CDN config...", -1);
   build_->setCurSel(0);
   build_->setPoint(PT_TOPLEFT, 120, 0);
@@ -35,11 +35,11 @@ void BuildPage::init() {
   if (ngdp && ngdp->version() && ngdp->version()->cdn == data.builds_loaded && data.builds.size() == data.build_configs.size()) {
     build_->reset();
     for (std::string const& build : data.builds) {
-      std::string name = data.build_configs[build]["build-name"];
-      if (build == ngdp->version()->build) {
-        name += " (current)";
-      }
-      build_->addString(name);
+      //std::string name = data.build_configs[build]["build-name"];
+      //if (build == ngdp->version()->build) {
+      //  name += " (current)";
+      //}
+      build_->addString(build);
       if (build == data.selected_build) {
         build_->setCurSel(build_->getCount() - 1);
       }
@@ -51,54 +51,73 @@ void BuildPage::init() {
   }
 }
 
+void BuildPage::showInfo(std::string const& build) {
+  auto& data = wizard_->app()->data();
+  static const std::string skipTags = "download|encoding|encoding-size|install|patch|patch-config|root";
+  std::string text;
+  auto const& info = data.build_configs[build];
+  for (auto& kv : info) {
+    if (skipTags.find(kv.first) != std::string::npos) continue;
+    text.append(kv.first);
+    text.append(" = ");
+    text.append(kv.second);
+    text.append("\r\n");
+  }
+  tags_->setText(text);
+  tags_->show();
+  wizard_->enableNext(info.size() > 0);
+}
+
 LRESULT BuildPage::onMessage(uint32 message, WPARAM wParam, LPARAM lParam) {
   auto& data = wizard_->app()->data();
   switch (message) {
   case WM_COMMAND:
-    if (LOWORD(wParam) == ID_BUILD && HIWORD(wParam) == CBN_SELCHANGE) {
-      int index = build_->getCurSel();
-      if (index >= 0 && index < data.builds.size() && data.build_configs.count(data.builds[index])) {
-        static const std::string skipTags = "download|encoding|encoding-size|install|patch|patch-config|root";
-        std::string text;
-        auto const& build = data.build_configs[data.builds[index]];
-        data.selected_build = data.builds[index];
-        for (auto& kv : build) {
-          if (skipTags.find(kv.first) != std::string::npos) continue;
-          text.append(kv.first);
-          text.append(" = ");
-          text.append(kv.second);
-          text.append("\r\n");
+    if (LOWORD(wParam) == ID_BUILD && (HIWORD(wParam) == CBN_EDITCHANGE || HIWORD(wParam) == CBN_SELCHANGE)) {
+      std::string build = build_->getText();
+      if (HIWORD(wParam) == CBN_SELCHANGE) {
+        int id = build_->getCurSel();
+        if (id >= 0 && id < data.builds.size()) {
+          build = data.builds[id];
         }
-        tags_->setText(text);
-        tags_->show();
-        wizard_->enableNext(true);
-      } else {
+      }
+      if (build.size() != 32) {
         data.selected_build.clear();
         tags_->hide();
         wizard_->enableNext(false);
+      } else if (data.build_configs.count(build)) {
+        data.selected_build = build;
+        showInfo(build);
+      } else {
+        data.selected_build = build;
+        tags_->hide();
+        wizard_->enableNext(false);
+        data.loadBuild(build);
       }
     }
     return 0;
   case WM_TASKDONE:
     if (lParam == -1) {
       build_->reset();
-      build_->addString("Failed to load CDN config", -1);
-      build_->setCurSel(0);
-      build_->disable();
+      //build_->addString("Failed to load CDN config", -1);
+      //build_->setCurSel(0);
+      //build_->disable();
     } else if (lParam == 0) {
       build_->reset();
       for (std::string const& build : data.builds) {
-        build_->addString("Loading...", -1);
+        build_->addString(build, -1);
       }
       build_->enable();
     } else if (lParam != ProgramData::LOADING) {
-      build_->delString(lParam - 1);
+      if (data.build_configs.count(data.selected_build)) {
+        showInfo(data.selected_build);
+      }
+      /*build_->delString(lParam - 1);
       std::string build = data.builds[lParam - 1];
       std::string name = data.build_configs[build]["build-name"];
       if (build == data.ngdp()->version()->build) {
         name += " (current)";
       }
-      SendMessage(build_->getHandle(), CB_INSERTSTRING, lParam - 1, (LPARAM) name.c_str());
+      SendMessage(build_->getHandle(), CB_INSERTSTRING, lParam - 1, (LPARAM) name.c_str());*/
     }
     return 0;
   default:

src/pages/build.h

@@ -15,5 +15,6 @@ private:
   ComboFrame* build_;
   EditFrame* tags_;
   void init();
+  void showInfo(std::string const& build);
   LRESULT onMessage(uint32 message, WPARAM wParam, LPARAM lParam);
 };

src/pages/tags.cpp

@@ -36,15 +36,18 @@ void TagsPage::addTags(int index, std::string str) {
     tags_->addItem(str);
     data.used_tags.push_back(str);
   } else {
-    if (index) str.push_back(' ');
+    //if (index) str.push_back(' ');
     int sel = options_[index]->getCurSel();
     if (sel >= 0) sel = options_[index]->getItemData(sel);
     if (sel < 0) {
-      for (auto const& tag : data.tags[index]) {
-        addTags(index + 1, str + tag);
-      }
+      //for (auto const& tag : data.tags[index]) {
+      //  addTags(index + 1, str + tag);
+      //}
+      addTags(index + 1, str);
     } else {
-      addTags(index + 1, str + data.tags[index][sel]);
+      std::string next = str;
+      if (!str.empty()) next.push_back(' ');
+      addTags(index + 1, next + data.tags[index][sel]);
     }
   }
 }
@@ -94,7 +97,7 @@ LRESULT TagsPage::onMessage(uint32 message, WPARAM wParam, LPARAM lParam) {
         int maxWidth = std::max<int>(60, FontSys::getTextSize(FontSys::getSysFont(), "Any").cx);
         ComboFrame* box = new ComboFrame(this);
         options_.push_back(box);
-        if (tags.size() > 1) {
+        if (tags.size() > 0) {
           box->addString("Any", -1);
         }
         for (size_t i = 0; i < tags.size(); ++i) {

src/zlib/zconf.h

@@ -0,0 +1,511 @@
+/* zconf.h -- configuration of the zlib compression library
+ * Copyright (C) 1995-2013 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#ifndef ZCONF_H
+#define ZCONF_H
+
+/*
+ * If you *really* need a unique prefix for all types and library functions,
+ * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
+ * Even better than compiling with -DZ_PREFIX would be to use configure to set
+ * this permanently in zconf.h using "./configure --zprefix".
+ */
+#ifdef Z_PREFIX     /* may be set to #if 1 by ./configure */
+#  define Z_PREFIX_SET
+
+/* all linked symbols */
+#  define _dist_code            z__dist_code
+#  define _length_code          z__length_code
+#  define _tr_align             z__tr_align
+#  define _tr_flush_bits        z__tr_flush_bits
+#  define _tr_flush_block       z__tr_flush_block
+#  define _tr_init              z__tr_init
+#  define _tr_stored_block      z__tr_stored_block
+#  define _tr_tally             z__tr_tally
+#  define adler32               z_adler32
+#  define adler32_combine       z_adler32_combine
+#  define adler32_combine64     z_adler32_combine64
+#  ifndef Z_SOLO
+#    define compress              z_compress
+#    define compress2             z_compress2
+#    define compressBound         z_compressBound
+#  endif
+#  define crc32                 z_crc32
+#  define crc32_combine         z_crc32_combine
+#  define crc32_combine64       z_crc32_combine64
+#  define deflate               z_deflate
+#  define deflateBound          z_deflateBound
+#  define deflateCopy           z_deflateCopy
+#  define deflateEnd            z_deflateEnd
+#  define deflateInit2_         z_deflateInit2_
+#  define deflateInit_          z_deflateInit_
+#  define deflateParams         z_deflateParams
+#  define deflatePending        z_deflatePending
+#  define deflatePrime          z_deflatePrime
+#  define deflateReset          z_deflateReset
+#  define deflateResetKeep      z_deflateResetKeep
+#  define deflateSetDictionary  z_deflateSetDictionary
+#  define deflateSetHeader      z_deflateSetHeader
+#  define deflateTune           z_deflateTune
+#  define deflate_copyright     z_deflate_copyright
+#  define get_crc_table         z_get_crc_table
+#  ifndef Z_SOLO
+#    define gz_error              z_gz_error
+#    define gz_intmax             z_gz_intmax
+#    define gz_strwinerror        z_gz_strwinerror
+#    define gzbuffer              z_gzbuffer
+#    define gzclearerr            z_gzclearerr
+#    define gzclose               z_gzclose
+#    define gzclose_r             z_gzclose_r
+#    define gzclose_w             z_gzclose_w
+#    define gzdirect              z_gzdirect
+#    define gzdopen               z_gzdopen
+#    define gzeof                 z_gzeof
+#    define gzerror               z_gzerror
+#    define gzflush               z_gzflush
+#    define gzgetc                z_gzgetc
+#    define gzgetc_               z_gzgetc_
+#    define gzgets                z_gzgets
+#    define gzoffset              z_gzoffset
+#    define gzoffset64            z_gzoffset64
+#    define gzopen                z_gzopen
+#    define gzopen64              z_gzopen64
+#    ifdef _WIN32
+#      define gzopen_w              z_gzopen_w
+#    endif
+#    define gzprintf              z_gzprintf
+#    define gzvprintf             z_gzvprintf
+#    define gzputc                z_gzputc
+#    define gzputs                z_gzputs
+#    define gzread                z_gzread
+#    define gzrewind              z_gzrewind
+#    define gzseek                z_gzseek
+#    define gzseek64              z_gzseek64
+#    define gzsetparams           z_gzsetparams
+#    define gztell                z_gztell
+#    define gztell64              z_gztell64
+#    define gzungetc              z_gzungetc
+#    define gzwrite               z_gzwrite
+#  endif
+#  define inflate               z_inflate
+#  define inflateBack           z_inflateBack
+#  define inflateBackEnd        z_inflateBackEnd
+#  define inflateBackInit_      z_inflateBackInit_
+#  define inflateCopy           z_inflateCopy
+#  define inflateEnd            z_inflateEnd
+#  define inflateGetHeader      z_inflateGetHeader
+#  define inflateInit2_         z_inflateInit2_
+#  define inflateInit_          z_inflateInit_
+#  define inflateMark           z_inflateMark
+#  define inflatePrime          z_inflatePrime
+#  define inflateReset          z_inflateReset
+#  define inflateReset2         z_inflateReset2
+#  define inflateSetDictionary  z_inflateSetDictionary
+#  define inflateGetDictionary  z_inflateGetDictionary
+#  define inflateSync           z_inflateSync
+#  define inflateSyncPoint      z_inflateSyncPoint
+#  define inflateUndermine      z_inflateUndermine
+#  define inflateResetKeep      z_inflateResetKeep
+#  define inflate_copyright     z_inflate_copyright
+#  define inflate_fast          z_inflate_fast
+#  define inflate_table         z_inflate_table
+#  ifndef Z_SOLO
+#    define uncompress            z_uncompress
+#  endif
+#  define zError                z_zError
+#  ifndef Z_SOLO
+#    define zcalloc               z_zcalloc
+#    define zcfree                z_zcfree
+#  endif
+#  define zlibCompileFlags      z_zlibCompileFlags
+#  define zlibVersion           z_zlibVersion
+
+/* all zlib typedefs in zlib.h and zconf.h */
+#  define Byte                  z_Byte
+#  define Bytef                 z_Bytef
+#  define alloc_func            z_alloc_func
+#  define charf                 z_charf
+#  define free_func             z_free_func
+#  ifndef Z_SOLO
+#    define gzFile                z_gzFile
+#  endif
+#  define gz_header             z_gz_header
+#  define gz_headerp            z_gz_headerp
+#  define in_func               z_in_func
+#  define intf                  z_intf
+#  define out_func              z_out_func
+#  define uInt                  z_uInt
+#  define uIntf                 z_uIntf
+#  define uLong                 z_uLong
+#  define uLongf                z_uLongf
+#  define voidp                 z_voidp
+#  define voidpc                z_voidpc
+#  define voidpf                z_voidpf
+
+/* all zlib structs in zlib.h and zconf.h */
+#  define gz_header_s           z_gz_header_s
+#  define internal_state        z_internal_state
+
+#endif
+
+#if defined(__MSDOS__) && !defined(MSDOS)
+#  define MSDOS
+#endif
+#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2)
+#  define OS2
+#endif
+#if defined(_WINDOWS) && !defined(WINDOWS)
+#  define WINDOWS
+#endif
+#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__)
+#  ifndef WIN32
+#    define WIN32
+#  endif
+#endif
+#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32)
+#  if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__)
+#    ifndef SYS16BIT
+#      define SYS16BIT
+#    endif
+#  endif
+#endif
+
+/*
+ * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
+ * than 64k bytes at a time (needed on systems with 16-bit int).
+ */
+#ifdef SYS16BIT
+#  define MAXSEG_64K
+#endif
+#ifdef MSDOS
+#  define UNALIGNED_OK
+#endif
+
+#ifdef __STDC_VERSION__
+#  ifndef STDC
+#    define STDC
+#  endif
+#  if __STDC_VERSION__ >= 199901L
+#    ifndef STDC99
+#      define STDC99
+#    endif
+#  endif
+#endif
+#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__))
+#  define STDC
+#endif
+
+#if defined(__OS400__) && !defined(STDC)    /* iSeries (formerly AS/400). */
+#  define STDC
+#endif
+
+#ifndef STDC
+#  ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
+#    define const       /* note: need a more gentle solution here */
+#  endif
+#endif
+
+#if defined(ZLIB_CONST) && !defined(z_const)
+#  define z_const const
+#else
+#  define z_const
+#endif
+
+/* Some Mac compilers merge all .h files incorrectly: */
+#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__)
+#  define NO_DUMMY_DECL
+#endif
+
+/* Maximum value for memLevel in deflateInit2 */
+#ifndef MAX_MEM_LEVEL
+#  ifdef MAXSEG_64K
+#    define MAX_MEM_LEVEL 8
+#  else
+#    define MAX_MEM_LEVEL 9
+#  endif
+#endif
+
+/* Maximum value for windowBits in deflateInit2 and inflateInit2.
+ * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
+ * created by gzip. (Files created by minigzip can still be extracted by
+ * gzip.)
+ */
+#ifndef MAX_WBITS
+#  define MAX_WBITS   15 /* 32K LZ77 window */
+#endif
+
+/* The memory requirements for deflate are (in bytes):
+            (1 << (windowBits+2)) +  (1 << (memLevel+9))
+ that is: 128K for windowBits=15  +  128K for memLevel = 8  (default values)
+ plus a few kilobytes for small objects. For example, if you want to reduce
+ the default memory requirements from 256K to 128K, compile with
+     make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
+ Of course this will generally degrade compression (there's no free lunch).
+
+   The memory requirements for inflate are (in bytes) 1 << windowBits
+ that is, 32K for windowBits=15 (default value) plus a few kilobytes
+ for small objects.
+*/
+
+                        /* Type declarations */
+
+#ifndef OF /* function prototypes */
+#  ifdef STDC
+#    define OF(args)  args
+#  else
+#    define OF(args)  ()
+#  endif
+#endif
+
+#ifndef Z_ARG /* function prototypes for stdarg */
+#  if defined(STDC) || defined(Z_HAVE_STDARG_H)
+#    define Z_ARG(args)  args
+#  else
+#    define Z_ARG(args)  ()
+#  endif
+#endif
+
+/* The following definitions for FAR are needed only for MSDOS mixed
+ * model programming (small or medium model with some far allocations).
+ * This was tested only with MSC; for other MSDOS compilers you may have
+ * to define NO_MEMCPY in zutil.h.  If you don't need the mixed model,
+ * just define FAR to be empty.
+ */
+#ifdef SYS16BIT
+#  if defined(M_I86SM) || defined(M_I86MM)
+     /* MSC small or medium model */
+#    define SMALL_MEDIUM
+#    ifdef _MSC_VER
+#      define FAR _far
+#    else
+#      define FAR far
+#    endif
+#  endif
+#  if (defined(__SMALL__) || defined(__MEDIUM__))
+     /* Turbo C small or medium model */
+#    define SMALL_MEDIUM
+#    ifdef __BORLANDC__
+#      define FAR _far
+#    else
+#      define FAR far
+#    endif
+#  endif
+#endif
+
+#if defined(WINDOWS) || defined(WIN32)
+   /* If building or using zlib as a DLL, define ZLIB_DLL.
+    * This is not mandatory, but it offers a little performance increase.
+    */
+#  ifdef ZLIB_DLL
+#    if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500))
+#      ifdef ZLIB_INTERNAL
+#        define ZEXTERN extern __declspec(dllexport)
+#      else
+#        define ZEXTERN extern __declspec(dllimport)
+#      endif
+#    endif
+#  endif  /* ZLIB_DLL */
+   /* If building or using zlib with the WINAPI/WINAPIV calling convention,
+    * define ZLIB_WINAPI.
+    * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI.
+    */
+#  ifdef ZLIB_WINAPI
+#    ifdef FAR
+#      undef FAR
+#    endif
+#    include <windows.h>
+     /* No need for _export, use ZLIB.DEF instead. */
+     /* For complete Windows compatibility, use WINAPI, not __stdcall. */
+#    define ZEXPORT WINAPI
+#    ifdef WIN32
+#      define ZEXPORTVA WINAPIV
+#    else
+#      define ZEXPORTVA FAR CDECL
+#    endif
+#  endif
+#endif
+
+#if defined (__BEOS__)
+#  ifdef ZLIB_DLL
+#    ifdef ZLIB_INTERNAL
+#      define ZEXPORT   __declspec(dllexport)
+#      define ZEXPORTVA __declspec(dllexport)
+#    else
+#      define ZEXPORT   __declspec(dllimport)
+#      define ZEXPORTVA __declspec(dllimport)
+#    endif
+#  endif
+#endif
+
+#ifndef ZEXTERN
+#  define ZEXTERN extern
+#endif
+#ifndef ZEXPORT
+#  define ZEXPORT
+#endif
+#ifndef ZEXPORTVA
+#  define ZEXPORTVA
+#endif
+
+#ifndef FAR
+#  define FAR
+#endif
+
+#if !defined(__MACTYPES__)
+typedef unsigned char  Byte;  /* 8 bits */
+#endif
+typedef unsigned int   uInt;  /* 16 bits or more */
+typedef unsigned long  uLong; /* 32 bits or more */
+
+#ifdef SMALL_MEDIUM
+   /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
+#  define Bytef Byte FAR
+#else
+   typedef Byte  FAR Bytef;
+#endif
+typedef char  FAR charf;
+typedef int   FAR intf;
+typedef uInt  FAR uIntf;
+typedef uLong FAR uLongf;
+
+#ifdef STDC
+   typedef void const *voidpc;
+   typedef void FAR   *voidpf;
+   typedef void       *voidp;
+#else
+   typedef Byte const *voidpc;
+   typedef Byte FAR   *voidpf;
+   typedef Byte       *voidp;
+#endif
+
+#if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC)
+#  include <limits.h>
+#  if (UINT_MAX == 0xffffffffUL)
+#    define Z_U4 unsigned
+#  elif (ULONG_MAX == 0xffffffffUL)
+#    define Z_U4 unsigned long
+#  elif (USHRT_MAX == 0xffffffffUL)
+#    define Z_U4 unsigned short
+#  endif
+#endif
+
+#ifdef Z_U4
+   typedef Z_U4 z_crc_t;
+#else
+   typedef unsigned long z_crc_t;
+#endif
+
+#ifdef HAVE_UNISTD_H    /* may be set to #if 1 by ./configure */
+#  define Z_HAVE_UNISTD_H
+#endif
+
+#ifdef HAVE_STDARG_H    /* may be set to #if 1 by ./configure */
+#  define Z_HAVE_STDARG_H
+#endif
+
+#ifdef STDC
+#  ifndef Z_SOLO
+#    include <sys/types.h>      /* for off_t */
+#  endif
+#endif
+
+#if defined(STDC) || defined(Z_HAVE_STDARG_H)
+#  ifndef Z_SOLO
+#    include <stdarg.h>         /* for va_list */
+#  endif
+#endif
+
+#ifdef _WIN32
+#  ifndef Z_SOLO
+#    include <stddef.h>         /* for wchar_t */
+#  endif
+#endif
+
+/* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and
+ * "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even
+ * though the former does not conform to the LFS document), but considering
+ * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as
+ * equivalently requesting no 64-bit operations
+ */
+#if defined(_LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1
+#  undef _LARGEFILE64_SOURCE
+#endif
+
+#if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H)
+#  define Z_HAVE_UNISTD_H
+#endif
+#ifndef Z_SOLO
+#  if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE)
+#    include <unistd.h>         /* for SEEK_*, off_t, and _LFS64_LARGEFILE */
+#    ifdef VMS
+#      include <unixio.h>       /* for off_t */
+#    endif
+#    ifndef z_off_t
+#      define z_off_t off_t
+#    endif
+#  endif
+#endif
+
+#if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0
+#  define Z_LFS64
+#endif
+
+#if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64)
+#  define Z_LARGE64
+#endif
+
+#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64)
+#  define Z_WANT64
+#endif
+
+#if !defined(SEEK_SET) && !defined(Z_SOLO)
+#  define SEEK_SET        0       /* Seek from beginning of file.  */
+#  define SEEK_CUR        1       /* Seek from current position.  */
+#  define SEEK_END        2       /* Set file pointer to EOF plus "offset" */
+#endif
+
+#ifndef z_off_t
+#  define z_off_t long
+#endif
+
+#if !defined(_WIN32) && defined(Z_LARGE64)
+#  define z_off64_t off64_t
+#else
+#  if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO)
+#    define z_off64_t __int64
+#  else
+#    define z_off64_t z_off_t
+#  endif
+#endif
+
+/* MVS linker does not support external names larger than 8 bytes */
+#if defined(__MVS__)
+  #pragma map(deflateInit_,"DEIN")
+  #pragma map(deflateInit2_,"DEIN2")
+  #pragma map(deflateEnd,"DEEND")
+  #pragma map(deflateBound,"DEBND")
+  #pragma map(inflateInit_,"ININ")
+  #pragma map(inflateInit2_,"ININ2")
+  #pragma map(inflateEnd,"INEND")
+  #pragma map(inflateSync,"INSY")
+  #pragma map(inflateSetDictionary,"INSEDI")
+  #pragma map(compressBound,"CMBND")
+  #pragma map(inflate_table,"INTABL")
+  #pragma map(inflate_fast,"INFA")
+  #pragma map(inflate_copyright,"INCOPY")
+#endif
+
+#endif /* ZCONF_H */

src/zlib/zutil.h

@@ -0,0 +1,253 @@
+/* zutil.h -- internal interface and configuration of the compression library
+ * Copyright (C) 1995-2013 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+/* @(#) $Id$ */
+
+#ifndef ZUTIL_H
+#define ZUTIL_H
+
+#ifdef HAVE_HIDDEN
+#  define ZLIB_INTERNAL __attribute__((visibility ("hidden")))
+#else
+#  define ZLIB_INTERNAL
+#endif
+
+#include "zlib.h"
+
+#if defined(STDC) && !defined(Z_SOLO)
+#  if !(defined(_WIN32_WCE) && defined(_MSC_VER))
+#    include <stddef.h>
+#  endif
+#  include <string.h>
+#  include <stdlib.h>
+#endif
+
+#ifdef Z_SOLO
+   typedef long ptrdiff_t;  /* guess -- will be caught if guess is wrong */
+#endif
+
+#ifndef local
+#  define local static
+#endif
+/* compile with -Dlocal if your debugger can't find static symbols */
+
+typedef unsigned char  uch;
+typedef uch FAR uchf;
+typedef unsigned short ush;
+typedef ush FAR ushf;
+typedef unsigned long  ulg;
+
+extern z_const char * const z_errmsg[10]; /* indexed by 2-zlib_error */
+/* (size given to avoid silly warnings with Visual C++) */
+
+#define ERR_MSG(err) z_errmsg[Z_NEED_DICT-(err)]
+
+#define ERR_RETURN(strm,err) \
+  return (strm->msg = ERR_MSG(err), (err))
+/* To be used only when the state is known to be valid */
+
+        /* common constants */
+
+#ifndef DEF_WBITS
+#  define DEF_WBITS MAX_WBITS
+#endif
+/* default windowBits for decompression. MAX_WBITS is for compression only */
+
+#if MAX_MEM_LEVEL >= 8
+#  define DEF_MEM_LEVEL 8
+#else
+#  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
+#endif
+/* default memLevel */
+
+#define STORED_BLOCK 0
+#define STATIC_TREES 1
+#define DYN_TREES    2
+/* The three kinds of block type */
+
+#define MIN_MATCH  3
+#define MAX_MATCH  258
+/* The minimum and maximum match lengths */
+
+#define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */
+
+        /* target dependencies */
+
+#if defined(MSDOS) || (defined(WINDOWS) && !defined(WIN32))
+#  define OS_CODE  0x00
+#  ifndef Z_SOLO
+#    if defined(__TURBOC__) || defined(__BORLANDC__)
+#      if (__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__))
+         /* Allow compilation with ANSI keywords only enabled */
+         void _Cdecl farfree( void *block );
+         void *_Cdecl farmalloc( unsigned long nbytes );
+#      else
+#        include <alloc.h>
+#      endif
+#    else /* MSC or DJGPP */
+#      include <malloc.h>
+#    endif
+#  endif
+#endif
+
+#ifdef AMIGA
+#  define OS_CODE  0x01
+#endif
+
+#if defined(VAXC) || defined(VMS)
+#  define OS_CODE  0x02
+#  define F_OPEN(name, mode) \
+     fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512")
+#endif
+
+#if defined(ATARI) || defined(atarist)
+#  define OS_CODE  0x05
+#endif
+
+#ifdef OS2
+#  define OS_CODE  0x06
+#  if defined(M_I86) && !defined(Z_SOLO)
+#    include <malloc.h>
+#  endif
+#endif
+
+#if defined(MACOS) || defined(TARGET_OS_MAC)
+#  define OS_CODE  0x07
+#  ifndef Z_SOLO
+#    if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os
+#      include <unix.h> /* for fdopen */
+#    else
+#      ifndef fdopen
+#        define fdopen(fd,mode) NULL /* No fdopen() */
+#      endif
+#    endif
+#  endif
+#endif
+
+#ifdef TOPS20
+#  define OS_CODE  0x0a
+#endif
+
+#ifdef WIN32
+#  ifndef __CYGWIN__  /* Cygwin is Unix, not Win32 */
+#    define OS_CODE  0x0b
+#  endif
+#endif
+
+#ifdef __50SERIES /* Prime/PRIMOS */
+#  define OS_CODE  0x0f
+#endif
+
+#if defined(_BEOS_) || defined(RISCOS)
+#  define fdopen(fd,mode) NULL /* No fdopen() */
+#endif
+
+#if (defined(_MSC_VER) && (_MSC_VER > 600)) && !defined __INTERIX
+#  if defined(_WIN32_WCE)
+#    define fdopen(fd,mode) NULL /* No fdopen() */
+#    ifndef _PTRDIFF_T_DEFINED
+       typedef int ptrdiff_t;
+#      define _PTRDIFF_T_DEFINED
+#    endif
+#  else
+#    define fdopen(fd,type)  _fdopen(fd,type)
+#  endif
+#endif
+
+#if defined(__BORLANDC__) && !defined(MSDOS)
+  #pragma warn -8004
+  #pragma warn -8008
+  #pragma warn -8066
+#endif
+
+/* provide prototypes for these when building zlib without LFS */
+#if !defined(_WIN32) && \
+    (!defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0)
+    ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t));
+    ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t));
+#endif
+
+        /* common defaults */
+
+#ifndef OS_CODE
+#  define OS_CODE  0x03  /* assume Unix */
+#endif
+
+#ifndef F_OPEN
+#  define F_OPEN(name, mode) fopen((name), (mode))
+#endif
+
+         /* functions */
+
+#if defined(pyr) || defined(Z_SOLO)
+#  define NO_MEMCPY
+#endif
+#if defined(SMALL_MEDIUM) && !defined(_MSC_VER) && !defined(__SC__)
+ /* Use our own functions for small and medium model with MSC <= 5.0.
+  * You may have to use the same strategy for Borland C (untested).
+  * The __SC__ check is for Symantec.
+  */
+#  define NO_MEMCPY
+#endif
+#if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY)
+#  define HAVE_MEMCPY
+#endif
+#ifdef HAVE_MEMCPY
+#  ifdef SMALL_MEDIUM /* MSDOS small or medium model */
+#    define zmemcpy _fmemcpy
+#    define zmemcmp _fmemcmp
+#    define zmemzero(dest, len) _fmemset(dest, 0, len)
+#  else
+#    define zmemcpy memcpy
+#    define zmemcmp memcmp
+#    define zmemzero(dest, len) memset(dest, 0, len)
+#  endif
+#else
+   void ZLIB_INTERNAL zmemcpy OF((Bytef* dest, const Bytef* source, uInt len));
+   int ZLIB_INTERNAL zmemcmp OF((const Bytef* s1, const Bytef* s2, uInt len));
+   void ZLIB_INTERNAL zmemzero OF((Bytef* dest, uInt len));
+#endif
+
+/* Diagnostic functions */
+#ifdef DEBUG
+#  include <stdio.h>
+   extern int ZLIB_INTERNAL z_verbose;
+   extern void ZLIB_INTERNAL z_error OF((char *m));
+#  define Assert(cond,msg) {if(!(cond)) z_error(msg);}
+#  define Trace(x) {if (z_verbose>=0) fprintf x ;}
+#  define Tracev(x) {if (z_verbose>0) fprintf x ;}
+#  define Tracevv(x) {if (z_verbose>1) fprintf x ;}
+#  define Tracec(c,x) {if (z_verbose>0 && (c)) fprintf x ;}
+#  define Tracecv(c,x) {if (z_verbose>1 && (c)) fprintf x ;}
+#else
+#  define Assert(cond,msg)
+#  define Trace(x)
+#  define Tracev(x)
+#  define Tracevv(x)
+#  define Tracec(c,x)
+#  define Tracecv(c,x)
+#endif
+
+#ifndef Z_SOLO
+   voidpf ZLIB_INTERNAL zcalloc OF((voidpf opaque, unsigned items,
+                                    unsigned size));
+   void ZLIB_INTERNAL zcfree  OF((voidpf opaque, voidpf ptr));
+#endif
+
+#define ZALLOC(strm, items, size) \
+           (*((strm)->zalloc))((strm)->opaque, (items), (size))
+#define ZFREE(strm, addr)  (*((strm)->zfree))((strm)->opaque, (voidpf)(addr))
+#define TRY_FREE(s, p) {if (p) ZFREE(s, p);}
+
+/* Reverse the bytes in a 32-bit value */
+#define ZSWAP32(q) ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \
+                    (((q) & 0xff00) << 8) + (((q) & 0xff) << 24))
+
+#endif /* ZUTIL_H */

vc13/BlizzGet.vcxproj

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|Win32">
       <Configuration>Debug</Configuration>
@@ -19,13 +19,13 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>