2.2.0:
======
- Features:
  * Handles multiple sources.list-formatted files
  * Supports arbitrary sources.list loading, parsing, and writing
    (meaning you can load any source file directly, or use the default set.)
  * Added the ability to query a list of all loaded sources.list files.
  * You can now fetch only the files for a specific repository.
  * gstreamer1.0 port completed by Harald Sitter
  * Dropped qtgstreamer in favor of native gstreamer API
- Bugfixes:
  * There was a bug in the unreleased alpha where removing all entries from
    any file could potentially result in overwriting the defaulatet /etc/apt/sources.list.
  * Various minor (but important) bug fixes (Harald)

2.1: (as of 2.1 alpha, unreleased)
======
- Features:
  * Added a new SourcesList class for manipulating APT source list files.
  * Added a new SourceEntry class for manipulating individual APT sources within source list
    files.
  * Added a "frontend capabilities" API which frontends use to advertise which forms of user
    interaction they support during the commit process. (Config file conflict, untrusted packages
    prompt, debconf, etc) This will prevent frontends that don't explicitly support these
    interactions from hanging the commit process indefinitely.
  * Add support for the new Synaptic marking file syntax (BKO: #314549)
- Bugfixes:
  * Stop leaking a file descriptor when reading APT pin files.
  * Stop taking the address of a temporary variable in the package search function.

2.0.1:
======
- Bugfixes:
  * Fixed a crash that could occur if an empty cache state is passed to
    Backend::stateChanges(). An empty change set is returned in this case.

2.0
======
- Release Notes:
  * This release includes API/ABI changes, that, while mostly source compatible, aren't
    100% compatible with code written aginst LibQApt 1.x. Additionally, code that invokes
    asynchronous worker actions will need more code to work now.
- Features:
  * New transaction-based worker API. Asyncronous actions run by the QApt Worker are now
    tracked with QApt::Transaction objects. The worker transactions can be tracked and
    controlled through the transaction object, and the transaction object will also signal
    property/state changes for the worker transaction. This fixes the long-standing issue of
    the QApt Backend listening for worker signals globally, potentially broadcasting information
    about a worker action initiated by another QApt frontend.
  * The new QApt Worker queues transactions as dispatched by either a single frontend or from
    multiple frontends.
  * If a non-QApt package manager such as apt-get, synaptic, aptdaemon, etc currently has a lock
    on the package system, the QApt Worker will wait until it can obtain the lock instead of
    immediately failing.
  * Added a new class QApt::DownloadProgress to replace the global download progress signal in
    QApt::Backend. Instances of QApt::Transaction will emit DownloadProgress objects to report
    new progress information for a file the QApt Worker is downloading. (E.g. a package file,
    on in the case of a cache update, package information lists.)
  * QApt::ChangelogEntry now has a CVEUrls() method to return a list of urls to websites
    describing vulnerability exploits which the version specified in the changelog entry fixes.
  * Backend::init() and Backend::reload() now return a boolean value based on whether or not
    the backend could be (re)initialized. If not, an error message can be retrieved through the
    new Backend::initErrorMessage() method. If init() or reload() return false, applications
    should immediately exit.
  * The QApt::Backend constructor now takes a QObject parameter to use as a parent, removing the
    need for manual deletion. (This could perhaps be considered a bug that it didn't before...)
  * Added API to QApt::DependencyInfo analgous to libapt-pkg's pkgCache::DepType() static method
    for obtaining a user-readable string from a QApt::DependencyType.
- API changes:
  * The Cache class was removed. It really had no external uses and now is a trivial wrapper
    around libapt-pkg's pkgCacheFile with a few additions for internal use.
  * The Backend::workerEvent() signal and Backend::workerState() method have been removed.
    The new Transaction object reports state changes on a per-transaction basis now.
  * Similarly, Backend::errorOccurred() and Backend::workerQuestion() have been replaced by
    analogous code in the Transaction class.
  * The Backend::setProxy() and setLocale() functions have been removed. Proxy and locale are now
    set on a per-transaction basis via the QApt::Transaction class.
  * Global signals for download/commit progress in QApt::Backend have been replaced by signals in
    the Transaction class for reporting info on a per-transaction basis.
  * The already-deprecated Backend::downloadMessage() signal was removed.
  * The Backend::packageChanged() signal no longer emits a pointer to the package that changed.
    There wasn't much use in emitting a pointer to the package just changed, as there was no
    garuantee that it was the only package that had changed (without doing expensive checks on
    every package), which meant that you had to assume that everything had changed.
  * Added a Backend::upgradeSystem() method that starts a worker transaction to upgrade all
    upgradeable packages. This is useful if you want to run a commit that will only upgrade
    packages, and will result in faster upgrade marking in the worker.
  * Added a new MarkingErrorInfo class to replace the QHash<int, QHash<QString, QVariantMap> >
    mess that Package::brokenReason() returned. The new class features a much nicer API.
  * Package::supportedUntil() now returns a QDateTime to allow localization in KDE applications.
- Bugfixes:
  * QApt::Backend will no longer emit progress information for worker actions not initiated by
    your application. (By virtue of not emitting progress information at all. Info is now emitted
    on a per-transaction basis.) This fixes a bunch of potential crashes where applications
    inappropriately react to worker state changes. (Muon worked around a bunch of these,
    but not all) (BKO: #305277, #307951)
  * Frontends can gracefully wait in line to use the QApt Worker (BKO: #274262)
  * The dependencies of an application marked for installation are now properly marked as
    auto-installed. (Before they weren't, which means they couldn't be autoremoved after all
    packages depending on them had been removed)
- Optimizations:
  * Public functions that took references to QLatin1String objects now take QLatin1String objects
    passed by value. A QLatin1String is nothing more than a char pointer with some convenience
    functions, so passing them by reference is really just introducing a double-indirection to get
    to the char pointer. (API change, should be source compatible)
  * QApt::Backend::origin() takes a const reference to a QString instead of a QString passed by
    value, preventing the need to copy the QString given as a parameter. (API change, source
    compatible)
  * Package::name() and Package::section() have been changed to return QLatin1Strings, using the
    implementations of the the latin1Name() and latin1Section() methods, which have been removed.
    (API change, usage of latin1Name() and latin1Section() should be changed to name() and
    section(). additionally, current usage that depends on the rvalues of name() and section()
    being QString need to be changed to first assign the result of name() or section() to a
    QString variable before running QString methods.
  * HistoryItems are now implicitly shared, copy-on-write objects. This makes copying HistoryItem
    instances around very cheap, and allows us to not need to use pointers to share access to them.
    (The History class now returns QList<HistoryItem> vs QList<HistoryItem *>)
  * Upgradeable packages that have not been marked for upgrade are no longer sent to the worker,
    for consideration when committing packages. This speeds up the dependency calculation for
    a commit involving a handful of packages, when hundreds of upgrades are also available.
  * Make QApt::Package constructing faster by storing the APT pkgIterator as a member variable
    in PackagePrivate, rather than having a pointer to a pkgIterator and storing the pkgIterator
    on the heap. Does not appreciably reduce memory usage, but reduced the number of times a
    heap memory allocation is performed.
  * Small speed optimizations to Backend::stateChanges()
  * Qt containers such as QList specialized for QApt types are now declared as movable, decreasing
    the amount of memory used to store these containers.
  * Small optimization in Package::setVersion()


1.4.0
======
- Features:
  * Make the supported architectures list available from the Config class.
  * Implemented APT MultiArch support in the QApt Deb Installer utility.
  * Add an origins() function to QApt::Backend to return a list of machine-readable
    origin names.
  * Add a function for retrieving a list of origins by its host URL.
  * Add a dialog to show additional changes to packages when installing a .deb package with
    the QApt Deb Installer. (LP: #1021966)
- Optimizations:
  * Use a faster QString -> const char * conversion when looking up packages by name

1.3.2:
======
- Bugfixes
  * Report APT errors that occur during marking in the worker as InitErrors with details.
    There wasn't a check for these errors before, so the APT error stack still had them
    on top, and we were getting them when we checked for LockErrors. (BKO: #285787)
  * Resolve all dependency problems on package upgrades using the ResolveByKeep paradigm.
    Often when a package that is to be upgraded has dependencies which also depend on packages
    that need upgraded, APT will not be able to immediately resolve potential breaks by marking
    these. However, since we are passed a list of other packages that will also be marked for
    upgrade, we will most likely resolve this situation manually later. With ResolveByKeep we
    can avoid trying to remove to-be-upgraded packages with dep problems until we can manually
    fix them. (Matching the behavior of libapt-pkg's pkgAllUpgrade method)
  * After package marking on commit, clear errors on the error stack caused by marking packages
    as long as there are no breaks currently. This fixes a bug where dependency issues that
    were fixed by the end of the commit marking would stay on the error stack, failing the
    entire commit.
  * Fix usage of transient apt-pkg headers which caused FTBFS with APT 0.9.x
  * Fixed an issue with the duplicate directory entry detection in Package::installedFilesList
    which caused similarly named files to be incorrectly deleted from the list.
    (E.g. /usr/bin/kppp was being removed since the next entry was /usr/bin/kppplogviewer, and
    we were incorrectly considering /usr/bin/kppp as a directory)
  * Fixed unallocated memory access when loading pinned packages in the QApt Backend.
  * Reset the package index vector to be filled with -1 on reload, to prevent weird things
    happening with uninitialized fields.
  * Delete all package objects in the Backend destructor to make memory leak checking easier.
    (Technically a memory leak, but the Backend class is usually a singleton-type class that
    lives throughout an application's lifetime)
  * Fix a situation where the APT package fetcher would say everything was fine to continue, but
    several packages had failed by manually checking what has failed and seeing if APT can
    continue safely. (BKO: #299887)
  * Fix an unchecked indexed vector access that causes a rare crash on application startup.
    (BKO: #299551)

1.3.1:
======
- Bugfixes
  * Fixed the QApt GStreamer Helper offering to install a blank list of packages if no
    plugin was found.
  * Fixed the QApt GStreamer Helper offering plugins for the wrong architecture,
    preventing the proper ones from being installed.
  * Fixed Package::installedFilesList() returning an empty list on foreign-architecture
    packages

1.3.0:
======
- Features:
  * Introducing the QApt::Changelog class, which provides an interface for retreiving
    information from a package's changelog. Individual entries in the changelog can
    be retreived along with other data such as version, date and an update description.
  * Added Backend::stateChanges() to provide lists of changed packages since a given
    CacheState.
  * Added QApt::Package::archives() function to return a list of archives that a package
    is available from. (E.g. oneiric, oneiric-updates, sid, etc)
- Bugfixes:
  * Fixed not being able to unmark a package when it is a dependency of another package
    that is also marked.
  * Fixed build with PolkitQt-1 0.100+
  * Fixed a spelling error in the QApt Deb Installer
  * Support Debian changelog servers, fixes changelogs containing HTML on Debian systems
  * Fixed a documentation typo in QAptConfig.cmake
  * Fix deprecated values and other desktop spec violations in the QApt Deb Installer's
    desktop file.
  * Fixed the GStreamer Plugin Installer not finding packages for entire GStreamer elements
    (as opposed to plugins for specific element capabilities) (LP: #883604)
  * Fixed the GStreamer Plugin Installer hanging when plugins can not be found.
  * Fixed a crash in the GStreamer Plugin Installer where a QGst::CapsPtr was used without
    a null check.
  * Make the QApt Worker report the URI for fetch errors instead of the fetch description.
  * Fix build issues with APT 0.8.16+
  * Fix failure to build on systems without KDE development headers installed.
- Optimizations:
  * Added Backend::markPackages() for marking multiple packages at once.
    It utilizes event compression, avoiding additional internal dependency checking or
    emitting packageChanged() signals until everything is marked. Increases the speed
    of marking multiple packages by 300% in Muon.
  * Added Backend::setCompressEvents() function so that programs can utilize the event
    compression speed benefits in their own custom marking loops if they can't use
    Backend::markPackages()
  * Normalize all signals/slots for a (micro)optimization.
* Other:
  - Dropped legacy support for PolKit-Qt 0.98.x. Polkit-Qt 0.99 or greater is now required.
  - Utilize language features of C++11, GCC 4.6+ or similar is now required.
  - API documentation updates

1.2.3:
======
- Bugfixes:
  * Fixed a bug with the QApt Deb Installer where files with spaces would fail to install.
    (BKO: #290510)
  * Read the dpkg pty regularly to prevent it from filling.Fixes an issue where long/verbose
    commits would hang the QApt Worker, by extension causing QApt frontends to hang.
    (BKO: #292423, LP: #840306)
  * Restart the QApt Worker's timeout timer and note the end of a commit if commitChanges
    fails. Otherwise, the QApt Worker will remain as a zombie indefinitely, hanging
    frontends. (BKO: #292549)
  * Emit a FetchFailed error if enough packages fail to download to prevent a commit from
    happening at all. Fixes a hang on frontends when packages fail to download. (BKO: #287274)

1.2.2:
======
- Bugfixes:
  * Fixed a bug in QApt::Debfile where the reported install size was
    always one unit too low. (E.g. showing 5 KiB instead of 5 MiB)
    Fixes the QApt Deb Installer showing too small installed sizes.
  * More fixes for MultiArch. The last round of fixes were made with the assumption that all
    installable foreign-arch packages would be marked with a Multi-Arch field in their control
    files. This was a bad assumption. Non-native foreign-arch packages need no changes made to
    them as long as their dependencies are multi-arch.

    As such, we cannot only add foreign-arch packages marked as MultiArch to the cache, or else
    we lose foreign-arch binary packages such as Skype. (Which is what people actually want!)

    Unfortunately, this means that there will be "duplicate" entries for most packages in the
    cache, but these can be differentiated by placing (arch) after the names in your display
    model.

    Package::isMultiArchEnabled() has been deprecated, and a new Package::isForeignArch()
    function has been added. It does the same thing, but includes all foreign-arch packages
    that the APT install supports.
  * Be a bit less strict about the quality cutoff for the quick search. Fixes very few
    results being found for the "linux" search term. (BKO: #283523)
  * Fixed an issue with the QApt Deb Installer hanging during long installations.
    (LP: #850902)
  * Fixed random "this package is incompatible with your computer" errors with the
    QApt Deb Installer.

1.2.1:
======
- Bugfixes:
  * Added support for MultiArch packages when used with APT 0.8.16+. By default,
    APT shows every foreign-arch package available. LibQApt filters these and
    only shows foreign-arch packages that are explicitly marked as MultiArch.
    To differentiate between the package names, LibQApt consumers can use the
    new Package::architecture to get the arch as a QString to help disambiguate.
    (BKO: #276389)
  * Added Backend::isMultiArchEnabled() to return whether or not dpkg/apt are
    set up for multiarch
  * Added Package::isMultiArchEnabled() to return whether or not a package is
    set up for multiarch
  * Fixed a bug where the lack of an apt-xapian cache would not trigger a
    cache rebuild. (A.K.A. search doesn't work on new installs of $DISTRO)
    (LP: #839411)
  * Fixed a bug where the QApt Worker would quit during a xapian cache update,
    causing consumer apps to lose update progress notification.
  * Fixed a bug where the QApt Worker would quit during long installations of
    local .deb files with qapt-deb-installer. (BKO: #280890, LP: #830786)
  * Fixed a crash when the qapt-gst-helper is given invalid GStreamer caps.
    (LP: #847748)
  * Fixed xdg compliance issues with the QApt Deb Thumbnailer's .desktop file.
    Fixes warnings from kbuildsycoca4.

1.2.0:
======
- Features:
  * Added the ability to pin and unpin packages via writing files to
    /etc/apt/preferences.d/
  * Added the QApt::DebFile class, an information retreval interface for .deb
    package archives.
  * Added Backend::saveDownloadList() to create a download list usable by the
    downloadArchives() function.
  * Added a downloadArchives() function to download a list of archives to an
    arbitrary directory. The worker will emit package download signals as usual.
    This can be useful, for example, for downloading packages to a USB stick.
  * Added Backend::addArchiveToCache(), whichs adds .deb files for the candidate
    versions of existing packages to the apt .deb cache. This function can be used
    to add .debs from e.g. a USB stick so that computers without internet
    connections can update packages.
  * Added an installDebFile method to QApt::Backend and the QApt Worker. This
    method starts the installation of the given .deb file, complete with a
    DebInstallStarted event signal on start, DebInstallFinished when finished,
    and a debInstallMessage() signal in between for dpkg output.
    A new error, WrongArchError, has been added to QApt::ErrorCode for when a
    .deb file cannot be installed due to incompatible CPU architectures for binary
    packages. (No multiarch support yet)
  * Added a new DependencyInfo class to help describe a package's relational
    dependencies. Useful for when working without APT's dependency solving
    while using .deb files
  * Added functions to QApt::Package for returning lists of DependenyInfo objects
    for various relational dependencies.
  * Added an upstreamVersion() function to the Package class to return the upstream
    version of a package. Also include a static version in case we have a package
    version without a Package object and want the upstream version without having
    a Package object instantiated.
  * Added a static method "compareVersion()" to the Package class to compare the
    versions of two packages, returning the standard less than 0, 0 or greater than
    zero when appropriate.

- Optimizations:
  * Speed up concatenation of the release file URI in
    PackagePrivate::getReleaseFileForOrigin() (Helps speed up the
    Package::isSupported() function)
  * Speed up Package::state() by 66% by caching state info that cannot change
    between cache reloads.
  * Don't pass const references to QLatin1Strings to PackagePrivate::searchPkgFileIter()
    and getReleaseFileForOrigin(). QL1S already has a pointer to a c-string, so we are
    pointlessly dereferencing a refernce to a pointer, making things a tad bit slower.
    These are private functions, so API/ABI is untouched.

- Bugfixes:
  * Fixed a copy/paste error in the documentation for the QApt::Group typedef
  * Fixed a constructor being incorrectly called a default constructor in the api docs.
  * Send the value of the http_proxy env var to the worker, since it normally runs in
    a shell-less environment with no env vars defined. Fixes proxies defined in the
    http_proxy environment variable not working. (BKO: 275276)
  * Fixed a divide-by-zero crash in the QApt Worker when built against APT 0.8.16 or
    higher. (BKO: 279690)

- New Utilities:
  * Introducing the Installer Plasma Runner plugin, providing package installation
    suggestions using the command-not-found utility and QApt Batch.
  * Introducing the QApt Deb Installer, a utility for installing .deb packages.
  * Introducing the QApt Deb Thumbnailer, a thumbnailing plugin for KDE that
    produces thumbnail previews for Dolphin and friends.
  * Introducing the QApt GStreamer Helper, a utility that can be used by Phonon's
    GStreamer backend for automatically suggesting and installing GStreamer codecs
    for media playback.

1.1.3:
======
- Bugfixes:
  * Don't waste time searching if the given file is empty, and return a null pointer.
    Fixes Backend::packageForFile() returning unpredictable results when passed an
    empty file string.
  * Innocuous errors can occur at certain times during the execution of
    downloadSize() can cause initialization errors, so discard all errors incurred
    in this function. (BKO: #265741)

1.1.2:
======
- This was a translations-only update

1.1.1:
======
- Bugfixes:
  * Don't crash in Package::supportedUntil() when packages in Ubuntu's main
    archive do not have a "Supported" field.
  * Prevent a potential crash in Package::supportedUntil() when a corrupt
    /etc/lsb-release file is present.
  * Set LC_MESSAGES as the worker's locale rather than LC_ALL. If extra locale
    categories are set, LC_ALL will return a rather unuseful composite of all of them.
    Thanks to Colin Watson for the patch.
  * Don't close stdout inside the QApt Worker. Packages' post-installation scripts
    that use stdout will silently fail when it is closed with newer versions of APT.
  * Use a pty instead of a pipe for write access to enable apt to produce useful
    entries in /var/log/apt/term.log.
    Adapted from a patch by Colin Watson.
  * Don't hardcode the changelog server used in Package::changelogUrl() to
    changelogs.ubuntu.com. Debian would have to patch the source file for
    changelogs to work, plus it is configurable at the APT level in the first place.
- Optimizations:
  * Don't try to build the entire changelog URL ourselves in Package::changelogUrl(),
    as the package's control records has much of the URL we need in the form of
    its filename.
  

1.1:
======
- Features:
  * Added a new QApt::Config class. It features a KConfig-like API to the APT system
    configuration, as well as provides config writing support without dumping the
    entire APT configuration settings to a file like APT does. It currently supports
    reading and writing int, bool and string settings. QApt::Backend has a
    QApt::Config instance that can be accessed by its config() method after
    initialization.
  * Added a new QApt::History class. It provides an interface to the APT history
    log(s). It provides a list of all entries in the logs, with each entry providing
    a start date, a list of packages acted upon as well as any errors that may have
    occurred during the transaction.
  * Added pretty includes in the form of <LibQApt/Include> (e.g. <LibQApt/Backend>)
  * Added a packageDownloadProgress() signal for per-package download progress reporting.
    This enables client applications to give more detailed information about
    currently-downloading packages, including parallel package downloads.
  * Added a markPackagesForAutoRemove() method that acts like apt-get autoremove,
    marking packages for removal that APT deems obsolete.
  * Added a new setUndoRedoCacheSize() function to QApt::Backend. This allows
    applications to customize the undo/redo stack size, allowing them to increase
    it if RAM usage is less of an issue, or decrease/eliminate the cache if RAM is tight.
  * Added Add a saveInstalledPackagesList() function to QApt::Backend that exports a
    list of all installed packages to the given path. This list can be ready by
    Backend::readSelections() and is fully compatible with the Synaptic Package Manager.
  * Add some new functions: recommendsList(), suggestsList(), enhancesList() and enhancedByList()
    to return QStringLists of the names of packages that have the aforementioned relational statuses
    with the Package.
  * Added an areChangesMarked() function to provide an easier/more efficient way to check if there are
    pending changes without checking the emptiness of the QApt::PackageList that
    Backend::MarkedPackages() constructs and returns.
  * API documentation updates, including making note of which functions are asynchronous
    and have signals to report events/data.
  * LibQApt now compiles with QT_NO_CAST_TO_ASCII and QT_NO_CAST_FROM_ASCII.

- Optimizations:
  * APT system initialization in Backend::init() is no longer blocking, so that you
    can paint your UI sooner to give a perception of increased speed.
  * General optimizations have been made throughout to significantly speed up
    Backend::init()
  * Speed up Package::isSupported() by making a cache of package index files to
    prevent doing a binary search for the index file from the sources list each time
    isSupported() is called.
  * Speed Package::isInstalled() up by checking for installation without calling state().
  * Added an installedCount() function that is faster than using the packageCount()
    overload function that takes a package state flag.
  * Add more efficient toInstallCount() and toRemoveCount() functions to Backend.
    These both just grab int's already cached in memory by APT, meaning that we
    don't have to iterate through every Package and get a full state reading to
    determine whether it is being installed/removed.
  * Add a more efficient latin1Section() function. to QApt::Package Since
    QLatin1String returns an empty string when it encounters null char pointers, we
    can use latin1Section() in section() to have equivalent, simpler code that still
    retains safety.
  * Improve the speed of Backend::loadSelections() by parsing selection files with
    QByteArray, as well as some other miscellaneous optimizations.
  * Change the Backend's origin/human readable name mapping to use a QHash, giving some
    minor optimizations to the originLabel() and origin() functions.
  * Add a Backend::package() overload that takes a QLatin1String. If you can use this overload,
    it is more efficient since you don't have to go QString -> ascii -> latin1 -> const char.
  * Make the regular Backend::package() implementation use the QL1S overload. This is slightly
    more efficient since we can convert directly from QString -> latin1 without converting to
    ascii in between (since APT package names will always be latin1)
  * Use the new Backend::package(QL1S) overload inside Backend::search(). the QL1S overload is
    faster in the first place, plus since Xapian gives us an std::string it is also faster to go
    to QL1S than to QString.
  * Since package names are always latin1-compliant, prevent the unnecessary conversion of const char *
    -> std::string -> QString::fromAscii -> QString::fromLatin1 by using QLatin1String to wrap around
    the const char *, making the conversion process look more like const char * -> QL1S -> QString::fromLatin1.

- Bugfixes:
  * Added a NotFound error for the QApt Batch Installer to use when it encounters
    a non-existant package. Before it was not catching this error at all and went
    straight to completion as if nothing was wrong.
  * QAptBatch: Don't say we were successful if there were errors. That looks a bit
    silly, especially when we have error dialogs to contradict ourselves.
  * Fixed a bug where installing a package locally did not make the
    xapianIndexNeedsUpdate() return true;
  * Fixed a bug where the worker would never respond to DBus requests when heavy
    load was present on the system. (BKO: #249929)
  * Fixed a bug where calling originLabel() with an origin that did not have a
    label would insert the origin into the origin map, wasting memory.
  * Fixed a blank line being snuck in to the end of lists returned by the
    Package::installedFilesList() function
  * Fix a potential problem with homepage URLs with UTF8 characters not displaying correctly.
  * Fix a small memory leak in PackagePrivate. We had a pointer that we allocate to in the
    Package constructor which we weren't deleting in the PackagePrivate destructor
  * Compile with -fvisibility=hidden by default so that libqapt doesn't expose
    symbols from libraries it links against, making life easier for packagers
    everywhere.

- Other
  * Documentation for the detail QVariantMaps of ErrorCodes, WarningCodes and
    WorkerQuestions is now provided, whereas they were completely undocumented
    in previous releases.

1.0.4:
======
- Bugfixes:
  * Respect preference files in the /etc/apt/preferences.d/ dir, and not just the
    /etc/apt/preferences file itself
  * Catch and report initialization errors in places we were missing for
  * Report that package state has changed when loading selection files

1.0.3:
======
- Bugfixes:
  * Implementing proper locking, fixing the "Doesn't respect APT system locks" bug

1.0.2:
======
- Bugfixes:
  * QAptBatch: Set the focus to the appropriate button for each mode

1.0.0:
====
* Initial release