diff --git a/src/actions.cpp b/src/actions.cpp
index 5ef52a2f..273db488 100644
--- a/src/actions.cpp
+++ b/src/actions.cpp
@@ -1604,7 +1604,7 @@ namespace {
                 case Params::askPolicy:
                     std::cout << Params::instance().progname()
                               << ": " << _("File") << " `" << newPath
-                              << "' " << _("exists. [O]verwrite, [r]ename or [s]kip?") 
+                              << "' " << _("exists. [O]verwrite, [r]ename or [s]kip?")
                               << " ";
                     std::cin >> s;
                     switch (s[0]) {
diff --git a/src/basicio.cpp b/src/basicio.cpp
index a93d440a..02af5789 100644
--- a/src/basicio.cpp
+++ b/src/basicio.cpp
@@ -67,7 +67,7 @@ EXIV2_RCSID("@(#) $Id$")
 namespace Exiv2 {
 
     FileIo::FileIo(const std::string& path)
-        : path_(path), fp_(0), opMode_(opSeek), 
+        : path_(path), fp_(0), opMode_(opSeek),
           pMappedArea_(0), mappedLength_(0), isMalloced_(false)
     {
     }
@@ -223,7 +223,7 @@ namespace Exiv2 {
             fileIo->close();
             // Check if the file can be written to, if it already exists
             if (open("w+b") != 0) {
-                // Remove the (temporary) file 
+                // Remove the (temporary) file
                 std::remove(fileIo->path_.c_str());
                 throw Error(10, path_, "w+b", strError());
             }
diff --git a/src/basicio.hpp b/src/basicio.hpp
index 1e802798..827bea99 100644
--- a/src/basicio.hpp
+++ b/src/basicio.hpp
@@ -175,7 +175,7 @@ namespace Exiv2 {
         /*!
           @brief Direct access to the IO data. For files, this is done by
                  mapping the file into the process's address space; for
-                 memory blocks, this allows direct access to the memory 
+                 memory blocks, this allows direct access to the memory
                  block.
 
           Todo: This is currently only for read access.
@@ -621,8 +621,8 @@ namespace Exiv2 {
           @brief Allow direct access to the underlying data buffer. The buffer
                  is not protected against write access except for the const
                  specifier.
-          @note  The application must ensure that the memory pointed to by the 
-                 returned pointer remains valid and allocated as long as the 
+          @note  The application must ensure that the memory pointed to by the
+                 returned pointer remains valid and allocated as long as the
                  MemIo object is in scope.
          */
         virtual const byte* mmap() { return data_; }
diff --git a/src/cr2image.cpp b/src/cr2image.cpp
index f2bc62b3..9e8f8f15 100644
--- a/src/cr2image.cpp
+++ b/src/cr2image.cpp
@@ -72,12 +72,12 @@ namespace Exiv2 {
         { "*",         0x8649, Group::ifd0,    &TiffMetadataDecoder::decodeIrbIptc    }
     };
 
-    const DecoderFct Cr2Decoder::findDecoder(const std::string& make, 
+    const DecoderFct Cr2Decoder::findDecoder(const std::string& make,
                                                    uint32_t     extendedTag,
                                                    uint16_t     group)
     {
         DecoderFct decoderFct = &TiffMetadataDecoder::decodeStdTiffEntry;
-        const TiffDecoderInfo* td = find(cr2DecoderInfo_, 
+        const TiffDecoderInfo* td = find(cr2DecoderInfo_,
                                          TiffDecoderInfo::Key(make, extendedTag, group));
         if (td) {
             // This may set decoderFct to 0, meaning that the tag should not be decoded
diff --git a/src/cr2image.hpp b/src/cr2image.hpp
index 048efeed..287261ed 100644
--- a/src/cr2image.hpp
+++ b/src/cr2image.hpp
@@ -162,9 +162,9 @@ namespace Exiv2 {
     class Cr2Decoder {
     public:
         /*!
-          @brief Find the decoder function for a key. 
+          @brief Find the decoder function for a key.
 
-          If the returned pointer is 0, the tag should not be decoded, 
+          If the returned pointer is 0, the tag should not be decoded,
           else the decoder function should be used.
 
           @param make Camera make
@@ -173,7 +173,7 @@ namespace Exiv2 {
 
           @return Pointer to the decoder function
          */
-        static const DecoderFct findDecoder(const std::string& make, 
+        static const DecoderFct findDecoder(const std::string& make,
                                                   uint32_t     extendedTag,
                                                   uint16_t     group);
 
diff --git a/src/datasets.cpp b/src/datasets.cpp
index 1b674995..a7a2514b 100644
--- a/src/datasets.cpp
+++ b/src/datasets.cpp
@@ -82,82 +82,82 @@ namespace Exiv2 {
     };
 
     static const DataSet envelopeRecord[] = {
-        DataSet(IptcDataSets::ModelVersion, "ModelVersion", N_("Model Version"), 
+        DataSet(IptcDataSets::ModelVersion, "ModelVersion", N_("Model Version"),
                 N_("A binary number identifying the version of the Information "
                 "Interchange Model, Part I, utilised by the provider. Version "
-                "numbers are assigned by IPTC and NAA organizations."), 
+                "numbers are assigned by IPTC and NAA organizations."),
                 true, false, 2, 2, Exiv2::unsignedShort, IptcDataSets::envelope, ""),
-        DataSet(IptcDataSets::Destination, "Destination", N_("Destination"), 
+        DataSet(IptcDataSets::Destination, "Destination", N_("Destination"),
                 N_("This DataSet is to accommodate some providers who require "
-                "routing information above the appropriate OSI layers."), 
+                "routing information above the appropriate OSI layers."),
                 false, true, 0, 1024, Exiv2::string, IptcDataSets::envelope, ""),
-        DataSet(IptcDataSets::FileFormat, "FileFormat", N_("File Format"), 
+        DataSet(IptcDataSets::FileFormat, "FileFormat", N_("File Format"),
                 N_("A binary number representing the file format. The file format "
                 "must be registered with IPTC or NAA with a unique number "
                 "assigned to it. The information is used to route "
                 "the data to the appropriate system and to allow the receiving "
-                "system to perform the appropriate actions there to."), 
+                "system to perform the appropriate actions there to."),
                 true, false, 2, 2, Exiv2::unsignedShort, IptcDataSets::envelope, ""),
-        DataSet(IptcDataSets::FileVersion, "FileVersion", N_("File Version"), 
+        DataSet(IptcDataSets::FileVersion, "FileVersion", N_("File Version"),
                 N_("A binary number representing the particular version of the File "
-                "Format specified by <FileFormat> tag."), 
+                "Format specified by <FileFormat> tag."),
                 true, false, 2, 2, Exiv2::unsignedShort, IptcDataSets::envelope, ""),
-        DataSet(IptcDataSets::ServiceId, "ServiceId", N_("Service Id"), 
-                N_("Identifies the provider and product"), 
+        DataSet(IptcDataSets::ServiceId, "ServiceId", N_("Service Id"),
+                N_("Identifies the provider and product"),
                 true, false, 0, 10, Exiv2::string, IptcDataSets::envelope, ""),
-        DataSet(IptcDataSets::EnvelopeNumber, "EnvelopeNumber", N_("Envelope Number"), 
+        DataSet(IptcDataSets::EnvelopeNumber, "EnvelopeNumber", N_("Envelope Number"),
                 N_("The characters form a number that will be unique for the date "
                 "specified in <DateSent> tag and for the Service Identifier "
                 "specified by <ServiceIdentifier> tag. "
                 "If identical envelope numbers appear with the same date and "
                 "with the same Service Identifier, records 2-9 must be unchanged "
                 "from the original. This is not intended to be a sequential serial "
-                "number reception check."), 
+                "number reception check."),
                 true, false, 8, 8, Exiv2::string, IptcDataSets::envelope, ""),
-        DataSet(IptcDataSets::ProductId, "ProductId", N_("Product Id"), 
+        DataSet(IptcDataSets::ProductId, "ProductId", N_("Product Id"),
                 N_("Allows a provider to identify subsets of its overall service. Used "
                 "to provide receiving organisation data on which to select, route, "
-                "or otherwise handle data."), 
+                "or otherwise handle data."),
                 false, true, 0, 32, Exiv2::string, IptcDataSets::envelope, ""),
-        DataSet(IptcDataSets::EnvelopePriority, "EnvelopePriority", N_("Envelope Priority"), 
+        DataSet(IptcDataSets::EnvelopePriority, "EnvelopePriority", N_("Envelope Priority"),
                 N_("Specifies the envelope handling priority and not the editorial "
                 "urgency (see <Urgency> tag). \"1\" indicates the most urgent, \"5\" "
                 "the normal urgency, and \"8\" the least urgent copy. The numeral "
                 "\"9\" indicates a User Defined Priority. The numeral \"0\" is reserved "
-                "for future use."), 
+                "for future use."),
                 false, false, 1, 1, Exiv2::string, IptcDataSets::envelope, ""),
-        DataSet(IptcDataSets::DateSent, "DateSent", N_("Date Sent"), 
+        DataSet(IptcDataSets::DateSent, "DateSent", N_("Date Sent"),
                 N_("Uses the format CCYYMMDD (century, year, month, day) as de-fined "
-                "in ISO 8601 to indicate year, month and day the service sent the material."), 
+                "in ISO 8601 to indicate year, month and day the service sent the material."),
                 true, false, 8, 8, Exiv2::date, IptcDataSets::envelope, ""),
-        DataSet(IptcDataSets::TimeSent, "TimeSent", N_("Time Sent"), 
+        DataSet(IptcDataSets::TimeSent, "TimeSent", N_("Time Sent"),
                 N_("Uses the format HHMMSS:HHMM where HHMMSS refers to "
                 "local hour, minute and seconds and HHMM refers to hours and "
                 "minutes ahead (+) or behind (-) Universal Coordinated Time as "
                 "described in ISO 8601. This is the time the service sent the material."),
                 false, false, 11, 11, Exiv2::time, IptcDataSets::envelope, ""),
-        DataSet(IptcDataSets::CharacterSet, "CharacterSet", N_("Character Set"), 
+        DataSet(IptcDataSets::CharacterSet, "CharacterSet", N_("Character Set"),
                 N_("This tag consisting of one or more control functions used for the announcement, "
                 "invocation or designation of coded character sets. The control functions follow "
                 "the ISO 2022 standard and may consist of the escape control "
-                "character and one or more graphic characters."), 
+                "character and one or more graphic characters."),
                 false, false, 0, 32, Exiv2::undefined, IptcDataSets::envelope, ""),
-        DataSet(IptcDataSets::UNO, "UNO", N_("Unique Name Object"), 
+        DataSet(IptcDataSets::UNO, "UNO", N_("Unique Name Object"),
                 N_("This tag provide a globally unique "
                 "identification for objects as specified in the IIM, independent of "
                 "provider and for any media form. The provider must ensure the "
-                "UNO is unique. Objects with the same UNO are identical."), 
+                "UNO is unique. Objects with the same UNO are identical."),
                 false, false, 14, 80, Exiv2::string, IptcDataSets::envelope, ""),
-        DataSet(IptcDataSets::ARMId, "ARMId", N_("ARM Identifier"), 
+        DataSet(IptcDataSets::ARMId, "ARMId", N_("ARM Identifier"),
                 N_("The DataSet identifies the Abstract Relationship Method identifier (ARM) "
                 "which is described in a document registered by the originator of "
-                "the ARM with the IPTC and NAA organizations."), 
+                "the ARM with the IPTC and NAA organizations."),
                 false, false, 2, 2, Exiv2::unsignedShort, IptcDataSets::envelope, ""),
-        DataSet(IptcDataSets::ARMVersion, "ARMVersion", N_("ARM Version"), 
+        DataSet(IptcDataSets::ARMVersion, "ARMVersion", N_("ARM Version"),
                 N_("This tag consisting of a binary number representing the particular "
-                "version of the ARM specified by tag <ARMId>."), 
+                "version of the ARM specified by tag <ARMId>."),
                 false, false, 2, 2, Exiv2::unsignedShort, IptcDataSets::envelope, ""),
-        DataSet(0xffff, "(Invalid)", "(Invalid)", 
+        DataSet(0xffff, "(Invalid)", "(Invalid)",
                 "(Invalid)", false, false, 0, 0, Exiv2::unsignedShort, IptcDataSets::envelope, "")
     };
 
@@ -167,179 +167,179 @@ namespace Exiv2 {
     }
 
     static const DataSet application2Record[] = {
-        DataSet(IptcDataSets::RecordVersion, "RecordVersion", N_("Record Version"), 
+        DataSet(IptcDataSets::RecordVersion, "RecordVersion", N_("Record Version"),
                 N_("A binary number identifying the version of the Information "
                 "Interchange Model, Part II, utilised by the provider. "
-                "Version numbers are assigned by IPTC and NAA organizations."), 
+                "Version numbers are assigned by IPTC and NAA organizations."),
                 true, false, 2, 2, Exiv2::unsignedShort, IptcDataSets::application2, ""),
-        DataSet(IptcDataSets::ObjectType, "ObjectType", N_("Object Type"), 
+        DataSet(IptcDataSets::ObjectType, "ObjectType", N_("Object Type"),
                 N_("The Object Type is used to distinguish between different types "
                 "of objects within the IIM. The first part is a number representing "
                 "a language independent international reference to an Object Type "
                 "followed by a colon separator. The second part, if used, is a text "
                 "representation of the Object Type Number consisting of graphic "
                 "characters plus spaces either in English or in the language of the "
-                "service as indicated in tag <LanguageIdentifier>"), 
+                "service as indicated in tag <LanguageIdentifier>"),
                 false, false, 3, 67, Exiv2::string, IptcDataSets::application2, ""),
-        DataSet(IptcDataSets::ObjectAttribute, "ObjectAttribute", N_("Object Attribute"), 
+        DataSet(IptcDataSets::ObjectAttribute, "ObjectAttribute", N_("Object Attribute"),
                 N_("The Object Attribute defines the nature of the object "
                 "independent of the Subject. The first part is a number representing "
                 "a language independent international reference to an Object Attribute "
                 "followed by a colon separator. The second part, if used, is a text "
                 "representation of the Object Attribute Number consisting of graphic "
                 "characters plus spaces either in English, or in the language of the "
-                "service as indicated in tag <LanguageIdentifier>"), 
+                "service as indicated in tag <LanguageIdentifier>"),
                 false, true, 4, 68, Exiv2::string, IptcDataSets::application2, ""),
-        DataSet(IptcDataSets::ObjectName, "ObjectName", N_("Object Name"), 
+        DataSet(IptcDataSets::ObjectName, "ObjectName", N_("Object Name"),
                 N_("Used as a shorthand reference for the object. Changes to exist-ing "
                 "data, such as updated stories or new crops on photos, should be "
-                "identified in tag <EditStatus>."), 
-                false, false, 0, 64, Exiv2::string, IptcDataSets::application2, 
+                "identified in tag <EditStatus>."),
+                false, false, 0, 64, Exiv2::string, IptcDataSets::application2,
                 N_("Document Title")),
-        DataSet(IptcDataSets::EditStatus, "EditStatus", N_("Edit Status"), 
-                N_("Status of the object data, according to the practice of the provider."), 
+        DataSet(IptcDataSets::EditStatus, "EditStatus", N_("Edit Status"),
+                N_("Status of the object data, according to the practice of the provider."),
                 false, false, 0, 64, Exiv2::string, IptcDataSets::application2, ""),
-        DataSet(IptcDataSets::EditorialUpdate, "EditorialUpdate", N_("Editorial Update"), 
+        DataSet(IptcDataSets::EditorialUpdate, "EditorialUpdate", N_("Editorial Update"),
                 N_("Indicates the type of update that this object provides to a "
                 "previous object. The link to the previous object is made using "
-                "the tags <ARMIdentifier> and <ARMVersion>, according to the practices of the provider."), 
+                "the tags <ARMIdentifier> and <ARMVersion>, according to the practices of the provider."),
                 false, false, 2, 2, Exiv2::string, IptcDataSets::application2, ""),
-        DataSet(IptcDataSets::Urgency, "Urgency", N_("Urgency"), 
+        DataSet(IptcDataSets::Urgency, "Urgency", N_("Urgency"),
                 N_("Specifies the editorial urgency of content and not necessarily the "
                 "envelope handling priority (see tag <EnvelopePriority>). The \"1\" "
-                "is most urgent, \"5\" normal and \"8\" denotes the least-urgent copy."), 
-                false, false, 1, 1, Exiv2::string, IptcDataSets::application2, 
+                "is most urgent, \"5\" normal and \"8\" denotes the least-urgent copy."),
+                false, false, 1, 1, Exiv2::string, IptcDataSets::application2,
                 N_("Urgency")),
-        DataSet(IptcDataSets::Subject, "Subject", N_("Subject"), 
-                N_("The Subject Reference is a structured definition of the subject matter."), 
+        DataSet(IptcDataSets::Subject, "Subject", N_("Subject"),
+                N_("The Subject Reference is a structured definition of the subject matter."),
                 false, true, 13, 236, Exiv2::string, IptcDataSets::application2, ""),
-        DataSet(IptcDataSets::Category, "Category", N_("Category"), 
+        DataSet(IptcDataSets::Category, "Category", N_("Category"),
                 N_("Identifies the subject of the object data in the opinion of the provider. "
                 "A list of categories will be maintained by a regional registry, "
-                "where available, otherwise by the provider."), 
-                false, false, 0, 3, Exiv2::string, IptcDataSets::application2, 
+                "where available, otherwise by the provider."),
+                false, false, 0, 3, Exiv2::string, IptcDataSets::application2,
                 N_("Category")),
-        DataSet(IptcDataSets::SuppCategory, "SuppCategory", N_("Supplemental Category"), 
+        DataSet(IptcDataSets::SuppCategory, "SuppCategory", N_("Supplemental Category"),
                 N_("Supplemental categories further refine the subject of an "
                 "object data. A supplemental category may include "
                 "any of the recognised categories as used in tag <Category>. Otherwise, "
-                "selection of supplemental categories are left to the provider."), 
-                false, true, 0, 32, Exiv2::string, IptcDataSets::application2, 
+                "selection of supplemental categories are left to the provider."),
+                false, true, 0, 32, Exiv2::string, IptcDataSets::application2,
                 N_("Supplemental Categories")),
-        DataSet(IptcDataSets::FixtureId, "FixtureId", N_("Fixture Id"), 
+        DataSet(IptcDataSets::FixtureId, "FixtureId", N_("Fixture Id"),
                 N_("Identifies object data that recurs often and predictably. Enables "
-                "users to immediately find or recall such an object."), 
+                "users to immediately find or recall such an object."),
                 false, false, 0, 32, Exiv2::string, IptcDataSets::application2, ""),
-        DataSet(IptcDataSets::Keywords, "Keywords", N_("Keywords"), 
+        DataSet(IptcDataSets::Keywords, "Keywords", N_("Keywords"),
                 N_("Used to indicate specific information retrieval words. "
                 "It is expected that a provider of various types of data that are related "
                 "in subject matter uses the same keyword, enabling the receiving system "
-                "or subsystems to search across all types of data for related material."), 
-                false, true, 0, 64, Exiv2::string, IptcDataSets::application2, 
+                "or subsystems to search across all types of data for related material."),
+                false, true, 0, 64, Exiv2::string, IptcDataSets::application2,
                 N_("Keywords")),
-        DataSet(IptcDataSets::LocationCode, "LocationCode", N_("Location Code"), 
+        DataSet(IptcDataSets::LocationCode, "LocationCode", N_("Location Code"),
                 N_("Indicates the code of a country/geographical location referenced "
                 "by the content of the object. Where ISO has established an appropriate "
                 "country code under ISO 3166, that code will be used. When ISO 3166 does not "
                 "adequately provide for identification of a location or a country, "
                 "e.g. ships at sea, space, IPTC will assign an appropriate three-character "
-                "code under the provisions of ISO 3166 to avoid conflicts."), 
+                "code under the provisions of ISO 3166 to avoid conflicts."),
                 false, true, 3, 3, Exiv2::string, IptcDataSets::application2, ""),
-        DataSet(IptcDataSets::LocationName, "LocationName", N_("Location Name"), 
+        DataSet(IptcDataSets::LocationName, "LocationName", N_("Location Name"),
                 N_("Provides a full, publishable name of a country/geographical "
                 "location referenced by the content of the object, according to "
-                "guidelines of the provider."), 
+                "guidelines of the provider."),
                 false, true, 0, 64, Exiv2::string, IptcDataSets::application2, ""),
-        DataSet(IptcDataSets::ReleaseDate, "ReleaseDate", N_("Release Date"), 
+        DataSet(IptcDataSets::ReleaseDate, "ReleaseDate", N_("Release Date"),
                 N_("Designates in the form CCYYMMDD the earliest date the "
-                "provider intends the object to be used. Follows ISO 8601 standard."), 
+                "provider intends the object to be used. Follows ISO 8601 standard."),
                 false, false, 8, 8, Exiv2::date, IptcDataSets::application2, ""),
-        DataSet(IptcDataSets::ReleaseTime, "ReleaseTime", N_("Release Time"), 
+        DataSet(IptcDataSets::ReleaseTime, "ReleaseTime", N_("Release Time"),
                 N_("Designates in the form HHMMSS:HHMM the earliest time the "
-                "provider intends the object to be used. Follows ISO 8601 standard."), 
+                "provider intends the object to be used. Follows ISO 8601 standard."),
                 false, false, 11, 11, Exiv2::time, IptcDataSets::application2, ""),
-        DataSet(IptcDataSets::ExpirationDate, "ExpirationDate", N_("Expiration Date"), 
+        DataSet(IptcDataSets::ExpirationDate, "ExpirationDate", N_("Expiration Date"),
                 N_("Designates in the form CCYYMMDD the latest date the provider "
-                "or owner intends the object data to be used. Follows ISO 8601 standard."), 
+                "or owner intends the object data to be used. Follows ISO 8601 standard."),
                 false, false, 8, 8, Exiv2::date, IptcDataSets::application2, ""),
-        DataSet(IptcDataSets::ExpirationTime, "ExpirationTime", N_("ExpirationTime"), 
+        DataSet(IptcDataSets::ExpirationTime, "ExpirationTime", N_("ExpirationTime"),
                 N_("Designates in the form HHMMSS:HHMM the latest time the "
-                "provider or owner intends the object data to be used. Follows ISO 8601 standard."), 
+                "provider or owner intends the object data to be used. Follows ISO 8601 standard."),
                 false, false, 11, 11, Exiv2::time, IptcDataSets::application2, ""),
-        DataSet(IptcDataSets::SpecialInstructions, "SpecialInstructions", N_("Special Instructions"), 
+        DataSet(IptcDataSets::SpecialInstructions, "SpecialInstructions", N_("Special Instructions"),
                 N_("Other editorial instructions concerning the use of the object data, "
-                "such as embargoes and warnings."), 
-                false, false, 0, 256, Exiv2::string, IptcDataSets::application2, 
+                "such as embargoes and warnings."),
+                false, false, 0, 256, Exiv2::string, IptcDataSets::application2,
                 N_("Instructions")),
-        DataSet(IptcDataSets::ActionAdvised, "ActionAdvised", N_("Action Advised"), 
+        DataSet(IptcDataSets::ActionAdvised, "ActionAdvised", N_("Action Advised"),
                 N_("Indicates the type of action that this object provides to a "
                 "previous object. The link to the previous object is made using "
-                "tags <ARMIdentifier> and <ARMVersion>, according to the practices of the provider."), 
+                "tags <ARMIdentifier> and <ARMVersion>, according to the practices of the provider."),
                 false, false, 2, 2, Exiv2::string, IptcDataSets::application2, ""),
-        DataSet(IptcDataSets::ReferenceService, "ReferenceService", N_("Reference Service"), 
+        DataSet(IptcDataSets::ReferenceService, "ReferenceService", N_("Reference Service"),
                 N_("Identifies the Service Identifier of a prior envelope to which the "
-                "current object refers."), 
+                "current object refers."),
                 false, true, 0, 10, Exiv2::string, IptcDataSets::application2, ""),
-        DataSet(IptcDataSets::ReferenceDate, "ReferenceDate", N_("Reference Date"), 
-                N_("Identifies the date of a prior envelope to which the current object refers."), 
+        DataSet(IptcDataSets::ReferenceDate, "ReferenceDate", N_("Reference Date"),
+                N_("Identifies the date of a prior envelope to which the current object refers."),
                 false, true, 8, 8, Exiv2::date, IptcDataSets::application2, ""),
-        DataSet(IptcDataSets::ReferenceNumber, "ReferenceNumber", N_("Reference Number"), 
-                N_("Identifies the Envelope Number of a prior envelope to which the current object refers."), 
+        DataSet(IptcDataSets::ReferenceNumber, "ReferenceNumber", N_("Reference Number"),
+                N_("Identifies the Envelope Number of a prior envelope to which the current object refers."),
                 false, true, 8, 8, Exiv2::string, IptcDataSets::application2, ""),
-        DataSet(IptcDataSets::DateCreated, "DateCreated", N_("Date Created"), 
+        DataSet(IptcDataSets::DateCreated, "DateCreated", N_("Date Created"),
                 N_("Represented in the form CCYYMMDD to designate the date the "
                 "intellectual content of the object data was created rather than the "
-                "date of the creation of the physical representation. Follows ISO 8601 standard."), 
-                false, false, 8, 8, Exiv2::date, IptcDataSets::application2, 
+                "date of the creation of the physical representation. Follows ISO 8601 standard."),
+                false, false, 8, 8, Exiv2::date, IptcDataSets::application2,
                 N_("Date Created")),
-        DataSet(IptcDataSets::TimeCreated, "TimeCreated", N_("Time Created"), 
+        DataSet(IptcDataSets::TimeCreated, "TimeCreated", N_("Time Created"),
                 N_("Represented in the form HHMMSS:HHMM to designate the "
                 "time the intellectual content of the object data current source "
                 "material was created rather than the creation of the physical "
-                "representation. Follows ISO 8601 standard."), 
+                "representation. Follows ISO 8601 standard."),
                 false, false, 11, 11, Exiv2::time, IptcDataSets::application2, ""),
-        DataSet(IptcDataSets::DigitizationDate, "DigitizationDate", N_("Digitization Date"), 
+        DataSet(IptcDataSets::DigitizationDate, "DigitizationDate", N_("Digitization Date"),
                 N_("Represented in the form CCYYMMDD to designate the date the "
                 "digital representation of the object data was created. Follows ISO 8601 standard."),
                 false, false, 8, 8, Exiv2::date, IptcDataSets::application2, ""),
-        DataSet(IptcDataSets::DigitizationTime, "DigitizationTime", N_("Digitization Time"), 
+        DataSet(IptcDataSets::DigitizationTime, "DigitizationTime", N_("Digitization Time"),
                 N_("Represented in the form HHMMSS:HHMM to designate the "
                 "time the digital representation of the object data was created. "
-                "Follows ISO 8601 standard."), 
+                "Follows ISO 8601 standard."),
                 false, false, 11, 11, Exiv2::time, IptcDataSets::application2, ""),
-        DataSet(IptcDataSets::Program, "Program", N_("Program"), 
-                N_("Identifies the type of program used to originate the object data."), 
+        DataSet(IptcDataSets::Program, "Program", N_("Program"),
+                N_("Identifies the type of program used to originate the object data."),
                 false, false, 0, 32, Exiv2::string, IptcDataSets::application2, ""),
-        DataSet(IptcDataSets::ProgramVersion, "ProgramVersion", N_("Program Version"), 
-                N_("Used to identify the version of the program mentioned in tag <Program>."), 
+        DataSet(IptcDataSets::ProgramVersion, "ProgramVersion", N_("Program Version"),
+                N_("Used to identify the version of the program mentioned in tag <Program>."),
                 false, false, 0, 10, Exiv2::string, IptcDataSets::application2, ""),
-        DataSet(IptcDataSets::ObjectCycle, "ObjectCycle", N_("Object Cycle"), 
-                N_("Used to identify the editorial cycle of object data."), 
+        DataSet(IptcDataSets::ObjectCycle, "ObjectCycle", N_("Object Cycle"),
+                N_("Used to identify the editorial cycle of object data."),
                 false, false, 1, 1, Exiv2::string, IptcDataSets::application2, ""),
-        DataSet(IptcDataSets::Byline, "Byline", N_("By-line"), 
+        DataSet(IptcDataSets::Byline, "Byline", N_("By-line"),
                 N_("Contains name of the creator of the object data, e.g. writer, photographer "
-                "or graphic artist."), 
-                false, true, 0, 32, Exiv2::string, IptcDataSets::application2, 
+                "or graphic artist."),
+                false, true, 0, 32, Exiv2::string, IptcDataSets::application2,
                 N_("Author")),
-        DataSet(IptcDataSets::BylineTitle, "BylineTitle", N_("By-line Title"), 
+        DataSet(IptcDataSets::BylineTitle, "BylineTitle", N_("By-line Title"),
                 N_("A by-line title is the title of the creator or creators of an "
-                "object data. Where used, a by-line title should follow the by-line it modifies."), 
+                "object data. Where used, a by-line title should follow the by-line it modifies."),
                 false, true, 0, 32, Exiv2::string, IptcDataSets::application2, "Authors Position"),
-        DataSet(IptcDataSets::City, "City", N_("City"), 
+        DataSet(IptcDataSets::City, "City", N_("City"),
                 N_("Identifies city of object data origin according to guidelines established "
-                "by the provider."), 
-                false, false, 0, 32, Exiv2::string, IptcDataSets::application2, 
+                "by the provider."),
+                false, false, 0, 32, Exiv2::string, IptcDataSets::application2,
                 N_("City")),
-        DataSet(IptcDataSets::SubLocation, "SubLocation", N_("Sub Location"), 
+        DataSet(IptcDataSets::SubLocation, "SubLocation", N_("Sub Location"),
                 N_("Identifies the location within a city from which the object data "
-                "originates, according to guidelines established by the provider."), 
+                "originates, according to guidelines established by the provider."),
                 false, false, 0, 32, Exiv2::string, IptcDataSets::application2, ""),
-        DataSet(IptcDataSets::ProvinceState, "ProvinceState", N_("Province State"), 
+        DataSet(IptcDataSets::ProvinceState, "ProvinceState", N_("Province State"),
                 N_("Identifies Province/State of origin according to guidelines "
-                "established by the provider."), 
-                false, false, 0, 32, Exiv2::string, IptcDataSets::application2, 
+                "established by the provider."),
+                false, false, 0, 32, Exiv2::string, IptcDataSets::application2,
                 N_("State/Province")),
-        DataSet(IptcDataSets::CountryCode, "CountryCode", N_("Country Code"), 
+        DataSet(IptcDataSets::CountryCode, "CountryCode", N_("Country Code"),
                 N_("Indicates the code of the country/primary location where the "
                 "intellectual property of the object data was created, e.g. a photo "
                 "was taken, an event occurred. Where ISO has established an appropriate "
@@ -347,94 +347,94 @@ namespace Exiv2 {
                 "adequately provide for identification of a location or a new "
                 "country, e.g. ships at sea, space, IPTC will assign an "
                 "appropriate three-character code under the provisions of "
-                "ISO 3166 to avoid conflicts."), 
+                "ISO 3166 to avoid conflicts."),
                 false, false, 3, 3, Exiv2::string, IptcDataSets::application2, ""),
-        DataSet(IptcDataSets::CountryName, "CountryName", N_("Country Name"), 
+        DataSet(IptcDataSets::CountryName, "CountryName", N_("Country Name"),
                 N_("Provides full, publishable, name of the country/primary location "
                 "where the intellectual property of the object data was created, "
-                "according to guidelines of the provider."), 
-                false, false, 0, 64, Exiv2::string, IptcDataSets::application2, 
+                "according to guidelines of the provider."),
+                false, false, 0, 64, Exiv2::string, IptcDataSets::application2,
                 N_("Country")),
-        DataSet(IptcDataSets::TransmissionReference, "TransmissionReference", N_("Transmission Reference"), 
+        DataSet(IptcDataSets::TransmissionReference, "TransmissionReference", N_("Transmission Reference"),
                 N_("A code representing the location of original transmission according "
-                "to practices of the provider."), 
-                false, false, 0, 32, Exiv2::string, IptcDataSets::application2, 
+                "to practices of the provider."),
+                false, false, 0, 32, Exiv2::string, IptcDataSets::application2,
                 N_("Transmission Reference")),
-        DataSet(IptcDataSets::Headline, "Headline", N_("Headline"), 
-                N_("A publishable entry providing a synopsis of the contents of the object data."), 
-                false, false, 0, 256, Exiv2::string, IptcDataSets::application2, 
+        DataSet(IptcDataSets::Headline, "Headline", N_("Headline"),
+                N_("A publishable entry providing a synopsis of the contents of the object data."),
+                false, false, 0, 256, Exiv2::string, IptcDataSets::application2,
                 N_("Headline")),
-        DataSet(IptcDataSets::Credit, "Credit", N_("Credit"), 
-                N_("Identifies the provider of the object data, not necessarily the owner/creator."), 
-                false, false, 0, 32, Exiv2::string, IptcDataSets::application2, 
+        DataSet(IptcDataSets::Credit, "Credit", N_("Credit"),
+                N_("Identifies the provider of the object data, not necessarily the owner/creator."),
+                false, false, 0, 32, Exiv2::string, IptcDataSets::application2,
                 N_("Credit")),
-        DataSet(IptcDataSets::Source, "Source", N_("Source"), 
+        DataSet(IptcDataSets::Source, "Source", N_("Source"),
                 N_("Identifies the original owner of the intellectual content of the "
-                "object data. This could be an agency, a member of an agency or an individual."), 
-                false, false, 0, 32, Exiv2::string, IptcDataSets::application2, 
+                "object data. This could be an agency, a member of an agency or an individual."),
+                false, false, 0, 32, Exiv2::string, IptcDataSets::application2,
                 N_("Source")),
-        DataSet(IptcDataSets::Copyright, "Copyright", N_("Copyright"), 
-                N_("Contains any necessary copyright notice."), 
-                false, false, 0, 128, Exiv2::string, IptcDataSets::application2, 
+        DataSet(IptcDataSets::Copyright, "Copyright", N_("Copyright"),
+                N_("Contains any necessary copyright notice."),
+                false, false, 0, 128, Exiv2::string, IptcDataSets::application2,
                 N_("Copyright Notice")),
-        DataSet(IptcDataSets::Contact, "Contact", N_("Contact"), 
+        DataSet(IptcDataSets::Contact, "Contact", N_("Contact"),
                 N_("Identifies the person or organisation which can provide further "
-                "background information on the object data."), 
+                "background information on the object data."),
                 false, true, 0, 128, Exiv2::string, IptcDataSets::application2, ""),
-        DataSet(IptcDataSets::Caption, "Caption", N_("Caption"), 
-                N_("A textual description of the object data."), 
-                false, false, 0, 2000, Exiv2::string, IptcDataSets::application2, 
+        DataSet(IptcDataSets::Caption, "Caption", N_("Caption"),
+                N_("A textual description of the object data."),
+                false, false, 0, 2000, Exiv2::string, IptcDataSets::application2,
                 N_("Description")),
-        DataSet(IptcDataSets::Writer, "Writer", N_("Writer"), 
+        DataSet(IptcDataSets::Writer, "Writer", N_("Writer"),
                 N_("Identification of the name of the person involved in the writing, "
-                "editing or correcting the object data or caption/abstract."), 
+                "editing or correcting the object data or caption/abstract."),
                 false, true, 0, 32, Exiv2::string, IptcDataSets::application2, "Description writer"),
-        DataSet(IptcDataSets::RasterizedCaption, "RasterizedCaption", N_("Rasterized Caption"), 
+        DataSet(IptcDataSets::RasterizedCaption, "RasterizedCaption", N_("Rasterized Caption"),
                 N_("Contains the rasterized object data description and is used "
-                "where characters that have not been coded are required for the caption."), 
+                "where characters that have not been coded are required for the caption."),
                 false, false, 7360, 7360, Exiv2::undefined, IptcDataSets::application2, ""),
-        DataSet(IptcDataSets::ImageType, "ImageType", N_("Image Type"), 
-                N_("Indicates the color components of an image."), 
+        DataSet(IptcDataSets::ImageType, "ImageType", N_("Image Type"),
+                N_("Indicates the color components of an image."),
                 false, false, 2, 2, Exiv2::string, IptcDataSets::application2, ""),
-        DataSet(IptcDataSets::ImageOrientation, "ImageOrientation", N_("Image Orientation"), 
-                N_("Indicates the layout of an image."), 
+        DataSet(IptcDataSets::ImageOrientation, "ImageOrientation", N_("Image Orientation"),
+                N_("Indicates the layout of an image."),
                 false, false, 1, 1, Exiv2::string, IptcDataSets::application2, ""),
-        DataSet(IptcDataSets::Language, "Language", N_("Language"), 
+        DataSet(IptcDataSets::Language, "Language", N_("Language"),
                 N_("Describes the major national language of the object, according "
                 "to the 2-letter codes of ISO 639:1988. Does not define or imply "
                 "any coded character set, but is used for internal routing, e.g. to "
-                "various editorial desks."), 
+                "various editorial desks."),
                 false, false, 2, 3, Exiv2::string, IptcDataSets::application2, ""),
-        DataSet(IptcDataSets::AudioType, "AudioType", N_("Audio Type"), 
-                N_("Indicates the type of an audio content."), 
+        DataSet(IptcDataSets::AudioType, "AudioType", N_("Audio Type"),
+                N_("Indicates the type of an audio content."),
                 false, false, 2, 2, Exiv2::string, IptcDataSets::application2, ""),
-        DataSet(IptcDataSets::AudioRate, "AudioRate", N_("Audio Rate"), 
-                N_("Indicates the sampling rate in Hertz of an audio content."), 
+        DataSet(IptcDataSets::AudioRate, "AudioRate", N_("Audio Rate"),
+                N_("Indicates the sampling rate in Hertz of an audio content."),
                 false, false, 6, 6, Exiv2::string, IptcDataSets::application2, ""),
-        DataSet(IptcDataSets::AudioResolution, "AudioResolution", N_("Audio Resolution"), 
-                N_("Indicates the sampling resolution of an audio content."), 
+        DataSet(IptcDataSets::AudioResolution, "AudioResolution", N_("Audio Resolution"),
+                N_("Indicates the sampling resolution of an audio content."),
                 false, false, 2, 2, Exiv2::string, IptcDataSets::application2, ""),
-        DataSet(IptcDataSets::AudioDuration, "AudioDuration", N_("Audio Duration"), 
-                N_("Indicates the duration of an audio content."), 
+        DataSet(IptcDataSets::AudioDuration, "AudioDuration", N_("Audio Duration"),
+                N_("Indicates the duration of an audio content."),
                 false, false, 6, 6, Exiv2::string, IptcDataSets::application2, ""),
-        DataSet(IptcDataSets::AudioOutcue, "AudioOutcue", N_("Audio Outcue"), 
+        DataSet(IptcDataSets::AudioOutcue, "AudioOutcue", N_("Audio Outcue"),
                 N_("Identifies the content of the end of an audio object data, "
-                "according to guidelines established by the provider."), 
+                "according to guidelines established by the provider."),
                 false, false, 0, 64, Exiv2::string, IptcDataSets::application2, ""),
-        DataSet(IptcDataSets::PreviewFormat, "PreviewFormat", N_("Preview Format"), 
+        DataSet(IptcDataSets::PreviewFormat, "PreviewFormat", N_("Preview Format"),
                 N_("A binary number representing the file format of the object data "
                 "preview. The file format must be registered with IPTC or NAA organizations "
-                "with a unique number assigned to it."), 
+                "with a unique number assigned to it."),
                 false, false, 2, 2, Exiv2::unsignedShort, IptcDataSets::application2, ""),
-        DataSet(IptcDataSets::PreviewVersion, "PreviewVersion", N_("Preview Version"), 
+        DataSet(IptcDataSets::PreviewVersion, "PreviewVersion", N_("Preview Version"),
                 N_("A binary number representing the particular version of the "
-                "object data preview file format specified in tag <PreviewFormat>."), 
+                "object data preview file format specified in tag <PreviewFormat>."),
                 false, false, 2, 2, Exiv2::unsignedShort, IptcDataSets::application2, ""),
-        DataSet(IptcDataSets::Preview, "Preview", N_("Preview Data"), 
-                N_("Binary image preview data."), 
+        DataSet(IptcDataSets::Preview, "Preview", N_("Preview Data"),
+                N_("Binary image preview data."),
                 false, false, 0, 256000, Exiv2::undefined, IptcDataSets::application2, ""),
-        DataSet(0xffff, "(Invalid)", N_("(Invalid)"), 
-                N_("(Invalid)"), 
+        DataSet(0xffff, "(Invalid)", N_("(Invalid)"),
+                N_("(Invalid)"),
                 false, false, 0, 0, Exiv2::unsignedShort, IptcDataSets::application2, "")
     };
 
@@ -443,10 +443,10 @@ namespace Exiv2 {
         return application2Record;
     }
 
-    static const DataSet unknownDataSet(0xffff, "Unknown dataset", N_("Unknown dataset"), 
-                                        N_("Unknown dataset"), 
-                                        false, true, 0, 0xffffffff, Exiv2::string, 
-                                        IptcDataSets::invalidRecord, 
+    static const DataSet unknownDataSet(0xffff, "Unknown dataset", N_("Unknown dataset"),
+                                        N_("Unknown dataset"),
+                                        false, true, 0, 0xffffffff, Exiv2::string,
+                                        IptcDataSets::invalidRecord,
                                         N_("Unknown dataset"));
 
     // Dataset lookup lists.This is an array with pointers to one list per IIM4 Record.
diff --git a/src/doxygen.hpp b/src/doxygen.hpp
index 4f5cba68..c6bd5690 100644
--- a/src/doxygen.hpp
+++ b/src/doxygen.hpp
@@ -100,8 +100,8 @@ bug tracking system</a>.</p>
   published by the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.</P>
 
-  <P>Alternatively, %Exiv2 is also available with a commercial license, which 
-  allows it to be used in closed-source projects. 
+  <P>Alternatively, %Exiv2 is also available with a commercial license, which
+  allows it to be used in closed-source projects.
   <A HREF="mailto:ahuggel@gmx.net">Contact me</A> for more information.</P>
 
   <P>%Exiv2 is distributed in the hope that it will be useful, but WITHOUT ANY
diff --git a/src/exif.cpp b/src/exif.cpp
index f5be5c87..c63a2e2d 100644
--- a/src/exif.cpp
+++ b/src/exif.cpp
@@ -483,12 +483,12 @@ namespace Exiv2 {
         assert(tmpIfd0.get() != 0);
         rc = tmpIfd0->read(tmpData.pData_,
                            tmpData.size_,
-                           tmpTiffHeader->offset(), 
+                           tmpTiffHeader->offset(),
                            tmpTiffHeader->byteOrder());
         if (rc) return rc; // no point to continue if there is no IFD0
 
         // We have at least a valid IFD0, so replace old metadata with new now
-        // After this point we only return 0 (success), although parts of the 
+        // After this point we only return 0 (success), although parts of the
         // Exif data may be missing due to problems reading specific IFDs.
 
         this->clear(); // Deletes existing pointers
diff --git a/src/exiv2.cpp b/src/exiv2.cpp
index b1888296..3a29ba32 100644
--- a/src/exiv2.cpp
+++ b/src/exiv2.cpp
@@ -319,7 +319,7 @@ int Params::option(int opt, const std::string& optarg, int optopt)
         break;
     default:
         std::cerr << progname()
-                  << ": " << _("getopt returned unexpected character code") << " " 
+                  << ": " << _("getopt returned unexpected character code") << " "
                   << std::hex << opt << "\n";
         rc = 1;
         break;
@@ -363,7 +363,7 @@ int Params::evalAdjust(const std::string& optarg)
         action_ = Action::adjust;
         adjust_ = parseTime(optarg, adjustment_);
         if (!adjust_) {
-            std::cerr << progname() << ": " << _("Error parsing -a option argument") << " `" 
+            std::cerr << progname() << ": " << _("Error parsing -a option argument") << " `"
                       << optarg << "'\n";
             rc = 1;
         }
@@ -394,18 +394,18 @@ int Params::evalPrint(const std::string& optarg)
         case 'i': printMode_ = pmIptc; break;
         case 'c': printMode_ = pmComment; break;
         default:
-            std::cerr << progname() << ": " << _("Unrecognized print mode") << " `" 
+            std::cerr << progname() << ": " << _("Unrecognized print mode") << " `"
                       << optarg << "'\n";
             rc = 1;
             break;
         }
         break;
     case Action::print:
-        std::cerr << progname() << ": " 
+        std::cerr << progname() << ": "
                   << _("Ignoring surplus option -p") << optarg << "\n";
         break;
     default:
-        std::cerr << progname() << ": " 
+        std::cerr << progname() << ": "
                   << _("Option -p is not compatible with a previous option\n");
         rc = 1;
         break;
@@ -434,7 +434,7 @@ int Params::evalPrintCols(const std::string& optarg)
             case 't': printItems_ |= prTrans; break;
             case 'h': printItems_ |= prHex;   break;
             default:
-                std::cerr << progname() << ": " << _("Unrecognized print item") << " `" 
+                std::cerr << progname() << ": " << _("Unrecognized print item") << " `"
                           << optarg[i] << "'\n";
                 rc = 1;
                 break;
@@ -442,11 +442,11 @@ int Params::evalPrintCols(const std::string& optarg)
         }
         break;
     case Action::print:
-        std::cerr << progname() << ": " 
+        std::cerr << progname() << ": "
                   << _("Ignoring surplus option -P") << optarg << "\n";
         break;
     default:
-        std::cerr << progname() << ": " 
+        std::cerr << progname() << ": "
                   << _("Option -P is not compatible with a previous option\n");
         rc = 1;
         break;
@@ -473,7 +473,7 @@ int Params::evalDelete(const std::string& optarg)
         }
         break;
     default:
-        std::cerr << progname() << ": " 
+        std::cerr << progname() << ": "
                   << _("Option -d is not compatible with a previous option\n");
         rc = 1;
         break;
@@ -500,7 +500,7 @@ int Params::evalExtract(const std::string& optarg)
         }
         break;
     default:
-        std::cerr << progname() << ": " 
+        std::cerr << progname() << ": "
                   << _("Option -e is not compatible with a previous option\n");
         rc = 1;
         break;
@@ -527,7 +527,7 @@ int Params::evalInsert(const std::string& optarg)
         }
         break;
     default:
-        std::cerr << progname() << ": " 
+        std::cerr << progname() << ": "
                   << _("Option -i is not compatible with a previous option\n");
         rc = 1;
         break;
@@ -548,7 +548,7 @@ int Params::evalModify(int opt, const std::string& optarg)
         if (opt == 'M') cmdLines_.push_back(optarg);  // parse the commands later
         break;
     default:
-        std::cerr << progname() << ": " 
+        std::cerr << progname() << ": "
                   << _("Option") << " -" << (char)opt << " "
                   << _("is not compatible with a previous option\n");
         rc = 1;
@@ -566,7 +566,7 @@ int Params::nonoption(const std::string& argv)
         first_ = false;
         if (argv == "ad" || argv == "adjust") {
             if (action_ != Action::none && action_ != Action::adjust) {
-                std::cerr << progname() << ": " 
+                std::cerr << progname() << ": "
                           << _("Action adjust is not compatible with the given options\n");
                 rc = 1;
             }
@@ -575,7 +575,7 @@ int Params::nonoption(const std::string& argv)
         }
         if (argv == "pr" || argv == "print") {
             if (action_ != Action::none && action_ != Action::print) {
-                std::cerr << progname() << ": " 
+                std::cerr << progname() << ": "
                           << _("Action print is not compatible with the given options\n");
                 rc = 1;
             }
@@ -584,7 +584,7 @@ int Params::nonoption(const std::string& argv)
         }
         if (argv == "rm" || argv == "delete") {
             if (action_ != Action::none && action_ != Action::erase) {
-                std::cerr << progname() << ": " 
+                std::cerr << progname() << ": "
                           << _("Action delete is not compatible with the given options\n");
                 rc = 1;
             }
@@ -593,7 +593,7 @@ int Params::nonoption(const std::string& argv)
         }
         if (argv == "ex" || argv == "extract") {
             if (action_ != Action::none && action_ != Action::extract) {
-                std::cerr << progname() << ": " 
+                std::cerr << progname() << ": "
                           << _("Action extract is not compatible with the given options\n");
                 rc = 1;
             }
@@ -602,7 +602,7 @@ int Params::nonoption(const std::string& argv)
         }
         if (argv == "in" || argv == "insert") {
             if (action_ != Action::none && action_ != Action::insert) {
-                std::cerr << progname() << ": " 
+                std::cerr << progname() << ": "
                           << _("Action insert is not compatible with the given options\n");
                 rc = 1;
             }
@@ -611,7 +611,7 @@ int Params::nonoption(const std::string& argv)
         }
         if (argv == "mv" || argv == "rename") {
             if (action_ != Action::none && action_ != Action::rename) {
-                std::cerr << progname() << ": " 
+                std::cerr << progname() << ": "
                           << _("Action rename is not compatible with the given options\n");
                 rc = 1;
             }
@@ -620,7 +620,7 @@ int Params::nonoption(const std::string& argv)
         }
         if (argv == "mo" || argv == "modify") {
             if (action_ != Action::none && action_ != Action::modify) {
-                std::cerr << progname() << ": " 
+                std::cerr << progname() << ": "
                           << _("Action modify is not compatible with the given options\n");
                 rc = 1;
             }
@@ -629,7 +629,7 @@ int Params::nonoption(const std::string& argv)
         }
         if (argv == "fi" || argv == "fixiso") {
             if (action_ != Action::none && action_ != Action::fixiso) {
-                std::cerr << progname() << ": " 
+                std::cerr << progname() << ": "
                           << _("Action fixiso is not compatible with the given options\n");
                 rc = 1;
             }
@@ -658,13 +658,13 @@ int Params::getopt(int argc, char* const argv[])
         rc = 1;
     }
     if (action_ == Action::adjust && !adjust_) {
-        std::cerr << progname() << ": " 
+        std::cerr << progname() << ": "
                   << _("Adjust action requires option -a time\n");
         rc = 1;
     }
     if (   action_ == Action::modify
         && cmdFiles_.empty() && cmdLines_.empty() && jpegComment_.empty()) {
-        std::cerr << progname() << ": " 
+        std::cerr << progname() << ": "
                   << _("Modify action requires at least one -c, -m or -M option\n");
         rc = 1;
     }
@@ -688,22 +688,22 @@ int Params::getopt(int argc, char* const argv[])
     }
     if (   !directory_.empty()
         && !(action_ == Action::insert || action_ == Action::extract)) {
-        std::cerr << progname() << ": " 
+        std::cerr << progname() << ": "
                   << _("-l option can only be used with extract or insert actions\n");
         rc = 1;
     }
     if (!suffix_.empty() && !(action_ == Action::insert)) {
-        std::cerr << progname() << ": " 
+        std::cerr << progname() << ": "
                   << _("-S option can only be used with insert action\n");
         rc = 1;
     }
     if (timestamp_ && !(action_ == Action::rename)) {
-        std::cerr << progname() << ": " 
+        std::cerr << progname() << ": "
                   << _("-t option can only be used with rename action\n");
         rc = 1;
     }
     if (timestampOnly_ && !(action_ == Action::rename)) {
-        std::cerr << progname() << ": " 
+        std::cerr << progname() << ": "
                   << _("-T option can only be used with rename action\n");
         rc = 1;
     }
@@ -787,7 +787,7 @@ namespace {
             try {
                 std::ifstream file(filename->c_str());
                 if (!file) {
-                    std::cerr << *filename << ": " 
+                    std::cerr << *filename << ": "
                               << _("Failed to open command file for reading\n");
                     return false;
                 }
diff --git a/src/fujimn.cpp b/src/fujimn.cpp
index c781b0ff..3bf801c8 100644
--- a/src/fujimn.cpp
+++ b/src/fujimn.cpp
@@ -182,110 +182,110 @@ namespace Exiv2 {
 
     // Fujifilm MakerNote Tag Info
     const TagInfo FujiMakerNote::tagInfo_[] = {
-        TagInfo(0x0000, "Version", N_("Version"), 
-                N_("Fujifilm Makernote version"), 
+        TagInfo(0x0000, "Version", N_("Version"),
+                N_("Fujifilm Makernote version"),
                 fujiIfdId, makerTags, undefined, printValue),
-        TagInfo(0x0010, "SerialNumber", N_("Serial Number"), 
+        TagInfo(0x0010, "SerialNumber", N_("Serial Number"),
                 N_("This number is unique, and contains the date of manufacture, "
-                   "but is not the same as the number printed on the camera body."), 
+                   "but is not the same as the number printed on the camera body."),
                 fujiIfdId, makerTags, asciiString, printValue),
-        TagInfo(0x1000, "Quality", N_("Quality"), 
-                N_("Image quality setting"), 
+        TagInfo(0x1000, "Quality", N_("Quality"),
+                N_("Image quality setting"),
                 fujiIfdId, makerTags, asciiString, printValue),
-        TagInfo(0x1001, N_("Sharpness"), N_("Sharpness"), 
-                N_("Sharpness setting"), 
+        TagInfo(0x1001, N_("Sharpness"), N_("Sharpness"),
+                N_("Sharpness setting"),
                 fujiIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(fujiSharpness)),
-        TagInfo(0x1002, "WhiteBalance", N_("White Balance"), 
-                N_("White balance setting"), 
+        TagInfo(0x1002, "WhiteBalance", N_("White Balance"),
+                N_("White balance setting"),
                 fujiIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(fujiWhiteBalance)),
-        TagInfo(0x1003, "Color", N_("Color"), 
-                N_("Chroma saturation setting"), 
+        TagInfo(0x1003, "Color", N_("Color"),
+                N_("Chroma saturation setting"),
                 fujiIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(fujiColor)),
-        TagInfo(0x1004, "Tone", N_("Tone"), 
-                N_("Contrast setting"), 
+        TagInfo(0x1004, "Tone", N_("Tone"),
+                N_("Contrast setting"),
                 fujiIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(fujiTone)),
-        TagInfo(0x1010, "FlashMode", N_("Flash Mode"), 
-                N_("Flash firing mode setting"), 
+        TagInfo(0x1010, "FlashMode", N_("Flash Mode"),
+                N_("Flash firing mode setting"),
                 fujiIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(fujiFlashMode)),
-        TagInfo(0x1011, "FlashStrength", N_("Flash Strength"), 
-                N_("Flash firing strength compensation setting"), 
+        TagInfo(0x1011, "FlashStrength", N_("Flash Strength"),
+                N_("Flash firing strength compensation setting"),
                 fujiIfdId, makerTags, signedRational, printValue),
-        TagInfo(0x1020, "Macro", N_("Macro"), 
-                N_("Macro mode setting"), 
+        TagInfo(0x1020, "Macro", N_("Macro"),
+                N_("Macro mode setting"),
                 fujiIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(fujiOffOn)),
-        TagInfo(0x1021, "FocusMode", N_("Focus Mode"), 
-                N_("Focusing mode setting"), 
+        TagInfo(0x1021, "FocusMode", N_("Focus Mode"),
+                N_("Focusing mode setting"),
                 fujiIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(fujiFocusMode)),
-        TagInfo(0x1022, "0x1022", "0x1022", 
-                N_("Unknown"), 
+        TagInfo(0x1022, "0x1022", "0x1022",
+                N_("Unknown"),
                 fujiIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x1030, "SlowSync", N_("Slow Sync"), 
-                N_("Slow synchro mode setting"), 
+        TagInfo(0x1030, "SlowSync", N_("Slow Sync"),
+                N_("Slow synchro mode setting"),
                 fujiIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(fujiOffOn)),
-        TagInfo(0x1031, "PictureMode", N_("Picture Mode"), 
-                N_("Picture mode setting"), 
+        TagInfo(0x1031, "PictureMode", N_("Picture Mode"),
+                N_("Picture mode setting"),
                 fujiIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(fujiPictureMode)),
-        TagInfo(0x1032, "0x1032", "0x1032", 
-                N_("Unknown"), 
+        TagInfo(0x1032, "0x1032", "0x1032",
+                N_("Unknown"),
                 fujiIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x1100, "Continuous", N_("Continuous"), 
-                N_("Continuous shooting or auto bracketing setting"), 
+        TagInfo(0x1100, "Continuous", N_("Continuous"),
+                N_("Continuous shooting or auto bracketing setting"),
                 fujiIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(fujiContinuous)),
-        TagInfo(0x1101, "SequenceNumber", N_("Sequence Number"), 
-                N_("Sequence number"), 
+        TagInfo(0x1101, "SequenceNumber", N_("Sequence Number"),
+                N_("Sequence number"),
                 fujiIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x1200, "0x1200", "0x1200", 
-                N_("Unknown"), 
+        TagInfo(0x1200, "0x1200", "0x1200",
+                N_("Unknown"),
                 fujiIfdId, makerTags, unsignedShort, printValue),
         TagInfo(0x1210, "FinePixColor", N_("FinePix Color"),
-                N_("Fuji FinePix color setting"), 
+                N_("Fuji FinePix color setting"),
                 fujiIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(fujiFinePixColor)),
-        TagInfo(0x1300, "BlurWarning", N_("Blur Warning"), 
-                N_("Blur warning status"), 
+        TagInfo(0x1300, "BlurWarning", N_("Blur Warning"),
+                N_("Blur warning status"),
                 fujiIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(fujiOffOn)),
-        TagInfo(0x1301, "FocusWarning", N_("Focus Warning"), 
-                N_("Auto Focus warning status"), 
+        TagInfo(0x1301, "FocusWarning", N_("Focus Warning"),
+                N_("Auto Focus warning status"),
                 fujiIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(fujiOffOn)),
-        TagInfo(0x1302, "ExposureWarning", N_("Exposure Warning"), 
-                N_("Auto exposure warning status"), 
+        TagInfo(0x1302, "ExposureWarning", N_("Exposure Warning"),
+                N_("Auto exposure warning status"),
                 fujiIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(fujiOffOn)),
-        TagInfo(0x1400, "DynamicRange", N_("Dynamic Range"), 
-                N_("Dynamic range"), 
+        TagInfo(0x1400, "DynamicRange", N_("Dynamic Range"),
+                N_("Dynamic range"),
                 fujiIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(fujiDynamicRange)),
-        TagInfo(0x1401, "FilmMode", N_("Film Mode"), 
-                N_("Film mode"), 
+        TagInfo(0x1401, "FilmMode", N_("Film Mode"),
+                N_("Film mode"),
                 fujiIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(fujiFilmMode)),
-        TagInfo(0x1402, "DynamicRangeSetting", N_("Dynamic Range Setting"), 
-                N_("Dynamic range settings"), 
+        TagInfo(0x1402, "DynamicRangeSetting", N_("Dynamic Range Setting"),
+                N_("Dynamic range settings"),
                 fujiIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(fujiDynamicRangeSetting)),
-        TagInfo(0x1403, "DevelopmentDynamicRange", N_("Development Dynamic Range"), 
-                N_("Development dynamic range"), 
+        TagInfo(0x1403, "DevelopmentDynamicRange", N_("Development Dynamic Range"),
+                N_("Development dynamic range"),
                 fujiIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x1404, "MinFocalLength", N_("Minimum Focal Length"), 
-                N_("Minimum focal length"), 
+        TagInfo(0x1404, "MinFocalLength", N_("Minimum Focal Length"),
+                N_("Minimum focal length"),
                 fujiIfdId, makerTags, unsignedRational, printValue),
-        TagInfo(0x1405, "MaxFocalLength", N_("Maximum Focal Length"), 
-                N_("Maximum focal length"), 
+        TagInfo(0x1405, "MaxFocalLength", N_("Maximum Focal Length"),
+                N_("Maximum focal length"),
                 fujiIfdId, makerTags, unsignedRational, printValue),
-        TagInfo(0x1406, "MaxApertureAtMinFocal", N_("Maximum Aperture at Mininimum Focal"), 
-                N_("Maximum aperture at mininimum focal"), 
+        TagInfo(0x1406, "MaxApertureAtMinFocal", N_("Maximum Aperture at Mininimum Focal"),
+                N_("Maximum aperture at mininimum focal"),
                 fujiIfdId, makerTags, unsignedRational, printValue),
-        TagInfo(0x1407, "MaxApertureAtMaxFocal", N_("Maximum Aperture at Maxinimum Focal"), 
-                N_("Maximum aperture at maxinimum focal"), 
+        TagInfo(0x1407, "MaxApertureAtMaxFocal", N_("Maximum Aperture at Maxinimum Focal"),
+                N_("Maximum aperture at maxinimum focal"),
                 fujiIfdId, makerTags, unsignedRational, printValue),
-        TagInfo(0x8000, "FileSource", N_("File Source"), 
-                N_("File source"), 
+        TagInfo(0x8000, "FileSource", N_("File Source"),
+                N_("File source"),
                 fujiIfdId, makerTags, asciiString, printValue),
-        TagInfo(0x8002, "OrderNumber", N_("Order Number"), 
-                N_("Order number"), 
+        TagInfo(0x8002, "OrderNumber", N_("Order Number"),
+                N_("Order number"),
                 fujiIfdId, makerTags, unsignedLong, printValue),
-        TagInfo(0x8003, "FrameNumber", N_("Frame Number"), 
-                N_("Frame number"), 
+        TagInfo(0x8003, "FrameNumber", N_("Frame Number"),
+                N_("Frame number"),
                 fujiIfdId, makerTags, unsignedShort, printValue),
 
         // End of list marker
-        TagInfo(0xffff, "(UnknownFujiMakerNoteTag)", "(UnknownFujiMakerNoteTag)", 
-                N_("Unknown FujiMakerNote tag"), 
+        TagInfo(0xffff, "(UnknownFujiMakerNoteTag)", "(UnknownFujiMakerNoteTag)",
+                N_("Unknown FujiMakerNote tag"),
                 fujiIfdId, makerTags, invalidTypeId, printValue)
     };
 
diff --git a/src/i18n.h b/src/i18n.h
index 6d1a926e..3a1038b9 100644
--- a/src/i18n.h
+++ b/src/i18n.h
@@ -20,7 +20,7 @@
  */
 /*
   File:      i18n.h
-  Brief:     i18n definitions. Do not use. This is an Exiv2 internal header. 
+  Brief:     i18n definitions. Do not use. This is an Exiv2 internal header.
   Version:   $Rev$
   Author(s): Gilles Caulier (gc) <caulier.gilles@kdemail.net>
   History:   01-Nov-06, gc: created
diff --git a/src/ifd.cpp b/src/ifd.cpp
index d82570a9..1012eda3 100644
--- a/src/ifd.cpp
+++ b/src/ifd.cpp
@@ -334,7 +334,7 @@ namespace Exiv2 {
             // Sanity check with an "unreasonably" large number
             if (n > 256) {
 #ifndef SUPPRESS_WARNINGS
-                std::cerr << "Error: " 
+                std::cerr << "Error: "
                           << "Directory " << ExifTags::ifdName(ifdId_) << " with "
                           << n << " entries considered invalid; not read.\n";
 #endif
@@ -380,7 +380,7 @@ namespace Exiv2 {
                     pNext_ = const_cast<byte*>(buf + o);
                 }
                 next_ = getULong(buf + o, byteOrder);
-                if (   static_cast<long>(next_) + shift < 0 
+                if (   static_cast<long>(next_) + shift < 0
                     || static_cast<long>(next_) + shift >= len) {
 #ifndef SUPPRESS_WARNINGS
                     std::cerr << "Warning: " << ExifTags::ifdName(ifdId_)
diff --git a/src/largeiptc-test.cpp b/src/largeiptc-test.cpp
index a9075e62..f91f7994 100644
--- a/src/largeiptc-test.cpp
+++ b/src/largeiptc-test.cpp
@@ -48,13 +48,13 @@ try {
     uint32_t sizeData;
     Exiv2::Photoshop::locateIptcIrb(irb.pData_, irb.size_, &record, &sizeHdr, &sizeData);
     Exiv2::DataBuf rawIptc = iptcData.copy();
-    std::cout << "Comparing IPTC and IRB size... "; 
+    std::cout << "Comparing IPTC and IRB size... ";
     if (static_cast<uint32_t>(rawIptc.size_) != sizeData) {
-        std::cout << "not ";        
+        std::cout << "not ";
     }
     std::cout << "ok\n";
 
-    std::cout << "Comparing IPTC and IRB data... "; 
+    std::cout << "Comparing IPTC and IRB data... ";
     if (0 != memcmp(rawIptc.pData_, record + sizeHdr, sizeData)) {
         std::cout << "not ";
     }
diff --git a/src/makernote2.hpp b/src/makernote2.hpp
index 420bee41..ec5e3da9 100644
--- a/src/makernote2.hpp
+++ b/src/makernote2.hpp
@@ -20,7 +20,7 @@
  */
 /*!
   @file    makernote2.hpp
-  @brief   Makernote TIFF composite class TiffIfdMakernote and classes for 
+  @brief   Makernote TIFF composite class TiffIfdMakernote and classes for
            various makernote headers.
   @version $Rev$
   @author  Andreas Huggel (ahu)
@@ -163,7 +163,7 @@ namespace Exiv2 {
         virtual ByteOrder byteOrder() const { return invalidByteOrder; }
         /*!
           @brief Return the base offset for the makernote IFD entries relative
-                 to the start of the TIFF header. \em mnOffset is the offset 
+                 to the start of the TIFF header. \em mnOffset is the offset
                  to the makernote from the start of the TIFF header.
          */
         virtual uint32_t baseOffset(uint32_t /*mnOffset*/) const { return 0; }
diff --git a/src/minoltamn.cpp b/src/minoltamn.cpp
index f359c981..d31848a3 100644
--- a/src/minoltamn.cpp
+++ b/src/minoltamn.cpp
@@ -65,8 +65,8 @@ namespace Exiv2 {
         { 14, N_("Natural+ sRGB")  },
         { 15, N_("Landscape")      },
         { 16, N_("Evening")        },	
-        { 17, N_("Night Scene")    },    
-        { 18, N_("Night Portrait") }    
+        { 17, N_("Night Scene")    },
+        { 18, N_("Night Portrait") }
     };
 
     //! Lookup table to translate Minolta image quality values to readable labels
@@ -93,8 +93,8 @@ namespace Exiv2 {
     };
 
     //! Lookup table to translate Minolta Lens id values to readable labels
-    /* NOTE: 
-       - duplicate tags value are: 
+    /* NOTE:
+       - duplicate tags value are:
        0/25520, 4/25920, 13/25610, 19/25910, 22/26050/26070,
        25500/25501/26130, 25540/25541/25850, 25580/25581, 2564025641,
        25720/25721, 25790/25791, 25960/25961, 25980/25981, 26150/26151
@@ -217,67 +217,67 @@ namespace Exiv2 {
 
     // Minolta Tag Info
     const TagInfo MinoltaMakerNote::tagInfo_[] = {
-        TagInfo(0x0000, "Version", N_("Makernote Version"), 
-                N_("String 'MLT0' (not null terminated)"), 
+        TagInfo(0x0000, "Version", N_("Makernote Version"),
+                N_("String 'MLT0' (not null terminated)"),
                 minoltaIfdId, makerTags, undefined, printValue),
-        TagInfo(0x0001, "CameraSettingsStdOld", N_("Camera Settings (Std Old)"), 
-                N_("Standard Camera settings (Old Camera models like D5, D7, S304, and S404)"), 
+        TagInfo(0x0001, "CameraSettingsStdOld", N_("Camera Settings (Std Old)"),
+                N_("Standard Camera settings (Old Camera models like D5, D7, S304, and S404)"),
                 minoltaIfdId, makerTags, undefined, printValue),
-        TagInfo(0x0003, "CameraSettingsStdNew", N_("Camera Settings (Std New)"), 
-                N_("Standard Camera settings (New Camera Models like D7u, D7i, and D7hi)"), 
+        TagInfo(0x0003, "CameraSettingsStdNew", N_("Camera Settings (Std New)"),
+                N_("Standard Camera settings (New Camera Models like D7u, D7i, and D7hi)"),
                 minoltaIfdId, makerTags, undefined, printValue),
-        TagInfo(0x0004, "CameraSettings7D", N_("Camera Settings (7D)"), 
-                N_("Camera Settings (for Dynax 7D model)"), 
+        TagInfo(0x0004, "CameraSettings7D", N_("Camera Settings (7D)"),
+                N_("Camera Settings (for Dynax 7D model)"),
                 minoltaIfdId, makerTags, undefined, printValue),
-        TagInfo(0x0018, "ImageStabilizationData", N_("Image Stabilization Data"), 
-                N_("Image stabilization data"), 
+        TagInfo(0x0018, "ImageStabilizationData", N_("Image Stabilization Data"),
+                N_("Image stabilization data"),
                 minoltaIfdId, makerTags, undefined, printValue),
-        TagInfo(0x0040, "CompressedImageSize", N_("Compressed Image Size"), 
-                N_("Compressed image size"), 
+        TagInfo(0x0040, "CompressedImageSize", N_("Compressed Image Size"),
+                N_("Compressed image size"),
                 minoltaIfdId, makerTags, unsignedLong, printValue),
-        TagInfo(0x0081, "Thumbnail", N_("Thumbnail"), 
-                N_("Jpeg thumbnail 640x480 pixels"), 
+        TagInfo(0x0081, "Thumbnail", N_("Thumbnail"),
+                N_("Jpeg thumbnail 640x480 pixels"),
                 minoltaIfdId, makerTags, undefined, printValue),
-        TagInfo(0x0088, "ThumbnailOffset", N_("Thumbnail Offset"), 
-                N_("Offset of the thumbnail"), 
+        TagInfo(0x0088, "ThumbnailOffset", N_("Thumbnail Offset"),
+                N_("Offset of the thumbnail"),
                 minoltaIfdId, makerTags, unsignedLong, printValue),
-        TagInfo(0x0089, "ThumbnailLength", N_("Thumbnail Length"), 
-                N_("Size of the thumbnail"), 
+        TagInfo(0x0089, "ThumbnailLength", N_("Thumbnail Length"),
+                N_("Size of the thumbnail"),
                 minoltaIfdId, makerTags, unsignedLong, printValue),
-        TagInfo(0x0101, "ColorMode", N_("Color Mode"), 
-                N_("Color mode"), 
+        TagInfo(0x0101, "ColorMode", N_("Color Mode"),
+                N_("Color mode"),
                 minoltaIfdId, makerTags, unsignedLong, EXV_PRINT_TAG(minoltaColorMode)),
-        TagInfo(0x0102, "Quality", N_("Image Quality"), 
-                N_("Image quality"), 
+        TagInfo(0x0102, "Quality", N_("Image Quality"),
+                N_("Image quality"),
                 minoltaIfdId, makerTags, unsignedLong, EXV_PRINT_TAG(minoltaImageQuality)),
 
         // TODO: Tag 0x0103 : quality or image size (see ExifTool doc).
 
-        TagInfo(0x0107, "ImageStabilization", N_("Image Stabilization"), 
-                N_("Image stabilization"), 
+        TagInfo(0x0107, "ImageStabilization", N_("Image Stabilization"),
+                N_("Image stabilization"),
                 minoltaIfdId, makerTags, unsignedLong, EXV_PRINT_TAG(minoltaImageStabilization)),
-        TagInfo(0x010a, "ZoneMatching", N_("Zone Matching"), 
+        TagInfo(0x010a, "ZoneMatching", N_("Zone Matching"),
                 N_("Zone matching"),
                 minoltaIfdId, makerTags, unsignedLong, EXV_PRINT_TAG(minoltaZoneMatching)),
-        TagInfo(0x010b, "ColorTemperature", N_("Color Temperature"), 
-                N_("Color temperature"), 
+        TagInfo(0x010b, "ColorTemperature", N_("Color Temperature"),
+                N_("Color temperature"),
                 minoltaIfdId, makerTags, unsignedLong, printValue),
-        TagInfo(0x010c, "LensID", N_("Lens ID"), 
-                N_("Lens identifier"), 
+        TagInfo(0x010c, "LensID", N_("Lens ID"),
+                N_("Lens identifier"),
                 minoltaIfdId, makerTags, unsignedLong, EXV_PRINT_TAG(minoltaLensID)),
-        TagInfo(0x0114, "CameraSettings5D", N_("Camera Settings (5D)"), 
-                N_("Camera Settings (for Dynax 5D model)"), 
+        TagInfo(0x0114, "CameraSettings5D", N_("Camera Settings (5D)"),
+                N_("Camera Settings (for Dynax 5D model)"),
                 minoltaIfdId, makerTags, undefined, printValue),
-        TagInfo(0x0e00, "PrintIM", N_("Print IM"), 
-                N_("PrintIM information"), 
+        TagInfo(0x0e00, "PrintIM", N_("Print IM"),
+                N_("PrintIM information"),
                 minoltaIfdId, makerTags, undefined, printValue),
-        TagInfo(0x0f00, "CameraSettingsZ1", N_("Camera Settings (Z1)"), 
-                N_("Camera Settings (for Z1, DImage X, and F100 models)"), 
+        TagInfo(0x0f00, "CameraSettingsZ1", N_("Camera Settings (Z1)"),
+                N_("Camera Settings (for Z1, DImage X, and F100 models)"),
                 minoltaIfdId, makerTags, undefined, printValue),
         // End of list marker
 
-        TagInfo(0xffff, "(UnknownMinoltaMakerNoteTag)", "(UnknownMinoltaMakerNoteTag)", 
-                N_("Unknown Minolta MakerNote tag"), 
+        TagInfo(0xffff, "(UnknownMinoltaMakerNoteTag)", "(UnknownMinoltaMakerNoteTag)",
+                N_("Unknown Minolta MakerNote tag"),
                 minoltaIfdId, makerTags, invalidTypeId, printValue)
     };
 
@@ -595,160 +595,160 @@ namespace Exiv2 {
 
     // Minolta Standard Camera Settings Tag Info (Old and New)
     const TagInfo MinoltaMakerNote::tagInfoCsStd_[] = {
-        TagInfo(0x0001, "ExposureMode", N_("Exposure Mode"), 
-                N_("Exposure mode"), 
+        TagInfo(0x0001, "ExposureMode", N_("Exposure Mode"),
+                N_("Exposure mode"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, EXV_PRINT_TAG(minoltaExposureModeStd)),
-        TagInfo(0x0002, "FlashMode", N_("Flash Mode"), 
+        TagInfo(0x0002, "FlashMode", N_("Flash Mode"),
                 N_("Flash mode"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, EXV_PRINT_TAG(minoltaFlashModeStd)),
-        TagInfo(0x0003, "WhiteBalance", N_("White Balance"), 
-                N_("White balance"), 
+        TagInfo(0x0003, "WhiteBalance", N_("White Balance"),
+                N_("White balance"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, EXV_PRINT_TAG(minoltaWhiteBalanceStd)),
-        TagInfo(0x0004, "ImageSize", N_("Image Size"), 
-                N_("Image size"), 
+        TagInfo(0x0004, "ImageSize", N_("Image Size"),
+                N_("Image size"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, EXV_PRINT_TAG(minoltaImageSizeStd)),
-        TagInfo(0x0005, "Quality", N_("Image Quality"), 
-                N_("Image quality"), 
+        TagInfo(0x0005, "Quality", N_("Image Quality"),
+                N_("Image quality"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, EXV_PRINT_TAG(minoltaImageQualityStd)),
-        TagInfo(0x0006, "DriveMode", N_("Drive Mode"), 
-                N_("Drive mode"), 
+        TagInfo(0x0006, "DriveMode", N_("Drive Mode"),
+                N_("Drive mode"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, EXV_PRINT_TAG(minoltaDriveModeStd)),
-        TagInfo(0x0007, "MeteringMode", N_("Metering Mode"), 
-                N_("Metering mode"), 
+        TagInfo(0x0007, "MeteringMode", N_("Metering Mode"),
+                N_("Metering mode"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, EXV_PRINT_TAG(minoltaMeteringModeStd)),
-        TagInfo(0x0008, "ExposureSpeed", N_("Exposure Speed"), 
-                N_("Exposure speed"), 
+        TagInfo(0x0008, "ExposureSpeed", N_("Exposure Speed"),
+                N_("Exposure speed"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, printMinoltaExposureSpeedStd),
-        TagInfo(0x0009, "ExposureTime", N_("Exposure Time"), 
-                N_("Exposure time"), 
+        TagInfo(0x0009, "ExposureTime", N_("Exposure Time"),
+                N_("Exposure time"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, printMinoltaExposureTimeStd),
-        TagInfo(0x000A, "FNumber", N_("FNumber"), 
-                N_("The F-Number"), 
+        TagInfo(0x000A, "FNumber", N_("FNumber"),
+                N_("The F-Number"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, printMinoltaFNumberStd),
-        TagInfo(0x000B, "MacroMode", N_("Macro Mode"), 
-                N_("Macro mode"), 
+        TagInfo(0x000B, "MacroMode", N_("Macro Mode"),
+                N_("Macro mode"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, EXV_PRINT_TAG(minoltaMacroModeStd)),
-        TagInfo(0x000C, "DigitalZoom", N_("Digital Zoom"), 
-                N_("Digital zoom"), 
+        TagInfo(0x000C, "DigitalZoom", N_("Digital Zoom"),
+                N_("Digital zoom"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, EXV_PRINT_TAG(minoltaDigitalZoomStd)),
-        TagInfo(0x000D, "ExposureCompensation", N_("Exposure Compensation"), 
-                N_("Exposure compensation"), 
+        TagInfo(0x000D, "ExposureCompensation", N_("Exposure Compensation"),
+                N_("Exposure compensation"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, printMinoltaExposureCompensationStd),
-        TagInfo(0x000E, "BracketStep", N_("Bracket Step"), 
-                N_("Bracket step"), 
+        TagInfo(0x000E, "BracketStep", N_("Bracket Step"),
+                N_("Bracket step"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, EXV_PRINT_TAG(minoltaBracketStepStd)),
-        TagInfo(0x0010, "IntervalLength", N_("Interval Length"), 
-                N_("Interval length"), 
+        TagInfo(0x0010, "IntervalLength", N_("Interval Length"),
+                N_("Interval length"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, printValue),
-        TagInfo(0x0011, "IntervalNumber", N_("Interval Number"), 
-                N_("Interval number"), 
+        TagInfo(0x0011, "IntervalNumber", N_("Interval Number"),
+                N_("Interval number"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, printValue),
-        TagInfo(0x0012, "FocalLength", N_("Focal Length"), 
-                N_("Focal length"), 
+        TagInfo(0x0012, "FocalLength", N_("Focal Length"),
+                N_("Focal length"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, printMinoltaFocalLengthStd),
-        TagInfo(0x0013, "FocusDistance", N_("Focus Distance"), 
+        TagInfo(0x0013, "FocusDistance", N_("Focus Distance"),
                 N_("Focus distance"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, printValue),
-        TagInfo(0x0014, "Flash", N_("Flash"), 
-                N_("Flash mode"), 
+        TagInfo(0x0014, "Flash", N_("Flash"),
+                N_("Flash mode"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, EXV_PRINT_TAG(minoltaFlashStd)),
-        TagInfo(0x0015, "MinoltaDate", N_("Minolta Date"), 
-                N_("Minolta date"), 
+        TagInfo(0x0015, "MinoltaDate", N_("Minolta Date"),
+                N_("Minolta date"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, printMinoltaDateStd),
-        TagInfo(0x0016, "MinoltaTime", N_("Minolta Time"), 
-                N_("Minolta time"), 
+        TagInfo(0x0016, "MinoltaTime", N_("Minolta Time"),
+                N_("Minolta time"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, printMinoltaTimeStd),
-        TagInfo(0x0017, "MaxAperture", N_("Max Aperture"), 
-                N_("Max aperture"), 
+        TagInfo(0x0017, "MaxAperture", N_("Max Aperture"),
+                N_("Max aperture"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, printValue),
-        TagInfo(0x001A, "FileNumberMemory", N_("File Number Memory"), 
-                N_("File number memory"), 
+        TagInfo(0x001A, "FileNumberMemory", N_("File Number Memory"),
+                N_("File number memory"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, EXV_PRINT_TAG(minoltaFileNumberMemoryStd)),
-        TagInfo(0x001B, "ImageNumber", N_("Image Number"), 
-                N_("Image number"), 
+        TagInfo(0x001B, "ImageNumber", N_("Image Number"),
+                N_("Image number"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, printValue),
-        TagInfo(0x001C, "ColorBalanceRed", N_("Color Balance Red"), 
-                N_("Color balance red"), 
+        TagInfo(0x001C, "ColorBalanceRed", N_("Color Balance Red"),
+                N_("Color balance red"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, printMinoltaWhiteBalanceStd),
-        TagInfo(0x001D, "ColorBalanceGreen", N_("Color Balance Green"), 
-                N_("Color balance green"), 
+        TagInfo(0x001D, "ColorBalanceGreen", N_("Color Balance Green"),
+                N_("Color balance green"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, printMinoltaWhiteBalanceStd),
-        TagInfo(0x001E, "ColorBalanceBlue", N_("Color Balance Blue"), 
-                N_("Color balance blue"), 
+        TagInfo(0x001E, "ColorBalanceBlue", N_("Color Balance Blue"),
+                N_("Color balance blue"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, printMinoltaWhiteBalanceStd),
-        TagInfo(0x001F, "Saturation", N_("Saturation"), 
-                N_("Saturation"), 
+        TagInfo(0x001F, "Saturation", N_("Saturation"),
+                N_("Saturation"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, printValue),
-        TagInfo(0x0020, "Contrast", N_("Contrast"), 
-                N_("Contrast"), 
+        TagInfo(0x0020, "Contrast", N_("Contrast"),
+                N_("Contrast"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, printValue),
-        TagInfo(0x0021, "Sharpness", N_("Sharpness"), 
-                N_("Sharpness"), 
+        TagInfo(0x0021, "Sharpness", N_("Sharpness"),
+                N_("Sharpness"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, EXV_PRINT_TAG(minoltaSharpnessStd)),
-        TagInfo(0x0022, "SubjectProgram", N_("Subject Program"), 
-                N_("Subject program"), 
+        TagInfo(0x0022, "SubjectProgram", N_("Subject Program"),
+                N_("Subject program"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, EXV_PRINT_TAG(minoltaSubjectProgramStd)),
-        TagInfo(0x0023, "FlashExposureComp", N_("Flash Exposure Compensation"), 
-                N_("Flash exposure compensation in EV"), 
+        TagInfo(0x0023, "FlashExposureComp", N_("Flash Exposure Compensation"),
+                N_("Flash exposure compensation in EV"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, printMinoltaFlashExposureCompStd),
-        TagInfo(0x0024, "ISOSpeed", N_("ISO Speed Mode"), 
-                N_("ISO speed setting"), 
+        TagInfo(0x0024, "ISOSpeed", N_("ISO Speed Mode"),
+                N_("ISO speed setting"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, EXV_PRINT_TAG(minoltaISOSettingStd)),
-        TagInfo(0x0025, "MinoltaModel", N_("Minolta Model"), 
-                N_("Minolta model"), 
+        TagInfo(0x0025, "MinoltaModel", N_("Minolta Model"),
+                N_("Minolta model"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, EXV_PRINT_TAG(minoltaModelStd)),
-        TagInfo(0x0026, "IntervalMode", N_("Interval Mode"), 
-                N_("Interval mode"), 
+        TagInfo(0x0026, "IntervalMode", N_("Interval Mode"),
+                N_("Interval mode"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, EXV_PRINT_TAG(minoltaIntervalModeStd)),
-        TagInfo(0x0027, "FolderName", N_("Folder Name"), 
-                N_("Folder name"), 
+        TagInfo(0x0027, "FolderName", N_("Folder Name"),
+                N_("Folder name"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, EXV_PRINT_TAG(minoltaFolderNameStd)),
-        TagInfo(0x0028, "ColorMode", N_("ColorMode"), 
-                N_("ColorMode"), 
+        TagInfo(0x0028, "ColorMode", N_("ColorMode"),
+                N_("ColorMode"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, EXV_PRINT_TAG(minoltaColorModeStd)),
-        TagInfo(0x0029, "ColorFilter", N_("Color Filter"), 
-                N_("Color filter"), 
+        TagInfo(0x0029, "ColorFilter", N_("Color Filter"),
+                N_("Color filter"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, printValue),
-        TagInfo(0x002A, "BWFilter", N_("Black and White Filter"), 
-                N_("Black and white filter"), 
+        TagInfo(0x002A, "BWFilter", N_("Black and White Filter"),
+                N_("Black and white filter"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, printValue),
-        TagInfo(0x002B, "InternalFlash", N_("Internal Flash"), 
-                N_("Internal flash"), 
+        TagInfo(0x002B, "InternalFlash", N_("Internal Flash"),
+                N_("Internal flash"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, EXV_PRINT_TAG(minoltaInternalFlashStd)),
-        TagInfo(0x002C, "Brightness", N_("Brightness"), 
-                N_("Brightness"), 
+        TagInfo(0x002C, "Brightness", N_("Brightness"),
+                N_("Brightness"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, printMinoltaBrightnessStd),
-        TagInfo(0x002D, "SpotFocusPointX", N_("Spot Focus Point X"), 
-                N_("Spot focus point X"), 
+        TagInfo(0x002D, "SpotFocusPointX", N_("Spot Focus Point X"),
+                N_("Spot focus point X"),
         minoltaCsNewIfdId, makerTags, unsignedLong, printValue),
-        TagInfo(0x002E, "SpotFocusPointY", N_("Spot Focus Point Y"), 
-                N_("Spot focus point Y"), 
+        TagInfo(0x002E, "SpotFocusPointY", N_("Spot Focus Point Y"),
+                N_("Spot focus point Y"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, printValue),
-        TagInfo(0x002F, "WideFocusZone", N_("Wide Focus Zone"), 
-                N_("Wide focus zone"), 
+        TagInfo(0x002F, "WideFocusZone", N_("Wide Focus Zone"),
+                N_("Wide focus zone"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, EXV_PRINT_TAG(minoltaWideFocusZoneStd)),
-        TagInfo(0x0030, "FocusMode", N_("Focus Mode"), 
-                N_("Focus mode"), 
+        TagInfo(0x0030, "FocusMode", N_("Focus Mode"),
+                N_("Focus mode"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, EXV_PRINT_TAG(minoltaFocusModeStd)),
-        TagInfo(0x0031, "FocusArea", N_("Focus area"), 
-                N_("Focus area"), 
+        TagInfo(0x0031, "FocusArea", N_("Focus area"),
+                N_("Focus area"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, EXV_PRINT_TAG(minoltaFocusAreaStd)),
-        TagInfo(0x0032, "DECPosition", N_("DEC Switch Position"), 
-                N_("DEC switch position"), 
+        TagInfo(0x0032, "DECPosition", N_("DEC Switch Position"),
+                N_("DEC switch position"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, EXV_PRINT_TAG(minoltaDECPositionStd)),
-        TagInfo(0x0033, "ColorProfile", N_("Color Profile"), 
-                N_("Color profile"), 
+        TagInfo(0x0033, "ColorProfile", N_("Color Profile"),
+                N_("Color profile"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, EXV_PRINT_TAG(minoltaColorProfileStd)),
-        TagInfo(0x0034, "DataImprint", N_("Data Imprint"), 
-                N_("Data Imprint"), 
+        TagInfo(0x0034, "DataImprint", N_("Data Imprint"),
+                N_("Data Imprint"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, EXV_PRINT_TAG(minoltaDataImprintStd)),
-        TagInfo(0x003F, "FlashMetering", N_("Flash Metering"), 
-                N_("Flash metering"), 
+        TagInfo(0x003F, "FlashMetering", N_("Flash Metering"),
+                N_("Flash metering"),
                 minoltaCsNewIfdId, makerTags, unsignedLong, EXV_PRINT_TAG(minoltaFlashMeteringStd)),
 
         // End of list marker
-        TagInfo(0xffff, "(UnknownMinoltaCsStdTag)", "(UnknownMinoltaCsStdTag)", 
-                N_("Unknown Minolta Camera Settings tag"), 
+        TagInfo(0xffff, "(UnknownMinoltaCsStdTag)", "(UnknownMinoltaCsStdTag)",
+                N_("Unknown Minolta Camera Settings tag"),
                 minoltaCsNewIfdId, makerTags, invalidTypeId, printValue)
     };
 
@@ -870,89 +870,89 @@ namespace Exiv2 {
 
     // Minolta Dynax 7D Camera Settings Tag Info
     const TagInfo MinoltaMakerNote::tagInfoCs7D_[] = {
-        TagInfo(0x0000, "ExposureMode", N_("Exposure Mode"), 
-                N_("Exposure mode"), 
+        TagInfo(0x0000, "ExposureMode", N_("Exposure Mode"),
+                N_("Exposure mode"),
                 minoltaCs7DIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(minoltaExposureMode7D)),
-        TagInfo(0x0002, "ImageSize", N_("Image Size"), 
-                N_("Image size"), 
+        TagInfo(0x0002, "ImageSize", N_("Image Size"),
+                N_("Image size"),
                 minoltaCs7DIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(minoltaImageSize7D)),
-        TagInfo(0x0003, "Quality", N_("Image Quality"), 
-                N_("Image quality"), 
+        TagInfo(0x0003, "Quality", N_("Image Quality"),
+                N_("Image quality"),
                 minoltaCs7DIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(minoltaImageQuality7D)),
-        TagInfo(0x0004, "WhiteBalance", N_("White Balance"), 
-                N_("White balance"), 
+        TagInfo(0x0004, "WhiteBalance", N_("White Balance"),
+                N_("White balance"),
                 minoltaCs7DIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(minoltaWhiteBalance7D)),
-        TagInfo(0x000E, "FocusMode", N_("Focus Mode"), 
-                N_("Focus mode"), 
+        TagInfo(0x000E, "FocusMode", N_("Focus Mode"),
+                N_("Focus mode"),
                 minoltaCs7DIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(minoltaFocusMode7D)),
-        TagInfo(0x0010, "AFPoints", N_("AF Points"), 
-                N_("AF points"), 
+        TagInfo(0x0010, "AFPoints", N_("AF Points"),
+                N_("AF points"),
                 minoltaCs7DIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(minoltaAFPoints7D)),
-        TagInfo(0x0015, "Flash", N_("Flash"), 
-                N_("Flash"), 
+        TagInfo(0x0015, "Flash", N_("Flash"),
+                N_("Flash"),
                 minoltaCs7DIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(minoltaFlash7D)),
-        TagInfo(0x0016, "FlashMode", N_("Flash Mode"), 
-                N_("Flash mode"), 
+        TagInfo(0x0016, "FlashMode", N_("Flash Mode"),
+                N_("Flash mode"),
                 minoltaCs7DIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x001C, "ISOSpeed", N_("ISO Speed Mode"), 
-                N_("ISO speed setting"), 
+        TagInfo(0x001C, "ISOSpeed", N_("ISO Speed Mode"),
+                N_("ISO speed setting"),
                 minoltaCs7DIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(minoltaISOSetting7D)),
-        TagInfo(0x001E, "ExposureCompensation", N_("Exposure Compensation"), 
-                N_("Exposure compensation"), 
+        TagInfo(0x001E, "ExposureCompensation", N_("Exposure Compensation"),
+                N_("Exposure compensation"),
                 minoltaCs7DIfdId, makerTags, signedShort, printValue),
-        TagInfo(0x0025, "ColorSpace", N_("Color Space"), 
-                N_("Color space"), 
+        TagInfo(0x0025, "ColorSpace", N_("Color Space"),
+                N_("Color space"),
                 minoltaCs7DIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(minoltaColorSpace7D)),
-        TagInfo(0x0026, "Sharpness", N_("Sharpness"), 
-                N_("Sharpness"), 
+        TagInfo(0x0026, "Sharpness", N_("Sharpness"),
+                N_("Sharpness"),
                 minoltaCs7DIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x0027, "Contrast", N_("Contrast"), 
-                N_("Contrast"), 
+        TagInfo(0x0027, "Contrast", N_("Contrast"),
+                N_("Contrast"),
                 minoltaCs7DIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x0028, "Saturation", N_("Saturation"), 
-                N_("Saturation"), 
+        TagInfo(0x0028, "Saturation", N_("Saturation"),
+                N_("Saturation"),
                 minoltaCs7DIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x002D, "FreeMemoryCardImages", N_("Free Memory Card Images"), 
-                N_("Free memory card images"), 
+        TagInfo(0x002D, "FreeMemoryCardImages", N_("Free Memory Card Images"),
+                N_("Free memory card images"),
                 minoltaCs7DIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x003F, "ColorTemperature", N_("Color Temperature"), 
-                N_("Color temperature"), 
+        TagInfo(0x003F, "ColorTemperature", N_("Color Temperature"),
+                N_("Color temperature"),
                 minoltaCs7DIfdId, makerTags, signedShort, printValue),
-        TagInfo(0x0040, "Hue", N_("Hue"), N_("Hue"), 
+        TagInfo(0x0040, "Hue", N_("Hue"), N_("Hue"),
                 minoltaCs7DIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x0046, "Rotation", N_("Rotation"), 
-                N_("Rotation"), 
+        TagInfo(0x0046, "Rotation", N_("Rotation"),
+                N_("Rotation"),
                 minoltaCs7DIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(minoltaRotation7D)),
-        TagInfo(0x0047, "FNumber", N_("FNumber"), 
-                N_("The F-Number"), 
+        TagInfo(0x0047, "FNumber", N_("FNumber"),
+                N_("The F-Number"),
                 minoltaCs7DIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x0048, "ExposureTime", N_("Exposure Time"), 
-                N_("Exposure time"), 
+        TagInfo(0x0048, "ExposureTime", N_("Exposure Time"),
+                N_("Exposure time"),
                 minoltaCs7DIfdId, makerTags, unsignedShort, printValue),
         // 0x004A is a dupplicate than 0x002D.
-        TagInfo(0x004A, "FreeMemoryCardImages", N_("Free Memory Card Images"), 
-                N_("Free memory card images"), 
+        TagInfo(0x004A, "FreeMemoryCardImages", N_("Free Memory Card Images"),
+                N_("Free memory card images"),
                 minoltaCs7DIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x005E, "ImageNumber", N_("Image Number"), 
-                N_("Image number"), 
+        TagInfo(0x005E, "ImageNumber", N_("Image Number"),
+                N_("Image number"),
                 minoltaCs7DIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x0060, "NoiseReduction", N_("Noise Reduction"), 
-                N_("Noise reduction"), 
+        TagInfo(0x0060, "NoiseReduction", N_("Noise Reduction"),
+                N_("Noise reduction"),
                 minoltaCs7DIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(minoltaNoiseReduction7D)),
         // 0x0062 is a dupplicate than 0x005E.
-        TagInfo(0x0062, "ImageNumber", N_("Image Number"), 
-                N_("Image number"), 
+        TagInfo(0x0062, "ImageNumber", N_("Image Number"),
+                N_("Image number"),
                 minoltaCs7DIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x0071, "ImageStabilization", N_("Image Stabilization"), 
-                N_("Image stabilization"), 
+        TagInfo(0x0071, "ImageStabilization", N_("Image Stabilization"),
+                N_("Image stabilization"),
                 minoltaCs7DIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(minoltaImageStabilization7D)),
-        TagInfo(0x0075, "ZoneMatchingOn", N_("Zone Matching On"), 
-                N_("Zone matching on"), 
+        TagInfo(0x0075, "ZoneMatchingOn", N_("Zone Matching On"),
+                N_("Zone matching on"),
                 minoltaCs7DIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(minoltaZoneMatchingOn7D)),
 
         // End of list marker
-        TagInfo(0xffff, "(UnknownMinoltaCs7DTag)", "(UnknownMinoltaCs7DTag)", 
-                N_("Unknown Minolta Camera Settings 7D tag"), 
+        TagInfo(0xffff, "(UnknownMinoltaCs7DTag)", "(UnknownMinoltaCs7DTag)",
+                N_("Unknown Minolta Camera Settings 7D tag"),
                 minoltaCs7DIfdId, makerTags, invalidTypeId, printValue)
     };
 
@@ -1108,83 +1108,83 @@ namespace Exiv2 {
 
     // Minolta Dynax 5D Camera Settings Tag Info
     const TagInfo MinoltaMakerNote::tagInfoCs5D_[] = {
-        TagInfo(0x000A, "ExposureMode", N_("Exposure Mode"), 
-                N_("Exposure mode"), 
+        TagInfo(0x000A, "ExposureMode", N_("Exposure Mode"),
+                N_("Exposure mode"),
                 minoltaCs5DIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(minoltaExposureMode5D)),
-        TagInfo(0x000C, "ImageSize", N_("Image Size"), 
-                N_("Image size"), 
+        TagInfo(0x000C, "ImageSize", N_("Image Size"),
+                N_("Image size"),
                 minoltaCs5DIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(minoltaImageSize5D)),
-        TagInfo(0x000D, "Quality", N_("Image Quality"), 
-                N_("Image quality"), 
+        TagInfo(0x000D, "Quality", N_("Image Quality"),
+                N_("Image quality"),
                 minoltaCs5DIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(minoltaImageQuality5D)),
-        TagInfo(0x000E, "WhiteBalance", N_("White Balance"), 
-                N_("White balance"), 
+        TagInfo(0x000E, "WhiteBalance", N_("White Balance"),
+                N_("White balance"),
                 minoltaCs5DIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(minoltaWhiteBalance5D)),
-        TagInfo(0x001a, "FocusPosition", N_("Focus Position"), 
-                N_("Focus position"), 
+        TagInfo(0x001a, "FocusPosition", N_("Focus Position"),
+                N_("Focus position"),
                 minoltaCs5DIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(minoltaFocusPosition5D)),
-        TagInfo(0x001b, "FocusArea", N_("Focus Area"), 
-                N_("Focus area"), 
+        TagInfo(0x001b, "FocusArea", N_("Focus Area"),
+                N_("Focus area"),
                 minoltaCs5DIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(minoltaFocusArea5D)),
-        TagInfo(0x001F, "Flash", N_("Flash"), 
-                N_("Flash"), 
+        TagInfo(0x001F, "Flash", N_("Flash"),
+                N_("Flash"),
                 minoltaCs5DIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(minoltaFlash5D)),
-        TagInfo(0x0025, "MeteringMode", N_("Metering Mode"), 
-                N_("Metering mode"), 
+        TagInfo(0x0025, "MeteringMode", N_("Metering Mode"),
+                N_("Metering mode"),
                 minoltaCs5DIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(minoltaMeteringMode5D)),
-        TagInfo(0x0026, "ISOSpeed", N_("ISO Speed Mode"), 
-                N_("ISO speed setting"), 
+        TagInfo(0x0026, "ISOSpeed", N_("ISO Speed Mode"),
+                N_("ISO speed setting"),
                 minoltaCs5DIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(minoltaISOSetting5D)),
-        TagInfo(0x0030, "Sharpness", N_("Sharpness"), 
-                N_("Sharpness"), 
+        TagInfo(0x0030, "Sharpness", N_("Sharpness"),
+                N_("Sharpness"),
                 minoltaCs5DIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x0031, "Contrast", N_("Contrast"), 
-                N_("Contrast"), 
+        TagInfo(0x0031, "Contrast", N_("Contrast"),
+                N_("Contrast"),
                 minoltaCs5DIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x0032, "Saturation", N_("Saturation"), 
-                N_("Saturation"), 
+        TagInfo(0x0032, "Saturation", N_("Saturation"),
+                N_("Saturation"),
                 minoltaCs5DIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x0035, "ExposureTime", N_("Exposure Time"), 
-                N_("Exposure time"), 
+        TagInfo(0x0035, "ExposureTime", N_("Exposure Time"),
+                N_("Exposure time"),
                 minoltaCs5DIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x0036, "FNumber", N_("FNumber"), 
-                N_("The F-Number"), 
+        TagInfo(0x0036, "FNumber", N_("FNumber"),
+                N_("The F-Number"),
                 minoltaCs5DIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x0037, "FreeMemoryCardImages", N_("Free Memory Card Images"), 
-                N_("Free memory card images"), 
+        TagInfo(0x0037, "FreeMemoryCardImages", N_("Free Memory Card Images"),
+                N_("Free memory card images"),
                 minoltaCs5DIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x0038, "ExposureRevision", N_("Exposure Revision"), 
-                N_("Exposure revision"), 
+        TagInfo(0x0038, "ExposureRevision", N_("Exposure Revision"),
+                N_("Exposure revision"),
                 minoltaCs5DIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x0048, "FocusMode", N_("Focus Mode"), 
-                N_("Focus mode"), 
+        TagInfo(0x0048, "FocusMode", N_("Focus Mode"),
+                N_("Focus mode"),
                 minoltaCs5DIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(minoltaFocusMode5D)),
-        TagInfo(0x0049, "ColorTemperature", N_("Color Temperature"), 
-                N_("Color temperature"), 
+        TagInfo(0x0049, "ColorTemperature", N_("Color Temperature"),
+                N_("Color temperature"),
                 minoltaCs5DIfdId, makerTags, signedShort, printValue),
-        TagInfo(0x0050, "Rotation", N_("Rotation"), 
-                N_("Rotation"), 
+        TagInfo(0x0050, "Rotation", N_("Rotation"),
+                N_("Rotation"),
                 minoltaCs5DIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(minoltaRotation5D)),
-        TagInfo(0x0053, "ExposureCompensation", N_("Exposure Compensation"), 
-                N_("Exposure compensation"), 
+        TagInfo(0x0053, "ExposureCompensation", N_("Exposure Compensation"),
+                N_("Exposure compensation"),
                 minoltaCs5DIfdId, makerTags, unsignedShort, printMinoltaExposureCompensation5D),
-        TagInfo(0x0054, "FreeMemoryCardImages", N_("Free Memory Card Images"), 
+        TagInfo(0x0054, "FreeMemoryCardImages", N_("Free Memory Card Images"),
                 N_("Free memory card images"),
                 minoltaCs5DIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x0091, "ExposureManualBias", N_("Exposure Manual Bias"), 
+        TagInfo(0x0091, "ExposureManualBias", N_("Exposure Manual Bias"),
                 N_("Exposure manual bias"),
                 minoltaCs5DIfdId, makerTags, unsignedShort, printMinoltaExposureManualBias5D),
-        TagInfo(0x009e, "AFMode", N_("AF Mode"), 
+        TagInfo(0x009e, "AFMode", N_("AF Mode"),
                 N_("AF mode"),
                 minoltaCs5DIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(minoltaAFMode5D)),
-        TagInfo(0x00AE, "ImageNumber", N_("Image Number"), 
-                N_("Image number"), 
+        TagInfo(0x00AE, "ImageNumber", N_("Image Number"),
+                N_("Image number"),
                 minoltaCs5DIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x00B0, "NoiseReduction", N_("Noise Reduction"), 
-                N_("Noise reduction"), 
+        TagInfo(0x00B0, "NoiseReduction", N_("Noise Reduction"),
+                N_("Noise reduction"),
                 minoltaCs5DIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(minoltaNoiseReduction5D)),
-        TagInfo(0x00BD, "ImageStabilization", N_("Image Stabilization"), 
-                N_("Image stabilization"), 
+        TagInfo(0x00BD, "ImageStabilization", N_("Image Stabilization"),
+                N_("Image stabilization"),
                 minoltaCs5DIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(minoltaImageStabilization5D)),
 
         // From Xavier Raynaud: some notes on missing tags.
@@ -1194,8 +1194,8 @@ namespace Exiv2 {
         // value and Exposure time is exp(-4+value*0.085)
 
         // End of list marker
-        TagInfo(0xffff, "(UnknownMinoltaCs5DTag)", "(UnknownMinoltaCs5DTag)", 
-                N_("Unknown Minolta Camera Settings 5D tag"), 
+        TagInfo(0xffff, "(UnknownMinoltaCs5DTag)", "(UnknownMinoltaCs5DTag)",
+                N_("Unknown Minolta Camera Settings 5D tag"),
                 minoltaCs5DIfdId, makerTags, invalidTypeId, printValue)
     };
 
diff --git a/src/mrwimage.cpp b/src/mrwimage.cpp
index c50ddab9..92e80980 100644
--- a/src/mrwimage.cpp
+++ b/src/mrwimage.cpp
@@ -155,7 +155,7 @@ namespace Exiv2 {
         io_->read(buf.pData_, buf.size_);
         if (io_->error() || io_->eof()) throw Error(14);
 
-        TiffParser::decode(this, buf.pData_, buf.size_, 
+        TiffParser::decode(this, buf.pData_, buf.size_,
                            TiffCreator::create, TiffDecoder::findDecoder);
     } // MrwImage::readMetadata
 
diff --git a/src/nikonmn.cpp b/src/nikonmn.cpp
index 1478066f..a812a4e9 100644
--- a/src/nikonmn.cpp
+++ b/src/nikonmn.cpp
@@ -162,58 +162,58 @@ namespace Exiv2 {
 
     // Nikon1 MakerNote Tag Info
     const TagInfo Nikon1MakerNote::tagInfo_[] = {
-        TagInfo(0x0001, "Version", N_("Version"), 
-                N_("Nikon Makernote version"), 
+        TagInfo(0x0001, "Version", N_("Version"),
+                N_("Nikon Makernote version"),
                 nikon1IfdId, makerTags, undefined, printValue),
         TagInfo(0x0002, "ISOSpeed", N_("ISO Speed"),
-                N_("ISO speed setting"), 
+                N_("ISO speed setting"),
                 nikon1IfdId, makerTags, unsignedShort, print0x0002),
-        TagInfo(0x0003, "ColorMode", N_("Color Mode"), 
-                N_("Color mode"), 
+        TagInfo(0x0003, "ColorMode", N_("Color Mode"),
+                N_("Color mode"),
                 nikon1IfdId, makerTags, asciiString, printValue),
-        TagInfo(0x0004, "Quality", N_("Quality"), 
-                N_("Image quality setting"), 
+        TagInfo(0x0004, "Quality", N_("Quality"),
+                N_("Image quality setting"),
                 nikon1IfdId, makerTags, asciiString, printValue),
-        TagInfo(0x0005, "WhiteBalance", N_("White Balance"), 
-                N_("White balance"), 
+        TagInfo(0x0005, "WhiteBalance", N_("White Balance"),
+                N_("White balance"),
                 nikon1IfdId, makerTags, asciiString, printValue),
-        TagInfo(0x0006, "Sharpening", N_("Sharpening"), 
-                N_("Image sharpening setting"), 
+        TagInfo(0x0006, "Sharpening", N_("Sharpening"),
+                N_("Image sharpening setting"),
                 nikon1IfdId, makerTags, asciiString, printValue),
-        TagInfo(0x0007, "Focus", N_("Focus"), 
-                N_("Focus mode"), 
+        TagInfo(0x0007, "Focus", N_("Focus"),
+                N_("Focus mode"),
                 nikon1IfdId, makerTags, asciiString, print0x0007),
-        TagInfo(0x0008, "FlashSetting", N_("Flash Setting"), 
-                N_("Flash setting"), 
+        TagInfo(0x0008, "FlashSetting", N_("Flash Setting"),
+                N_("Flash setting"),
                 nikon1IfdId, makerTags, asciiString, printValue),
-        TagInfo(0x000a, "0x000a", "0x000a", 
-                N_("Unknown"), 
+        TagInfo(0x000a, "0x000a", "0x000a",
+                N_("Unknown"),
                 nikon1IfdId, makerTags, unsignedRational, printValue),
-        TagInfo(0x000f, "ISOSelection", N_("ISO Selection"), 
-                N_("ISO selection"), 
+        TagInfo(0x000f, "ISOSelection", N_("ISO Selection"),
+                N_("ISO selection"),
                 nikon1IfdId, makerTags, asciiString, printValue),
-        TagInfo(0x0010, "DataDump", N_("Data Dump"), 
-                N_("Data dump"), 
+        TagInfo(0x0010, "DataDump", N_("Data Dump"),
+                N_("Data dump"),
                 nikon1IfdId, makerTags, undefined, printValue),
-        TagInfo(0x0080, "ImageAdjustment", N_("Image Adjustment"), 
-                N_("Image adjustment setting"), 
+        TagInfo(0x0080, "ImageAdjustment", N_("Image Adjustment"),
+                N_("Image adjustment setting"),
                 nikon1IfdId, makerTags, asciiString, printValue),
-        TagInfo(0x0082, "AuxiliaryLens", N_("Auxiliary Lens"), 
-                N_("Auxiliary lens (adapter)"), 
+        TagInfo(0x0082, "AuxiliaryLens", N_("Auxiliary Lens"),
+                N_("Auxiliary lens (adapter)"),
                 nikon1IfdId, makerTags, asciiString, printValue),
-        TagInfo(0x0085, "FocusDistance", N_("Focus Distance"), 
-                N_("Manual focus distance"), 
+        TagInfo(0x0085, "FocusDistance", N_("Focus Distance"),
+                N_("Manual focus distance"),
                 nikon1IfdId, makerTags, unsignedRational, print0x0085),
-        TagInfo(0x0086, "DigitalZoom", N_("Digital Zoom"), 
-                N_("Digital zoom setting"), 
+        TagInfo(0x0086, "DigitalZoom", N_("Digital Zoom"),
+                N_("Digital zoom setting"),
                 nikon1IfdId, makerTags, unsignedRational, print0x0086),
-        TagInfo(0x0088, "AFFocusPos", N_("AF Focus Position"), 
-                N_("AF focus position information"), 
+        TagInfo(0x0088, "AFFocusPos", N_("AF Focus Position"),
+                N_("AF focus position information"),
                 nikon1IfdId, makerTags, undefined, print0x0088),
 
         // End of list marker
-        TagInfo(0xffff, "(UnknownNikon1MnTag)", "(UnknownNikon1MnTag)", 
-                N_("Unknown Nikon1MakerNote tag"), 
+        TagInfo(0xffff, "(UnknownNikon1MnTag)", "(UnknownNikon1MnTag)",
+                N_("Unknown Nikon1MakerNote tag"),
                 nikon1IfdId, makerTags, invalidTypeId, printValue)
     };
 
@@ -350,7 +350,7 @@ namespace Exiv2 {
             if (focusPointsUsed1 != 0 && focusPointsUsed2 != 0)
             {
                 os << "; [";
-    
+
                 if (focusPointsUsed1 & 1)
                     os << nikonFocuspoints[0] << " ";
                 if (focusPointsUsed1 & 2)
@@ -367,7 +367,7 @@ namespace Exiv2 {
                     os << nikonFocuspoints[6] << " ";
                 if (focusPointsUsed1 & 128)
                     os << nikonFocuspoints[7] << " ";
-    
+
                 if (focusPointsUsed2 & 1)
                     os << nikonFocuspoints[8] << " ";
                 if (focusPointsUsed2 & 2)
@@ -440,42 +440,42 @@ namespace Exiv2 {
 
     // Nikon2 MakerNote Tag Info
     const TagInfo Nikon2MakerNote::tagInfo_[] = {
-        TagInfo(0x0002, "0x0002", "0x0002", 
-                N_("Unknown"), 
+        TagInfo(0x0002, "0x0002", "0x0002",
+                N_("Unknown"),
                 nikon2IfdId, makerTags, asciiString, printValue),
-        TagInfo(0x0003, "Quality", N_("Quality"), 
-                N_("Image quality setting"), 
+        TagInfo(0x0003, "Quality", N_("Quality"),
+                N_("Image quality setting"),
                 nikon2IfdId, makerTags, unsignedShort, EXV_PRINT_TAG(nikon2Quality)),
-        TagInfo(0x0004, "ColorMode", N_("Color Mode"), 
-                N_("Color mode"), 
+        TagInfo(0x0004, "ColorMode", N_("Color Mode"),
+                N_("Color mode"),
                 nikon2IfdId, makerTags, unsignedShort, EXV_PRINT_TAG(nikon2ColorMode)),
-        TagInfo(0x0005, "ImageAdjustment", N_("Image Adjustment"), 
-                N_("Image adjustment setting"), 
+        TagInfo(0x0005, "ImageAdjustment", N_("Image Adjustment"),
+                N_("Image adjustment setting"),
                 nikon2IfdId, makerTags, unsignedShort, EXV_PRINT_TAG(nikon2ImageAdjustment)),
-        TagInfo(0x0006, "ISOSpeed", N_("ISO Speed"), 
-                N_("ISO speed setting"), 
+        TagInfo(0x0006, "ISOSpeed", N_("ISO Speed"),
+                N_("ISO speed setting"),
                 nikon2IfdId, makerTags, unsignedShort, EXV_PRINT_TAG(nikon2IsoSpeed)),
-        TagInfo(0x0007, "WhiteBalance", N_("White Balance"), 
-                N_("White balance"), 
+        TagInfo(0x0007, "WhiteBalance", N_("White Balance"),
+                N_("White balance"),
                 nikon2IfdId, makerTags, unsignedShort, EXV_PRINT_TAG(nikon2WhiteBalance)),
-        TagInfo(0x0008, "Focus", N_("Focus Mode"), 
-                N_("Focus mode"), 
+        TagInfo(0x0008, "Focus", N_("Focus Mode"),
+                N_("Focus mode"),
                 nikon2IfdId, makerTags, unsignedRational, printValue),
-        TagInfo(0x0009, "0x0009", "0x0009", 
-                N_("Unknown"), 
+        TagInfo(0x0009, "0x0009", "0x0009",
+                N_("Unknown"),
                 nikon2IfdId, makerTags, asciiString, printValue),
-        TagInfo(0x000a, "DigitalZoom", N_("Digital Zoom"), 
-                N_("Digital zoom setting"), 
+        TagInfo(0x000a, "DigitalZoom", N_("Digital Zoom"),
+                N_("Digital zoom setting"),
                 nikon2IfdId, makerTags, unsignedRational, print0x000a),
-        TagInfo(0x000b, "AuxiliaryLens", N_("Auxiliary Lens"), 
-                N_("Auxiliary lens (adapter)"), 
+        TagInfo(0x000b, "AuxiliaryLens", N_("Auxiliary Lens"),
+                N_("Auxiliary lens (adapter)"),
                 nikon2IfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x0f00, "0x0f00", "0x0f00", 
-                N_("Unknown"), 
+        TagInfo(0x0f00, "0x0f00", "0x0f00",
+                N_("Unknown"),
                 nikon2IfdId, makerTags, unsignedLong, printValue),
         // End of list marker
-        TagInfo(0xffff, "(UnknownNikon2MnTag)", "(UnknownNikon2MnTag)", 
-                N_("Unknown Nikon2MakerNote tag"), 
+        TagInfo(0xffff, "(UnknownNikon2MnTag)", "(UnknownNikon2MnTag)",
+                N_("Unknown Nikon2MakerNote tag"),
                 nikon2IfdId, makerTags, invalidTypeId, printValue)
     };
 
@@ -578,228 +578,228 @@ namespace Exiv2 {
 
     // Nikon3 MakerNote Tag Info
     const TagInfo Nikon3MakerNote::tagInfo_[] = {
-        TagInfo(0x0001, "Version", N_("Version"), 
-                N_("Nikon Makernote version"), 
+        TagInfo(0x0001, "Version", N_("Version"),
+                N_("Nikon Makernote version"),
                 nikon3IfdId, makerTags, undefined, printValue),
         TagInfo(0x0002, "ISOSpeed", N_("ISO Speed"),
-                N_("ISO speed setting"), 
+                N_("ISO speed setting"),
                 nikon3IfdId, makerTags, unsignedShort, print0x0002),
-        TagInfo(0x0003, "ColorMode", N_("Color Mode"), 
-                N_("Color mode"), 
+        TagInfo(0x0003, "ColorMode", N_("Color Mode"),
+                N_("Color mode"),
                 nikon3IfdId, makerTags, asciiString, printValue),
-         TagInfo(0x0004, "Quality", N_("Quality"), 
-                N_("Image quality setting"), 
+         TagInfo(0x0004, "Quality", N_("Quality"),
+                N_("Image quality setting"),
                 nikon3IfdId, makerTags, asciiString, printValue),
-        TagInfo(0x0005, "WhiteBalance", N_("White Balance"), 
-                N_("White balance"), 
+        TagInfo(0x0005, "WhiteBalance", N_("White Balance"),
+                N_("White balance"),
                 nikon3IfdId, makerTags, asciiString, printValue),
-        TagInfo(0x0006, "Sharpening", N_("Sharpening"), 
-                N_("Image sharpening setting"), 
+        TagInfo(0x0006, "Sharpening", N_("Sharpening"),
+                N_("Image sharpening setting"),
                 nikon3IfdId, makerTags, asciiString, printValue),
-        TagInfo(0x0007, "Focus", N_("Focus"), 
-                N_("Focus mode"), 
+        TagInfo(0x0007, "Focus", N_("Focus"),
+                N_("Focus mode"),
                 nikon3IfdId, makerTags, asciiString, print0x0007),
-        TagInfo(0x0008, "FlashSetting", N_("Flash Setting"), 
-                N_("Flash setting"), 
+        TagInfo(0x0008, "FlashSetting", N_("Flash Setting"),
+                N_("Flash setting"),
                 nikon3IfdId, makerTags, asciiString, printValue),
-        TagInfo(0x0009, "FlashDevice", N_("Flash Device"), 
-                N_("Flash device"), 
+        TagInfo(0x0009, "FlashDevice", N_("Flash Device"),
+                N_("Flash device"),
                 nikon3IfdId, makerTags, asciiString, printValue),
-        TagInfo(0x000a, "0x000a", "0x000a", 
-                N_("Unknown"), 
+        TagInfo(0x000a, "0x000a", "0x000a",
+                N_("Unknown"),
                 nikon3IfdId, makerTags, unsignedRational, printValue),
-        TagInfo(0x000b, "WhiteBalanceBias", N_("White Balance Bias"), 
-                N_("White balance bias"), 
+        TagInfo(0x000b, "WhiteBalanceBias", N_("White Balance Bias"),
+                N_("White balance bias"),
                 nikon3IfdId, makerTags, signedShort, printValue),
         TagInfo(0x000c, "ColorBalance1", N_("Color Balance 1"),
-                N_("Color balance settings 1"), 
+                N_("Color balance settings 1"),
                 nikon3IfdId, makerTags, unsignedRational, printValue),
         TagInfo(0x000d, "ProgramShift", N_("Program Shift"),
-                N_("Program shift"), 
+                N_("Program shift"),
                 nikon3IfdId, makerTags, undefined, printValue),
         TagInfo(0x000e, "ExposureDiff", N_("Exposure Difference"),
-                N_("Exposure difference"), 
+                N_("Exposure difference"),
                 nikon3IfdId, makerTags, undefined, printValue),
-        TagInfo(0x000f, "ISOSelection", N_("ISO Selection"), 
-                N_("ISO selection"), 
+        TagInfo(0x000f, "ISOSelection", N_("ISO Selection"),
+                N_("ISO selection"),
                 nikon3IfdId, makerTags, asciiString, printValue),
-        TagInfo(0x0010, "DataDump", N_("Data Dump"), 
-                N_("Data dump"), 
+        TagInfo(0x0010, "DataDump", N_("Data Dump"),
+                N_("Data dump"),
                 nikon3IfdId, makerTags, undefined, printValue),
-        TagInfo(0x0011, "Preview", N_("Pointer to a preview image"), 
+        TagInfo(0x0011, "Preview", N_("Pointer to a preview image"),
                 N_("Offset to an IFD containing a preview image"),
                 nikon3IfdId, makerTags, undefined, printValue),
-        TagInfo(0x0012, "FlashComp", N_("Flash Comp"), 
+        TagInfo(0x0012, "FlashComp", N_("Flash Comp"),
                 N_("Flash compensation setting"),
                 nikon3IfdId, makerTags, undefined, EXV_PRINT_TAG(nikonFlashComp)),
         TagInfo(0x0013, "ISOSettings", N_("ISO Settings"),
-                N_("ISO setting"), 
+                N_("ISO setting"),
                 nikon3IfdId, makerTags, unsignedShort, print0x0002), // use 0x0002 print fct
         TagInfo(0x0016, "ImageBoundary", N_("Image Boundary"),
-                N_("Image boundary"), 
+                N_("Image boundary"),
                 nikon3IfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x0017, "0x0017", "0x0017", 
-                N_("Unknown"), 
+        TagInfo(0x0017, "0x0017", "0x0017",
+                N_("Unknown"),
                 nikon3IfdId, makerTags, undefined, printValue),
-        TagInfo(0x0018, "FlashBracketComp", N_("Flash Bracket Comp"), 
-                N_("Flash bracket compensation applied"), 
+        TagInfo(0x0018, "FlashBracketComp", N_("Flash Bracket Comp"),
+                N_("Flash bracket compensation applied"),
                 nikon3IfdId, makerTags, undefined, EXV_PRINT_TAG(nikonFlashComp)), // use 0x0012 print fct
-        TagInfo(0x0019, "ExposureBracketComp", N_("Exposure Bracket Comp"), 
-                N_("AE bracket compensation applied"), 
+        TagInfo(0x0019, "ExposureBracketComp", N_("Exposure Bracket Comp"),
+                N_("AE bracket compensation applied"),
                 nikon3IfdId, makerTags, signedRational, printValue),
-        TagInfo(0x001a, "ImageProcessing", N_("Image Processing"), 
-                N_("Image processing"), 
+        TagInfo(0x001a, "ImageProcessing", N_("Image Processing"),
+                N_("Image processing"),
                 nikon3IfdId, makerTags, asciiString, printValue),
         TagInfo(0x001b, "CropHiSpeed", N_("Crop High Speed"),
-                N_("Crop high speed"), 
+                N_("Crop high speed"),
                 nikon3IfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x001d, "SerialNumber", N_("Serial Number"), 
-                N_("Serial Number"), 
+        TagInfo(0x001d, "SerialNumber", N_("Serial Number"),
+                N_("Serial Number"),
                 nikon3IfdId, makerTags, asciiString, printValue),
         TagInfo(0x001e, "ColorSpace", N_("Color Space"),
-                N_("Color space"), 
+                N_("Color space"),
                 nikon3IfdId, makerTags, unsignedShort, EXV_PRINT_TAG(nikonColorSpace)),
-        TagInfo(0x0080, "ImageAdjustment", N_("Image Adjustment"), 
-                N_("Image adjustment setting"), 
+        TagInfo(0x0080, "ImageAdjustment", N_("Image Adjustment"),
+                N_("Image adjustment setting"),
                 nikon3IfdId, makerTags, asciiString, printValue),
-        TagInfo(0x0081, "ToneComp", N_("Tone Compensation"), 
-                N_("Tone compensation"), 
+        TagInfo(0x0081, "ToneComp", N_("Tone Compensation"),
+                N_("Tone compensation"),
                 nikon3IfdId, makerTags, asciiString, printValue),
-        TagInfo(0x0082, "AuxiliaryLens", N_("Auxiliary Lens"), 
-                N_("Auxiliary lens (adapter)"), 
+        TagInfo(0x0082, "AuxiliaryLens", N_("Auxiliary Lens"),
+                N_("Auxiliary lens (adapter)"),
                 nikon3IfdId, makerTags, asciiString, printValue),
         TagInfo(0x0083, "LensType", N_("Lens Type"),
-                N_("Lens type"), 
+                N_("Lens type"),
                 nikon3IfdId, makerTags, unsignedByte, print0x0083),
         TagInfo(0x0084, "Lens", N_("Lens"),
-                N_("Lens"), 
+                N_("Lens"),
                 nikon3IfdId, makerTags, unsignedRational, print0x0084),
-        TagInfo(0x0085, "FocusDistance", N_("Focus Distance"), 
-                N_("Manual focus distance"), 
+        TagInfo(0x0085, "FocusDistance", N_("Focus Distance"),
+                N_("Manual focus distance"),
                 nikon3IfdId, makerTags, unsignedRational, print0x0085),
-        TagInfo(0x0086, "DigitalZoom", N_("Digital Zoom"), 
-                N_("Digital zoom setting"), 
+        TagInfo(0x0086, "DigitalZoom", N_("Digital Zoom"),
+                N_("Digital zoom setting"),
                 nikon3IfdId, makerTags, unsignedRational, print0x0086),
-        TagInfo(0x0087, "FlashMode", N_("Flash Mode"), 
-                N_("Mode of flash used"), 
+        TagInfo(0x0087, "FlashMode", N_("Flash Mode"),
+                N_("Mode of flash used"),
                 nikon3IfdId, makerTags, unsignedByte, EXV_PRINT_TAG(nikonFlashMode)),
-        TagInfo(0x0088, "AFFocusPos", N_("AF Focus Position"), 
-                N_("AF focus position information"), 
+        TagInfo(0x0088, "AFFocusPos", N_("AF Focus Position"),
+                N_("AF focus position information"),
                 nikon3IfdId, makerTags, undefined, print0x0088),
-        TagInfo(0x0089, "ShootingMode", N_("Shooting Mode"), 
-                N_("Shooting mode"), 
+        TagInfo(0x0089, "ShootingMode", N_("Shooting Mode"),
+                N_("Shooting mode"),
                 nikon3IfdId, makerTags, unsignedShort, EXV_PRINT_TAG(nikonShootingMode)),
         TagInfo(0x008a, "AutoBracketRelease", N_("Auto Bracket Release"),
-                N_("Auto bracket release"), 
+                N_("Auto bracket release"),
                 nikon3IfdId, makerTags, unsignedShort, EXV_PRINT_TAG(nikonAutoBracketRelease)),
         TagInfo(0x008b, "LensFStops", N_("Lens FStops"),
-                N_("Lens FStops"), 
+                N_("Lens FStops"),
                 nikon3IfdId, makerTags, undefined, print0x008b),
-        TagInfo(0x008c, "ToneCurve", N_("Tone Curve"), 
-                N_("Tone curve"), 
+        TagInfo(0x008c, "ToneCurve", N_("Tone Curve"),
+                N_("Tone curve"),
                 nikon3IfdId, makerTags, undefined, printValue),
-        TagInfo(0x008d, "ColorMode", N_("Color Mode"), 
-                N_("Color mode"), 
+        TagInfo(0x008d, "ColorMode", N_("Color Mode"),
+                N_("Color mode"),
                 nikon3IfdId, makerTags, asciiString, printValue),
-        TagInfo(0x008f, "SceneMode", N_("Scene Mode"), 
-                N_("Scene mode"), 
+        TagInfo(0x008f, "SceneMode", N_("Scene Mode"),
+                N_("Scene mode"),
                 nikon3IfdId, makerTags, asciiString, printValue),
-        TagInfo(0x0090, "LightSource", N_("Light Source"), 
-                N_("Light source"), 
+        TagInfo(0x0090, "LightSource", N_("Light Source"),
+                N_("Light source"),
                 nikon3IfdId, makerTags, asciiString, printValue),
-        TagInfo(0x0091, "0x0091", "0x0091", 
-                N_("Unknown"), 
+        TagInfo(0x0091, "0x0091", "0x0091",
+                N_("Unknown"),
                 nikon3IfdId, makerTags, undefined, printValue),
         TagInfo(0x0092, "HueAdjustment", N_("Hue Adjustment"),
-                N_("Hue adjustment"), 
+                N_("Hue adjustment"),
                 nikon3IfdId, makerTags, signedShort, printValue),
         TagInfo(0x0094, "Saturation", N_("Saturation"),
-                N_("Saturation"), 
+                N_("Saturation"),
                 nikon3IfdId, makerTags, signedShort, printValue),
-        TagInfo(0x0095, "NoiseReduction", N_("Noise Reduction"), 
-                N_("Noise reduction"), 
+        TagInfo(0x0095, "NoiseReduction", N_("Noise Reduction"),
+                N_("Noise reduction"),
                 nikon3IfdId, makerTags, asciiString, printValue),
-        TagInfo(0x0096, "CompressionCurve", N_("Compression Curve"), 
-                N_("Compression curve"), 
+        TagInfo(0x0096, "CompressionCurve", N_("Compression Curve"),
+                N_("Compression curve"),
                 nikon3IfdId, makerTags, undefined, printValue),
         TagInfo(0x0097, "ColorBalance2", N_("Color Balance 2"),
                 N_("Color balance settings 2"),
                 nikon3IfdId, makerTags, undefined, printValue),
         TagInfo(0x0098, "LensData", N_("Lens Data"),
-                N_("Lens data settings"), 
+                N_("Lens data settings"),
                 nikon3IfdId, makerTags, undefined, print0x0098),
-        TagInfo(0x0099, "NEFThumbnailSize", N_("NEF Thumbnail Size"), 
-                N_("NEF thumbnail size"), 
+        TagInfo(0x0099, "NEFThumbnailSize", N_("NEF Thumbnail Size"),
+                N_("NEF thumbnail size"),
                 nikon3IfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x009a, "SensorPixelSize", N_("Sensor Pixel Size"), 
-                N_("Sensor pixel size"), 
+        TagInfo(0x009a, "SensorPixelSize", N_("Sensor Pixel Size"),
+                N_("Sensor pixel size"),
                 nikon3IfdId, makerTags, unsignedRational, printValue),
-        TagInfo(0x009b, "0x009b", "0x009b", 
-                N_("Unknown"), 
+        TagInfo(0x009b, "0x009b", "0x009b",
+                N_("Unknown"),
                 nikon3IfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x009f, "0x009f", "0x009f", 
-                N_("Unknown"), 
+        TagInfo(0x009f, "0x009f", "0x009f",
+                N_("Unknown"),
                 nikon3IfdId, makerTags, signedShort, printValue),
-        TagInfo(0x00a0, "SerialNumber", N_("Serial Number"), 
-                N_("Camera serial number"), 
+        TagInfo(0x00a0, "SerialNumber", N_("Serial Number"),
+                N_("Camera serial number"),
                 nikon3IfdId, makerTags, asciiString, printValue),
-        TagInfo(0x00a2, "ImageDataSize", N_("Image Data Size"), 
-                N_("Image data size"), 
+        TagInfo(0x00a2, "ImageDataSize", N_("Image Data Size"),
+                N_("Image data size"),
                 nikon3IfdId, makerTags, unsignedLong, printValue),
-        TagInfo(0x00a3, "0x00a3", "0x00a3", 
-                N_("Unknown"), 
+        TagInfo(0x00a3, "0x00a3", "0x00a3",
+                N_("Unknown"),
                 nikon3IfdId, makerTags, unsignedByte, printValue),
-        TagInfo(0x00a5, "ImageCount", N_("Image Count"), 
-                N_("Image count"), 
+        TagInfo(0x00a5, "ImageCount", N_("Image Count"),
+                N_("Image count"),
                 nikon3IfdId, makerTags, unsignedLong, printValue),
-        TagInfo(0x00a6, "DeleteImageCount", N_("Delete Image Count"), 
-                N_("Delete image count"), 
+        TagInfo(0x00a6, "DeleteImageCount", N_("Delete Image Count"),
+                N_("Delete image count"),
                 nikon3IfdId, makerTags, unsignedLong, printValue),
-        TagInfo(0x00a7, "ShutterCount", N_("Shutter Count"), 
-                N_("Number of shots taken by camera"), 
+        TagInfo(0x00a7, "ShutterCount", N_("Shutter Count"),
+                N_("Number of shots taken by camera"),
                 nikon3IfdId, makerTags, unsignedLong, printValue),
-        TagInfo(0x00a8, "0x00a8", "0x00a8", 
-                N_("Unknown"), 
+        TagInfo(0x00a8, "0x00a8", "0x00a8",
+                N_("Unknown"),
                 nikon3IfdId, makerTags, undefined, printValue),
-        TagInfo(0x00a9, "ImageOptimization", N_("Image Optimization"), 
-                N_("Image optimization"), 
+        TagInfo(0x00a9, "ImageOptimization", N_("Image Optimization"),
+                N_("Image optimization"),
                 nikon3IfdId, makerTags, asciiString, printValue),
-        TagInfo(0x00aa, "Saturation", N_("Saturation"), 
-                N_("Saturation"), 
+        TagInfo(0x00aa, "Saturation", N_("Saturation"),
+                N_("Saturation"),
                 nikon3IfdId, makerTags, asciiString, printValue),
-        TagInfo(0x00ab, "VariProgram", N_("Program Variation"), 
-                N_("Program variation"), 
+        TagInfo(0x00ab, "VariProgram", N_("Program Variation"),
+                N_("Program variation"),
                 nikon3IfdId, makerTags, asciiString, printValue),
-        TagInfo(0x00ac, "ImageStabilization", N_("Image Stabilization"), 
-                N_("Image stabilization"), 
+        TagInfo(0x00ac, "ImageStabilization", N_("Image Stabilization"),
+                N_("Image stabilization"),
                 nikon3IfdId, makerTags, asciiString, printValue),
-        TagInfo(0x00ad, "AFResponse", N_("AF Response"), 
-                N_("AF response"), 
+        TagInfo(0x00ad, "AFResponse", N_("AF Response"),
+                N_("AF response"),
                 nikon3IfdId, makerTags, asciiString, printValue),
         TagInfo(0x00b1, "HighISONoiseReduction", N_("High ISO Noise Reduction"),
-                N_("High ISO Noise Reduction"), 
+                N_("High ISO Noise Reduction"),
                 nikon3IfdId, makerTags, unsignedShort, EXV_PRINT_TAG(nikonHighISONoiseReduction)),
-        TagInfo(0x0e00, "PrintIM", N_("Print IM"), 
-                N_("PrintIM information"), 
+        TagInfo(0x0e00, "PrintIM", N_("Print IM"),
+                N_("PrintIM information"),
                 nikon3IfdId, makerTags, undefined, printValue),
 
         // TODO: Add Capture Data decoding implementation.
-        TagInfo(0x0e01, "CaptureData", N_("Capture Data"), 
-                N_("Capture data"), 
+        TagInfo(0x0e01, "CaptureData", N_("Capture Data"),
+                N_("Capture data"),
                 nikon3IfdId, makerTags, undefined, printValue),
 
-        TagInfo(0x0e09, "CaptureVersion", N_("Capture Version"), 
-                N_("Capture version"), 
+        TagInfo(0x0e09, "CaptureVersion", N_("Capture Version"),
+                N_("Capture version"),
                 nikon3IfdId, makerTags, asciiString, printValue),
 
         // TODO: Add Capture Offsets decoding implementation.
-        TagInfo(0x0e0e, "CaptureOffsets", N_("Capture Offsets"), 
-                N_("Capture offsets"), 
+        TagInfo(0x0e0e, "CaptureOffsets", N_("Capture Offsets"),
+                N_("Capture offsets"),
                 nikon3IfdId, makerTags, undefined, printValue),
 
         // End of list marker
         TagInfo(0xffff, "(UnknownNikon3MnTag)", "(UnknownNikon3MnTag)",
-                N_("Unknown Nikon3MakerNote tag"), 
+                N_("Unknown Nikon3MakerNote tag"),
                 nikon3IfdId, makerTags, invalidTypeId, printValue)
     };
 
diff --git a/src/olympusmn.cpp b/src/olympusmn.cpp
index c13d86fa..3a92106f 100644
--- a/src/olympusmn.cpp
+++ b/src/olympusmn.cpp
@@ -116,280 +116,280 @@ namespace Exiv2 {
     // Olympus Tag Info
     const TagInfo OlympusMakerNote::tagInfo_[] = {
 
-        /* TODO: 
+        /* TODO:
            add Minolta makenotes tags here (0x0000-0x0103). See Exiftool database.*/
 
-        TagInfo(0x0200, "SpecialMode", N_("Special Mode"), 
-                N_("Picture taking mode"), 
+        TagInfo(0x0200, "SpecialMode", N_("Special Mode"),
+                N_("Picture taking mode"),
                 olympusIfdId, makerTags, unsignedLong, print0x0200),
-        TagInfo(0x0201, "Quality", N_("Quality"), 
-                N_("Image quality setting"), 
+        TagInfo(0x0201, "Quality", N_("Quality"),
+                N_("Image quality setting"),
                 olympusIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(olympusQuality)),
-        TagInfo(0x0202, "Macro", N_("Macro"), 
-                N_("Macro mode"), 
+        TagInfo(0x0202, "Macro", N_("Macro"),
+                N_("Macro mode"),
                 olympusIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(olympusMacro)),
-        TagInfo(0x0203, "BWMode", N_("Black & White Mode"), 
-                N_("Black and white mode"), 
+        TagInfo(0x0203, "BWMode", N_("Black & White Mode"),
+                N_("Black and white mode"),
                 olympusIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(olympusOffOn)),
-        TagInfo(0x0204, "DigitalZoom", N_("Digital Zoom"), 
-                N_("Digital zoom ratio"), 
+        TagInfo(0x0204, "DigitalZoom", N_("Digital Zoom"),
+                N_("Digital zoom ratio"),
                 olympusIfdId, makerTags, unsignedRational, print0x0204),
-        TagInfo(0x0205, "FocalPlaneDiagonal", N_("Focal Plane Diagonal"), 
-                N_("Focal plane diagonal"), 
+        TagInfo(0x0205, "FocalPlaneDiagonal", N_("Focal Plane Diagonal"),
+                N_("Focal plane diagonal"),
                 olympusIfdId, makerTags, unsignedRational, printValue),
-        TagInfo(0x0206, "LensDistortionParams", N_("Lens Distortion Parameters"), 
-                N_("Lens distortion parameters"), 
+        TagInfo(0x0206, "LensDistortionParams", N_("Lens Distortion Parameters"),
+                N_("Lens distortion parameters"),
                 olympusIfdId, makerTags, signedShort, printValue),
-        TagInfo(0x0207, "FirmwareVersion", N_("Firmware Version"), 
-                N_("Software firmware version"), 
+        TagInfo(0x0207, "FirmwareVersion", N_("Firmware Version"),
+                N_("Software firmware version"),
                 olympusIfdId, makerTags, asciiString, printValue),
-        TagInfo(0x0208, "PictureInfo", N_("Picture Info"),             
-                N_("ASCII format data such as [PictureInfo]"),         
-                olympusIfdId, makerTags, asciiString, printValue),  
-        TagInfo(0x0209, "CameraID", N_("Camera ID"), 
-                N_("Camera ID data"), 
+        TagInfo(0x0208, "PictureInfo", N_("Picture Info"),
+                N_("ASCII format data such as [PictureInfo]"),
+                olympusIfdId, makerTags, asciiString, printValue),
+        TagInfo(0x0209, "CameraID", N_("Camera ID"),
+                N_("Camera ID data"),
                 olympusIfdId, makerTags, undefined, printValue),
 
         /* TODO: Epson Camera tags. See ExifTool database.
 
-        TagInfo(0x020b, "ImageWidth", N_("Image Width"),                
-                N_("Image width"), 
+        TagInfo(0x020b, "ImageWidth", N_("Image Width"),
+                N_("Image width"),
                 olympusIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x020c, "ImageHeight", N_("Image Height"),              
-                N_("Image height"), 
+        TagInfo(0x020c, "ImageHeight", N_("Image Height"),
+                N_("Image height"),
                 olympusIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x020d, "Software", N_("Software"),                     
-                N_("Software"), 
+        TagInfo(0x020d, "Software", N_("Software"),
+                N_("Software"),
                 olympusIfdId, makerTags, asciiString, printValue),
-        TagInfo(0x0280, "PreviewImage", N_("Preview Image"),            
-                N_("Preview image"), 
+        TagInfo(0x0280, "PreviewImage", N_("Preview Image"),
+                N_("Preview image"),
                 olympusIfdId, makerTags, unsignedByte, printValue),
         */
 
-        TagInfo(0x0300, "PreCaptureFrames", N_("Pre Capture Frames"), 
-                N_("Pre-capture frames"), 
+        TagInfo(0x0300, "PreCaptureFrames", N_("Pre Capture Frames"),
+                N_("Pre-capture frames"),
                 olympusIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x0301, "0x0301", "0x0301", 
-                N_("Unknown"), 
+        TagInfo(0x0301, "0x0301", "0x0301",
+                N_("Unknown"),
                 olympusIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x0302, "OneTouchWB", N_("One Touch WB"), 
-                N_("One touch white balance"), 
+        TagInfo(0x0302, "OneTouchWB", N_("One Touch WB"),
+                N_("One touch white balance"),
                 olympusIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(olympusOneTouchWb)),
-        TagInfo(0x0303, "0x0303", "0x0303", 
-                N_("Unknown"), 
+        TagInfo(0x0303, "0x0303", "0x0303",
+                N_("Unknown"),
                 olympusIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x0304, "0x0304", "0x0304", 
-                N_("Unknown"), 
+        TagInfo(0x0304, "0x0304", "0x0304",
+                N_("Unknown"),
                 olympusIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x0404, "SerialNumber", N_("Serial Number"), 
-                N_("Serial number"), 
+        TagInfo(0x0404, "SerialNumber", N_("Serial Number"),
+                N_("Serial number"),
                 olympusIfdId, makerTags, asciiString, printValue),
-        TagInfo(0x0e00, "PrintIM", N_("Print IM"), 
-                N_("PrintIM information"), 
+        TagInfo(0x0e00, "PrintIM", N_("Print IM"),
+                N_("PrintIM information"),
                 olympusIfdId, makerTags, undefined, printValue),
-        TagInfo(0x0f00, "DataDump1", N_("Data Dump 1"), 
-                N_("Various camera settings 1"), 
+        TagInfo(0x0f00, "DataDump1", N_("Data Dump 1"),
+                N_("Various camera settings 1"),
                 olympusIfdId, makerTags, undefined, printValue),
-        TagInfo(0x0f01, "DataDump2", N_("Data Dump 2"), 
-                N_("Various camera settings 2"), 
+        TagInfo(0x0f01, "DataDump2", N_("Data Dump 2"),
+                N_("Various camera settings 2"),
                 olympusIfdId, makerTags, undefined, printValue),
-        TagInfo(0x1000, "ShutterSpeed", N_("Shutter Speed"), 
-                N_("Shutter speed value"), 
+        TagInfo(0x1000, "ShutterSpeed", N_("Shutter Speed"),
+                N_("Shutter speed value"),
                 olympusIfdId, makerTags, signedRational, printValue),
-        TagInfo(0x1001, "ISOSpeed", N_("ISO Speed"), 
-                N_("ISO speed value"), 
+        TagInfo(0x1001, "ISOSpeed", N_("ISO Speed"),
+                N_("ISO speed value"),
                 olympusIfdId, makerTags, signedRational, printValue),
-        TagInfo(0x1002, "ApertureValue", N_("Aperture Value"), 
-                N_("Aperture value"), 
+        TagInfo(0x1002, "ApertureValue", N_("Aperture Value"),
+                N_("Aperture value"),
                 olympusIfdId, makerTags, signedRational, printValue),
-        TagInfo(0x1003, "Brightness", N_("Brightness"), 
-                N_("Brightness value"), 
+        TagInfo(0x1003, "Brightness", N_("Brightness"),
+                N_("Brightness value"),
                 olympusIfdId, makerTags, signedRational, printValue),
-        TagInfo(0x1004, "FlashMode", N_("Flash Mode"), 
-                N_("Flash mode"), 
+        TagInfo(0x1004, "FlashMode", N_("Flash Mode"),
+                N_("Flash mode"),
                 olympusIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(olympusOffOn)),
-        TagInfo(0x1005, "FlashDevice", N_("Flash Device"), 
-                N_("Flash device"), 
+        TagInfo(0x1005, "FlashDevice", N_("Flash Device"),
+                N_("Flash device"),
                 olympusIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(olympusFlashDevice)),
-        TagInfo(0x1006, "Bracket", N_("Bracket"), 
-                N_("Exposure compensation value"), 
+        TagInfo(0x1006, "Bracket", N_("Bracket"),
+                N_("Exposure compensation value"),
                 olympusIfdId, makerTags, signedRational, printValue),
-        TagInfo(0x1007, "SensorTemperature", N_("Sensor Temperature"), 
-                N_("Sensor temperature"), 
+        TagInfo(0x1007, "SensorTemperature", N_("Sensor Temperature"),
+                N_("Sensor temperature"),
                 olympusIfdId, makerTags, signedShort, printValue),
-        TagInfo(0x1008, "LensTemperature", N_("Lens Temperature"), 
-                N_("Lens temperature"), 
+        TagInfo(0x1008, "LensTemperature", N_("Lens Temperature"),
+                N_("Lens temperature"),
                 olympusIfdId, makerTags, signedShort, printValue),
-        TagInfo(0x1009, "0x1009", "0x1009", 
-                N_("Unknown"), 
+        TagInfo(0x1009, "0x1009", "0x1009",
+                N_("Unknown"),
                 olympusIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x100a, "0x100a", "0x100a", 
-                N_("Unknown"), 
+        TagInfo(0x100a, "0x100a", "0x100a",
+                N_("Unknown"),
                 olympusIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x100b, "FocusMode", N_("Focus Mode"), 
-                N_("Focus mode"), 
+        TagInfo(0x100b, "FocusMode", N_("Focus Mode"),
+                N_("Focus mode"),
                 olympusIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(olympusFocusMode)),
-        TagInfo(0x100c, "FocusDistance", N_("Focus Distance"), 
-                N_("Manual focus distance"), 
+        TagInfo(0x100c, "FocusDistance", N_("Focus Distance"),
+                N_("Manual focus distance"),
                 olympusIfdId, makerTags, unsignedRational, printValue),
-        TagInfo(0x100d, "Zoom", N_("Zoom"), 
-                N_("Zoom step count"), 
+        TagInfo(0x100d, "Zoom", N_("Zoom"),
+                N_("Zoom step count"),
                 olympusIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x100e, "MacroFocus", N_("Macro Focus"), 
-                N_("Macro focus step count"), 
+        TagInfo(0x100e, "MacroFocus", N_("Macro Focus"),
+                N_("Macro focus step count"),
                 olympusIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x100f, "SharpnessFactor", N_("Sharpness Factor"), 
-                N_("Sharpness factor"), 
+        TagInfo(0x100f, "SharpnessFactor", N_("Sharpness Factor"),
+                N_("Sharpness factor"),
                 olympusIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(olympusSharpness)),
-        TagInfo(0x1010, "FlashChargeLevel", N_("Flash Charge Level"), 
-                N_("Flash charge level"), 
+        TagInfo(0x1010, "FlashChargeLevel", N_("Flash Charge Level"),
+                N_("Flash charge level"),
                 olympusIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x1011, "ColorMatrix", N_("Color Matrix"), 
-                N_("Color matrix"), 
+        TagInfo(0x1011, "ColorMatrix", N_("Color Matrix"),
+                N_("Color matrix"),
                 olympusIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x1012, "BlackLevel", N_("BlackLevel"), 
-                N_("Black level"), 
+        TagInfo(0x1012, "BlackLevel", N_("BlackLevel"),
+                N_("Black level"),
                 olympusIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x1013, "0x1013", "0x1013", 
-                N_("Unknown"), 
+        TagInfo(0x1013, "0x1013", "0x1013",
+                N_("Unknown"),
                 olympusIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x1014, "0x1014", "0x1014", 
-                N_("Unknown"), 
+        TagInfo(0x1014, "0x1014", "0x1014",
+                N_("Unknown"),
                 olympusIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x1015, "WhiteBalance", N_("White Balance"), 
-                N_("White balance mode"), 
+        TagInfo(0x1015, "WhiteBalance", N_("White Balance"),
+                N_("White balance mode"),
                 olympusIfdId, makerTags, unsignedShort, print0x1015),
-        TagInfo(0x1016, "0x1016", "0x1016", 
-                N_("Unknown"), 
+        TagInfo(0x1016, "0x1016", "0x1016",
+                N_("Unknown"),
                 olympusIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x1017, "RedBalance", N_("Red Balance"), 
-                N_("Red balance"), 
+        TagInfo(0x1017, "RedBalance", N_("Red Balance"),
+                N_("Red balance"),
                 olympusIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x1018, "BlueBalance", N_("Blue Balance"), 
-                N_("Blue balance"), 
+        TagInfo(0x1018, "BlueBalance", N_("Blue Balance"),
+                N_("Blue balance"),
                 olympusIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x1019, "0x1019", "0x1019", 
-                N_("Unknown"), 
+        TagInfo(0x1019, "0x1019", "0x1019",
+                N_("Unknown"),
                 olympusIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x101a, "SerialNumber2", N_("Serial Number 2"), 
-                N_("Serial number 2"), 
+        TagInfo(0x101a, "SerialNumber2", N_("Serial Number 2"),
+                N_("Serial number 2"),
                 olympusIfdId, makerTags, asciiString, printValue),
-        TagInfo(0x101b, "0x101b", "0x101b", 
-                N_("Unknown"), 
+        TagInfo(0x101b, "0x101b", "0x101b",
+                N_("Unknown"),
                 olympusIfdId, makerTags, unsignedLong, printValue),
-        TagInfo(0x101c, "0x101c", "0x101c", 
-                N_("Unknown"), 
+        TagInfo(0x101c, "0x101c", "0x101c",
+                N_("Unknown"),
                 olympusIfdId, makerTags, unsignedLong, printValue),
-        TagInfo(0x101d, "0x101d", "0x101d", 
-                N_("Unknown"), 
+        TagInfo(0x101d, "0x101d", "0x101d",
+                N_("Unknown"),
                 olympusIfdId, makerTags, unsignedLong, printValue),
-        TagInfo(0x101e, "0x101e", "0x101e", 
-                N_("Unknown"), 
+        TagInfo(0x101e, "0x101e", "0x101e",
+                N_("Unknown"),
                 olympusIfdId, makerTags, unsignedLong, printValue),
-        TagInfo(0x101f, "0x101f", "0x101f", 
-                N_("Unknown"), 
+        TagInfo(0x101f, "0x101f", "0x101f",
+                N_("Unknown"),
                 olympusIfdId, makerTags, unsignedLong, printValue),
-        TagInfo(0x1020, "0x1020", "0x1020", 
-                N_("Unknown"), 
+        TagInfo(0x1020, "0x1020", "0x1020",
+                N_("Unknown"),
                 olympusIfdId, makerTags, unsignedLong, printValue),
-        TagInfo(0x1021, "0x1021", "0x1021", 
-                N_("Unknown"), 
+        TagInfo(0x1021, "0x1021", "0x1021",
+                N_("Unknown"),
                 olympusIfdId, makerTags, unsignedLong, printValue),
-        TagInfo(0x1022, "0x1022", "0x1022", 
-                N_("Unknown"), 
+        TagInfo(0x1022, "0x1022", "0x1022",
+                N_("Unknown"),
                 olympusIfdId, makerTags, unsignedLong, printValue),
-        TagInfo(0x1023, "FlashBias", N_("Flash Bias"), 
-                N_("Flash exposure compensation"), 
+        TagInfo(0x1023, "FlashBias", N_("Flash Bias"),
+                N_("Flash exposure compensation"),
                 olympusIfdId, makerTags, signedRational, printValue),
-        TagInfo(0x1024, "0x1024", "0x1024", 
-                N_("Unknown"), 
+        TagInfo(0x1024, "0x1024", "0x1024",
+                N_("Unknown"),
                 olympusIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x1025, "0x1025", "0x1025", 
-                N_("Unknown"), 
+        TagInfo(0x1025, "0x1025", "0x1025",
+                N_("Unknown"),
                 olympusIfdId, makerTags, signedRational, printValue),
-        TagInfo(0x1026, "ExternalFlashBounce", N_("External Flash Bounce"), 
-                N_("External flash bounce"), 
+        TagInfo(0x1026, "ExternalFlashBounce", N_("External Flash Bounce"),
+                N_("External flash bounce"),
                 olympusIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(olympusOffOn)),
-        TagInfo(0x1027, "ExternalFlashZoom", N_("External Flash Zoom"), 
-                N_("External flash zoom"), 
+        TagInfo(0x1027, "ExternalFlashZoom", N_("External Flash Zoom"),
+                N_("External flash zoom"),
                 olympusIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x1028, "ExternalFlashMode", N_("External Flash Mode"), 
-                N_("External flash mode"), 
+        TagInfo(0x1028, "ExternalFlashMode", N_("External Flash Mode"),
+                N_("External flash mode"),
                 olympusIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x1029, "Contrast", N_("Contrast"), 
+        TagInfo(0x1029, "Contrast", N_("Contrast"),
                 N_("Contrast setting"),
                 olympusIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(olympusContrast)),
-        TagInfo(0x102a, "SharpnessFactor", N_("Sharpness Factor"), 
-                N_("Sharpness factor"), 
+        TagInfo(0x102a, "SharpnessFactor", N_("Sharpness Factor"),
+                N_("Sharpness factor"),
                 olympusIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x102b, "ColorControl", N_("Color Control"), 
-                N_("Color control"), 
+        TagInfo(0x102b, "ColorControl", N_("Color Control"),
+                N_("Color control"),
                 olympusIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x102c, "ValidBits", N_("ValidBits"), 
-                N_("Valid bits"), 
+        TagInfo(0x102c, "ValidBits", N_("ValidBits"),
+                N_("Valid bits"),
                 olympusIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x102d, "CoringFilter", N_("CoringFilter"), 
-                N_("Coring filter"), 
+        TagInfo(0x102d, "CoringFilter", N_("CoringFilter"),
+                N_("Coring filter"),
                 olympusIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x102e, "ImageWidth", N_("Image Width"), 
-                N_("Image width"), 
+        TagInfo(0x102e, "ImageWidth", N_("Image Width"),
+                N_("Image width"),
                 olympusIfdId, makerTags, unsignedLong, printValue),
-        TagInfo(0x102f, "ImageHeight", N_("Image Height"), 
-                N_("Image height"), 
+        TagInfo(0x102f, "ImageHeight", N_("Image Height"),
+                N_("Image height"),
                 olympusIfdId, makerTags, unsignedLong, printValue),
-        TagInfo(0x1030, "0x1030", "0x1030", 
-                N_("Unknown"), 
+        TagInfo(0x1030, "0x1030", "0x1030",
+                N_("Unknown"),
                 olympusIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x1031, "0x1031", "0x1031", 
-                N_("Unknown"), 
+        TagInfo(0x1031, "0x1031", "0x1031",
+                N_("Unknown"),
                 olympusIfdId, makerTags, unsignedLong, printValue),
-        TagInfo(0x1032, "0x1032", "0x1032", 
-                N_("Unknown"), 
+        TagInfo(0x1032, "0x1032", "0x1032",
+                N_("Unknown"),
                 olympusIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x1033, "0x1033", "0x1033", 
-                N_("Unknown"), 
+        TagInfo(0x1033, "0x1033", "0x1033",
+                N_("Unknown"),
                 olympusIfdId, makerTags, unsignedLong, printValue),
-        TagInfo(0x1034, "CompressionRatio", N_("Compression Ratio"), 
-                N_("Compression ratio"), 
+        TagInfo(0x1034, "CompressionRatio", N_("Compression Ratio"),
+                N_("Compression ratio"),
                 olympusIfdId, makerTags, unsignedRational, printValue),
-        TagInfo(0x1035, "Thumbnail", N_("Thumbnail"), 
-                N_("Preview image embedded"), 
+        TagInfo(0x1035, "Thumbnail", N_("Thumbnail"),
+                N_("Preview image embedded"),
                 olympusIfdId, makerTags, unsignedLong, EXV_PRINT_TAG(olympusOffOn)),
-        TagInfo(0x1036, "ThumbnailOffset", N_("Thumbnail Offset"), 
-                N_("Offset of the preview image"), 
+        TagInfo(0x1036, "ThumbnailOffset", N_("Thumbnail Offset"),
+                N_("Offset of the preview image"),
                 olympusIfdId, makerTags, unsignedLong, printValue),
-        TagInfo(0x1037, "ThumbnailLength", N_("Thumbnail Length"), 
-                N_("Size of the preview image"), 
+        TagInfo(0x1037, "ThumbnailLength", N_("Thumbnail Length"),
+                N_("Size of the preview image"),
                 olympusIfdId, makerTags, unsignedLong, printValue),
-        TagInfo(0x1039, "CCDScanMode", N_("CCD Scan Mode"), 
-                N_("CCD scan mode"), 
+        TagInfo(0x1039, "CCDScanMode", N_("CCD Scan Mode"),
+                N_("CCD scan mode"),
                 olympusIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(olympusCCDScanMode)),
-        TagInfo(0x103a, "NoiseReduction", N_("Noise Reduction"), 
-                N_("Noise reduction"), 
+        TagInfo(0x103a, "NoiseReduction", N_("Noise Reduction"),
+                N_("Noise reduction"),
                 olympusIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(olympusOffOn)),
-        TagInfo(0x103b, "InfinityLensStep", N_("Infinity Lens Step"), 
-                N_("Infinity lens step"), 
+        TagInfo(0x103b, "InfinityLensStep", N_("Infinity Lens Step"),
+                N_("Infinity lens step"),
                 olympusIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x103c, "NearLensStep", N_("Near Lens Step"), 
-                N_("Near lens step"), 
+        TagInfo(0x103c, "NearLensStep", N_("Near Lens Step"),
+                N_("Near lens step"),
                 olympusIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x2010, "Equipment", N_("Equipment Info"), 
-                N_("Camera equipment information"), 
+        TagInfo(0x2010, "Equipment", N_("Equipment Info"),
+                N_("Camera equipment information"),
                 minoltaIfdId, makerTags, undefined, printValue),
-        TagInfo(0x2020, "CameraSettings", N_("Camera Settings"), 
-                N_("Camera Settings information"), 
+        TagInfo(0x2020, "CameraSettings", N_("Camera Settings"),
+                N_("Camera Settings information"),
                 minoltaIfdId, makerTags, undefined, printValue),
-        TagInfo(0x2030, "RawDevelopment", N_("Raw Development"), 
-                N_("Raw development information"), 
+        TagInfo(0x2030, "RawDevelopment", N_("Raw Development"),
+                N_("Raw development information"),
                 minoltaIfdId, makerTags, undefined, printValue),
-        TagInfo(0x2040, "ImageProcessing", N_("Image Processing"), 
-                N_("Image processing information"), 
+        TagInfo(0x2040, "ImageProcessing", N_("Image Processing"),
+                N_("Image processing information"),
                 minoltaIfdId, makerTags, undefined, printValue),
-        TagInfo(0x2050, "FocusInfo", N_("Focus Info"), 
-                N_("Focus information"), 
+        TagInfo(0x2050, "FocusInfo", N_("Focus Info"),
+                N_("Focus information"),
                 minoltaIfdId, makerTags, undefined, printValue),
-        TagInfo(0x3000, "RawInfo", N_("Raw Info"), 
-                N_("Raw information"), 
+        TagInfo(0x3000, "RawInfo", N_("Raw Info"),
+                N_("Raw information"),
                 minoltaIfdId, makerTags, undefined, printValue),
 
         // End of list marker
diff --git a/src/panasonicmn.cpp b/src/panasonicmn.cpp
index 19c3f973..eec2ec81 100644
--- a/src/panasonicmn.cpp
+++ b/src/panasonicmn.cpp
@@ -181,102 +181,102 @@ namespace Exiv2 {
 
     // Panasonic MakerNote Tag Info
     const TagInfo PanasonicMakerNote::tagInfo_[] = {
-        TagInfo(0x0001, "Quality", N_("Quality"), 
-                N_("Image Quality"), 
+        TagInfo(0x0001, "Quality", N_("Quality"),
+                N_("Image Quality"),
                 panasonicIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(panasonicQuality)),
-        TagInfo(0x0002, "FirmwareVersion", N_("Firmware Version"), 
-                N_("Firmware version"), 
+        TagInfo(0x0002, "FirmwareVersion", N_("Firmware Version"),
+                N_("Firmware version"),
                 panasonicIfdId, makerTags, undefined, printValue),
-        TagInfo(0x0003, "WhiteBalance", N_("White Balance"), 
-                N_("White balance setting"), 
+        TagInfo(0x0003, "WhiteBalance", N_("White Balance"),
+                N_("White balance setting"),
                 panasonicIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(panasonicWhiteBalance)),
-        TagInfo(0x0004, "0x0004", "0x0004", 
-                N_("Unknown"), 
+        TagInfo(0x0004, "0x0004", "0x0004",
+                N_("Unknown"),
                 panasonicIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x0007, "FocusMode", N_("Focus Mode"), 
-                N_("Focus mode"), 
+        TagInfo(0x0007, "FocusMode", N_("Focus Mode"),
+                N_("Focus mode"),
                 panasonicIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(panasonicFocusMode)),
-        TagInfo(0x000f, "SpotMode", N_("Spot Mode"), N_("Spot mode"), 
+        TagInfo(0x000f, "SpotMode", N_("Spot Mode"), N_("Spot mode"),
                 panasonicIfdId, makerTags, unsignedByte, print0x000f),
         TagInfo(0x001a, "ImageStabilizer", N_("ImageStabilizer"),
                 N_("Image stabilizer"),
                 panasonicIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(panasonicImageStabilizer)),
-        TagInfo(0x001c, "Macro", N_("Macro"), 
-                N_("Macro mode"), 
+        TagInfo(0x001c, "Macro", N_("Macro"),
+                N_("Macro mode"),
                 panasonicIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(panasonicMacro)),
-        TagInfo(0x001f, "ShootingMode", N_("Shooting Mode"), 
-                N_("Shooting mode"), 
+        TagInfo(0x001f, "ShootingMode", N_("Shooting Mode"),
+                N_("Shooting mode"),
                 panasonicIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(panasonicShootingMode)),
-        TagInfo(0x0020, "Audio", N_("Audio"), 
-                N_("Audio"), 
+        TagInfo(0x0020, "Audio", N_("Audio"),
+                N_("Audio"),
                 panasonicIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(panasonicAudio)),
-        TagInfo(0x0021, "DataDump", N_("Data Dump"), 
-                N_("Data dump"), 
+        TagInfo(0x0021, "DataDump", N_("Data Dump"),
+                N_("Data dump"),
                 panasonicIfdId, makerTags, undefined, printValue),
-        TagInfo(0x0022, "0x0022", "0x0022", 
-                N_("Unknown"), 
+        TagInfo(0x0022, "0x0022", "0x0022",
+                N_("Unknown"),
                 panasonicIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x0023, "WhiteBalanceBias", N_("White Balance Bias"), 
-                N_("White balance adjustment"), 
+        TagInfo(0x0023, "WhiteBalanceBias", N_("White Balance Bias"),
+                N_("White balance adjustment"),
                 panasonicIfdId, makerTags, unsignedShort, print0x0023),
-        TagInfo(0x0024, "FlashBias", N_("FlashBias"), 
-                N_("Flash bias"), 
+        TagInfo(0x0024, "FlashBias", N_("FlashBias"),
+                N_("Flash bias"),
                 panasonicIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x0025, "SerialNumber", N_("Serial Number"), 
+        TagInfo(0x0025, "SerialNumber", N_("Serial Number"),
                 N_("This number is unique, and contains the date of manufacture, "
-                   "but is not the same as the number printed on the camera body."), 
+                   "but is not the same as the number printed on the camera body."),
                 panasonicIfdId, makerTags, undefined, printValue),
-        TagInfo(0x0026, "0x0026", "0x0026", 
-                N_("Unknown"), 
+        TagInfo(0x0026, "0x0026", "0x0026",
+                N_("Unknown"),
                 panasonicIfdId, makerTags, undefined, printValue),
-        TagInfo(0x0027, "0x0027", "0x0027", 
-                N_("Unknown"), 
+        TagInfo(0x0027, "0x0027", "0x0027",
+                N_("Unknown"),
                 panasonicIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x0028, "ColorEffect", N_("Color Effect"), 
-                N_("Color effect"), 
+        TagInfo(0x0028, "ColorEffect", N_("Color Effect"),
+                N_("Color effect"),
                 panasonicIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(panasonicColorEffect)),
-        TagInfo(0x0029, "0x0029", "0x0029", 
-                N_("Unknown"), 
+        TagInfo(0x0029, "0x0029", "0x0029",
+                N_("Unknown"),
                 panasonicIfdId, makerTags, unsignedLong, printValue),
-        TagInfo(0x002a, "BurstMode", N_("Burst Mode"), 
-                N_("Burst mode"), 
+        TagInfo(0x002a, "BurstMode", N_("Burst Mode"),
+                N_("Burst mode"),
                 panasonicIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(panasonicBurstMode)),
-        TagInfo(0x002b, "SequenceNumber", N_("Sequence Number"), 
-                N_("Sequence number"), 
+        TagInfo(0x002b, "SequenceNumber", N_("Sequence Number"),
+                N_("Sequence number"),
                 panasonicIfdId, makerTags, unsignedLong, printValue),
-        TagInfo(0x002c, "Contrast", N_("Contrast"), 
-                N_("Contrast setting"), 
+        TagInfo(0x002c, "Contrast", N_("Contrast"),
+                N_("Contrast setting"),
                 panasonicIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(panasonicContrast)),
-        TagInfo(0x002d, "NoiseReduction", N_("NoiseReduction"), 
-                N_("Noise reduction"), 
+        TagInfo(0x002d, "NoiseReduction", N_("NoiseReduction"),
+                N_("Noise reduction"),
                 panasonicIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(panasonicNoiseReduction)),
-        TagInfo(0x002e, "SelfTimer", N_("Self Timer"), 
-                N_("Self timer"), 
+        TagInfo(0x002e, "SelfTimer", N_("Self Timer"),
+                N_("Self timer"),
                 panasonicIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(panasonicSelfTimer)),
-        TagInfo(0x002f, "0x002f", "0x002f", 
-                N_("Unknown"), 
+        TagInfo(0x002f, "0x002f", "0x002f",
+                N_("Unknown"),
                 panasonicIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x0030, "Rotation", N_("Rotation"), 
-                N_("Rotation"), 
+        TagInfo(0x0030, "Rotation", N_("Rotation"),
+                N_("Rotation"),
                 panasonicIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(panasonicRotation)),
-        TagInfo(0x0031, "0x0031", "0x0031", 
-                N_("Unknown"), 
+        TagInfo(0x0031, "0x0031", "0x0031",
+                N_("Unknown"),
                 panasonicIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x0032, "ColorMode", N_("Color Mode"), 
-                N_("Color mode"), 
+        TagInfo(0x0032, "ColorMode", N_("Color Mode"),
+                N_("Color mode"),
                 panasonicIfdId, makerTags, unsignedShort, EXV_PRINT_TAG(panasonicColorMode)),
-        TagInfo(0x0036, "TravelDay", N_("Travel Day"), 
-                N_("Travel day"), 
+        TagInfo(0x0036, "TravelDay", N_("Travel Day"),
+                N_("Travel day"),
                 panasonicIfdId, makerTags, unsignedShort, printValue),
-        TagInfo(0x0e00, "PrintIM", N_("Print IM"), 
-                N_("PrintIM information"), 
+        TagInfo(0x0e00, "PrintIM", N_("Print IM"),
+                N_("PrintIM information"),
                 minoltaIfdId, makerTags, undefined, printValue),
-        TagInfo(0x4449, "0x4449", "0x4449", 
-                N_("Unknown"), 
+        TagInfo(0x4449, "0x4449", "0x4449",
+                N_("Unknown"),
                 panasonicIfdId, makerTags, undefined, printValue),
         // End of list marker
-        TagInfo(0xffff, "(UnknownPanasonicMakerNoteTag)", "(UnknownPanasonicMakerNoteTag)", 
-                N_("Unknown PanasonicMakerNote tag"), 
+        TagInfo(0xffff, "(UnknownPanasonicMakerNoteTag)", "(UnknownPanasonicMakerNoteTag)",
+                N_("Unknown PanasonicMakerNote tag"),
                 panasonicIfdId, makerTags, invalidTypeId, printValue)
     };
 
diff --git a/src/pngchunk.cpp b/src/pngchunk.cpp
index 15ff02ab..8110a6c2 100644
--- a/src/pngchunk.cpp
+++ b/src/pngchunk.cpp
@@ -94,7 +94,7 @@ namespace Exiv2 {
                 const byte *key = &PNG_CHUNK_DATA(pData, index, 0);
 
                 int keysize=0;
-                for ( ; key[keysize] != 0 ; keysize++) 
+                for ( ; key[keysize] != 0 ; keysize++)
                 {
                     // look if we reached the end of the file (it might be corrupted)
                     if (8+index+keysize >= size)
@@ -103,7 +103,7 @@ namespace Exiv2 {
 
                 DataBuf arr;
 
-                if(!strncmp((char*)PNG_CHUNK_TYPE(pData, index), "zTXt", 4)) 
+                if(!strncmp((char*)PNG_CHUNK_TYPE(pData, index), "zTXt", 4))
                 {
                     // Extract a deflate compressed Latin-1 text chunk
 
@@ -112,7 +112,7 @@ namespace Exiv2 {
 #endif
                     // we get the compression method after the key
                     const byte* compressionMethod = &PNG_CHUNK_DATA(pData, index, keysize+1);
-                    if ( *compressionMethod != 0x00 ) 
+                    if ( *compressionMethod != 0x00 )
                     {
                         // then it isn't zlib compressed and we are sunk
 #ifdef DEBUG
@@ -141,12 +141,12 @@ namespace Exiv2 {
                         zlibResult = uncompress((Bytef*)arr.pData_, &uncompressedLen,
                                                 compressedText, compressedTextSize);
 
-                        if (Z_OK == zlibResult) 
+                        if (Z_OK == zlibResult)
                         {
                             // then it is all OK
                             arr.alloc(uncompressedLen);
                         }
-                        else if (Z_BUF_ERROR == zlibResult) 
+                        else if (Z_BUF_ERROR == zlibResult)
                         {
                             // the uncompressedArray needs to be larger
 #ifdef DEBUG
@@ -158,18 +158,18 @@ namespace Exiv2 {
                             if ( uncompressedLen > 131072 )
                                 break;
                         }
-                        else 
+                        else
                         {
                             // something bad happened
                             throw Error(14);
                         }
-                    } 
+                    }
                     while (Z_BUF_ERROR == zlibResult);
 
                     if (zlibResult != Z_OK)
                         throw Error(14);
                 }
-                else if (!strncmp((char*)PNG_CHUNK_TYPE(pData, index), "tEXt", 4)) 
+                else if (!strncmp((char*)PNG_CHUNK_TYPE(pData, index), "tEXt", 4))
                 {
                     // Extract a non-compressed Latin-1 text chunk
 #ifdef DEBUG
@@ -201,7 +201,7 @@ namespace Exiv2 {
                 }
 
 #ifdef DEBUG
-                std::cerr << "Exiv2::PngChunk::decode: Found PNG entry " << std::string((const char*)key) << " / " 
+                std::cerr << "Exiv2::PngChunk::decode: Found PNG entry " << std::string((const char*)key) << " / "
                           << std::string((const char*)arr.pData_, 64) << "\n";
 #endif
 
@@ -237,7 +237,7 @@ namespace Exiv2 {
                             std::cerr << "Exiv2::PngChunk::decode: Exif header found at position " << pos << "\n";
 #endif
                             pos = pos + sizeof(exifHeader);
-                            TiffParser::decode(pImage, exifData.pData_ + pos, length - pos, 
+                            TiffParser::decode(pImage, exifData.pData_ + pos, length - pos,
                                                TiffCreator::create, TiffDecoder::findDecoder);
                         }
                     }
diff --git a/src/pngimage.cpp b/src/pngimage.cpp
index 029b5f98..2ef07b6f 100644
--- a/src/pngimage.cpp
+++ b/src/pngimage.cpp
@@ -60,7 +60,7 @@ namespace Exiv2 {
     PngImage::PngImage(BasicIo::AutoPtr io, bool create)
         : Image(mdExif | mdIptc), io_(io)
     {
-        if (create) 
+        if (create)
         {
             IoCloser closer(*io_);
             io_->open();
@@ -121,13 +121,13 @@ namespace Exiv2 {
 #ifdef DEBUG
         std::cerr << "Exiv2::PngImage::readMetadata: Reading PNG file " << io_->path() << "\n";
 #endif
-        if (io_->open() != 0) 
+        if (io_->open() != 0)
         {
             throw Error(9, io_->path(), strError());
         }
         IoCloser closer(*io_);
         // Ensure that this is the correct image type
-        if (!isThisType(*io_, false)) 
+        if (!isThisType(*io_, false))
         {
             if (io_->error() || io_->eof()) throw Error(14);
             throw Error(3, "PNG");
@@ -142,8 +142,8 @@ namespace Exiv2 {
             makes decisions what to do. It reads only one chunk at a time
             instead of the whole file.
 
-          - new class PngChunk, initialized with the memory of one chunk and 
-            has all the access methods required to determine the field, key, 
+          - new class PngChunk, initialized with the memory of one chunk and
+            has all the access methods required to determine the field, key,
             to access and decompress data etc.
         */
 
@@ -167,7 +167,7 @@ namespace Exiv2 {
     Image::AutoPtr newPngInstance(BasicIo::AutoPtr io, bool create)
     {
         Image::AutoPtr image(new PngImage(io, create));
-        if (!image->good()) 
+        if (!image->good())
         {
             image.reset();
         }
@@ -180,12 +180,12 @@ namespace Exiv2 {
         const unsigned char pngID[8] = { 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A };
         byte buf[len];
         iIo.read(buf, len);
-        if (iIo.error() || iIo.eof()) 
+        if (iIo.error() || iIo.eof())
         {
             return false;
         }
         int rc = memcmp(buf, pngID, 8);
-        if (!advance || rc != 0) 
+        if (!advance || rc != 0)
         {
             iIo.seek(-len, BasicIo::cur);
         }
diff --git a/src/sigmamn.cpp b/src/sigmamn.cpp
index 8317fb9c..5a7af6ca 100644
--- a/src/sigmamn.cpp
+++ b/src/sigmamn.cpp
@@ -63,77 +63,77 @@ namespace Exiv2 {
 
     // Sigma (Foveon) MakerNote Tag Info
     const TagInfo SigmaMakerNote::tagInfo_[] = {
-        TagInfo(0x0002, "SerialNumber", N_("Serial Number"), 
-                N_("Camera serial number"), 
+        TagInfo(0x0002, "SerialNumber", N_("Serial Number"),
+                N_("Camera serial number"),
                 sigmaIfdId, makerTags, asciiString, printValue),
-        TagInfo(0x0003, "DriveMode", N_("Drive Mode"), 
-                N_("Drive mode"), 
+        TagInfo(0x0003, "DriveMode", N_("Drive Mode"),
+                N_("Drive mode"),
                 sigmaIfdId, makerTags, asciiString, printValue),
-        TagInfo(0x0004, "ResolutionMode", N_("Resolution Mode"), 
+        TagInfo(0x0004, "ResolutionMode", N_("Resolution Mode"),
                 N_("Resolution mode"), sigmaIfdId, makerTags, asciiString, printValue),
-        TagInfo(0x0005, "AutofocusMode", N_("Autofocus Mode"), 
-                N_("Autofocus mode"), 
+        TagInfo(0x0005, "AutofocusMode", N_("Autofocus Mode"),
+                N_("Autofocus mode"),
                 sigmaIfdId, makerTags, asciiString, printValue),
-        TagInfo(0x0006, "FocusSetting", N_("Focus Setting"), 
-                N_("Focus setting"), 
+        TagInfo(0x0006, "FocusSetting", N_("Focus Setting"),
+                N_("Focus setting"),
                 sigmaIfdId, makerTags, asciiString, printValue),
-        TagInfo(0x0007, "WhiteBalance", N_("White Balance"), 
-                N_("White balance"), 
+        TagInfo(0x0007, "WhiteBalance", N_("White Balance"),
+                N_("White balance"),
                 sigmaIfdId, makerTags, asciiString, printValue),
-        TagInfo(0x0008, "ExposureMode", N_("Exposure Mode"), 
-                N_("Exposure mode"), 
+        TagInfo(0x0008, "ExposureMode", N_("Exposure Mode"),
+                N_("Exposure mode"),
                 sigmaIfdId, makerTags, asciiString, print0x0008),
-        TagInfo(0x0009, "MeteringMode", N_("Metering Mode"), 
-                N_("Metering mode"), 
+        TagInfo(0x0009, "MeteringMode", N_("Metering Mode"),
+                N_("Metering mode"),
                 sigmaIfdId, makerTags, asciiString, print0x0009),
-        TagInfo(0x000a, "LensRange", N_("Lens Range"), 
-                N_("Lens focal length range"), 
+        TagInfo(0x000a, "LensRange", N_("Lens Range"),
+                N_("Lens focal length range"),
                 sigmaIfdId, makerTags, asciiString, printValue),
-        TagInfo(0x000b, "ColorSpace", N_("Color Space"), 
-                N_("Color space"), 
+        TagInfo(0x000b, "ColorSpace", N_("Color Space"),
+                N_("Color space"),
                 sigmaIfdId, makerTags, asciiString, printValue),
-        TagInfo(0x000c, "Exposure", N_("Exposure"), 
-                N_("Exposure"), 
+        TagInfo(0x000c, "Exposure", N_("Exposure"),
+                N_("Exposure"),
                 sigmaIfdId, makerTags, asciiString, printStripLabel),
-        TagInfo(0x000d, "Contrast", N_("Contrast"), 
-                N_("Contrast"), 
+        TagInfo(0x000d, "Contrast", N_("Contrast"),
+                N_("Contrast"),
                 sigmaIfdId, makerTags, asciiString, printStripLabel),
-        TagInfo(0x000e, "Shadow", N_("Shadow"), 
-                N_("Shadow"), 
+        TagInfo(0x000e, "Shadow", N_("Shadow"),
+                N_("Shadow"),
                 sigmaIfdId, makerTags, asciiString, printStripLabel),
-        TagInfo(0x000f, "Highlight", N_("Highlight"), 
-                N_("Highlight"), 
+        TagInfo(0x000f, "Highlight", N_("Highlight"),
+                N_("Highlight"),
                 sigmaIfdId, makerTags, asciiString, printStripLabel),
-        TagInfo(0x0010, "Saturation", N_("Saturation"), 
-                N_("Saturation"), 
+        TagInfo(0x0010, "Saturation", N_("Saturation"),
+                N_("Saturation"),
                 sigmaIfdId, makerTags, asciiString, printStripLabel),
-        TagInfo(0x0011, "Sharpness", N_("Sharpness"), 
-                N_("Sharpness"), 
+        TagInfo(0x0011, "Sharpness", N_("Sharpness"),
+                N_("Sharpness"),
                 sigmaIfdId, makerTags, asciiString, printStripLabel),
-        TagInfo(0x0012, "FillLight", N_("Fill Light"), 
-                N_("X3 Fill light"), 
+        TagInfo(0x0012, "FillLight", N_("Fill Light"),
+                N_("X3 Fill light"),
                 sigmaIfdId, makerTags, asciiString, printStripLabel),
-        TagInfo(0x0014, "ColorAdjustment", N_("Color Adjustment"), 
-                N_("Color adjustment"), 
+        TagInfo(0x0014, "ColorAdjustment", N_("Color Adjustment"),
+                N_("Color adjustment"),
                 sigmaIfdId, makerTags, asciiString, printStripLabel),
-        TagInfo(0x0015, "AdjustmentMode", N_("Adjustment Mode"), 
-                N_("Adjustment mode"), 
+        TagInfo(0x0015, "AdjustmentMode", N_("Adjustment Mode"),
+                N_("Adjustment mode"),
                 sigmaIfdId, makerTags, asciiString, printValue),
-        TagInfo(0x0016, "Quality", N_("Quality"), 
-                N_("Quality"), 
+        TagInfo(0x0016, "Quality", N_("Quality"),
+                N_("Quality"),
                 sigmaIfdId, makerTags, asciiString, printStripLabel),
-        TagInfo(0x0017, "Firmware", N_("Firmware"), 
-                N_("Firmware"), 
+        TagInfo(0x0017, "Firmware", N_("Firmware"),
+                N_("Firmware"),
                 sigmaIfdId, makerTags, asciiString, printValue),
-        TagInfo(0x0018, "Software", N_("Software"), 
-                N_("Software"), 
+        TagInfo(0x0018, "Software", N_("Software"),
+                N_("Software"),
                 sigmaIfdId, makerTags, asciiString, printValue),
-        TagInfo(0x0019, "AutoBracket", N_("Auto Bracket"), 
-                N_("Auto bracket"), 
+        TagInfo(0x0019, "AutoBracket", N_("Auto Bracket"),
+                N_("Auto bracket"),
                 sigmaIfdId, makerTags, asciiString, printValue),
         // End of list marker
         TagInfo(0xffff, "(UnknownSigmaMakerNoteTag)", "(UnknownSigmaMakerNoteTag)",
-                N_("Unknown SigmaMakerNote tag"), 
+                N_("Unknown SigmaMakerNote tag"),
                 sigmaIfdId, makerTags, invalidTypeId, printValue)
     };
 
diff --git a/src/sonymn.cpp b/src/sonymn.cpp
index 7fa524df..1e8887fa 100644
--- a/src/sonymn.cpp
+++ b/src/sonymn.cpp
@@ -59,36 +59,36 @@ namespace Exiv2 {
 
     // Sony MakerNote Tag Info
     const TagInfo SonyMakerNote::tagInfo_[] = {
-        TagInfo(0x2000, "0x2000", "0x2000", 
-                N_("Unknown"), 
+        TagInfo(0x2000, "0x2000", "0x2000",
+                N_("Unknown"),
                 sonyIfdId, makerTags, undefined, printValue),
-        TagInfo(0x9001, "0x9001", "0x9001", 
+        TagInfo(0x9001, "0x9001", "0x9001",
                 N_("Unknown"),
                 sonyIfdId, makerTags, undefined, printValue),
-        TagInfo(0x9002, "0x9002", "0x9002", 
-                N_("Unknown"), 
+        TagInfo(0x9002, "0x9002", "0x9002",
+                N_("Unknown"),
                 sonyIfdId, makerTags, undefined, printValue),
-        TagInfo(0x9003, "0x9003", "0x9003", 
-                N_("Unknown"), 
+        TagInfo(0x9003, "0x9003", "0x9003",
+                N_("Unknown"),
                 sonyIfdId, makerTags, undefined, printValue),
-        TagInfo(0x9004, "0x9004", "0x9004", 
-                N_("Unknown"), 
+        TagInfo(0x9004, "0x9004", "0x9004",
+                N_("Unknown"),
                 sonyIfdId, makerTags, undefined, printValue),
-        TagInfo(0x9005, "0x9005", "0x9005", 
-                N_("Unknown"), 
+        TagInfo(0x9005, "0x9005", "0x9005",
+                N_("Unknown"),
                 sonyIfdId, makerTags, undefined, printValue),
-        TagInfo(0x9006, "0x9006", "0x9006", 
-                N_("Unknown"), 
+        TagInfo(0x9006, "0x9006", "0x9006",
+                N_("Unknown"),
                 sonyIfdId, makerTags, undefined, printValue),
-        TagInfo(0x9007, "0x9007", "0x9007", 
-                N_("Unknown"), 
+        TagInfo(0x9007, "0x9007", "0x9007",
+                N_("Unknown"),
                 sonyIfdId, makerTags, undefined, printValue),
-        TagInfo(0x9008, "0x9008", "0x9008", 
-                N_("Unknown"), 
+        TagInfo(0x9008, "0x9008", "0x9008",
+                N_("Unknown"),
                 sonyIfdId, makerTags, undefined, printValue),
         // End of list marker
-        TagInfo(0xffff, "(UnknownSonyMakerNoteTag)", "(UnknownSonyMakerNoteTag)", 
-                N_("Unknown SonyMakerNote tag"), 
+        TagInfo(0xffff, "(UnknownSonyMakerNoteTag)", "(UnknownSonyMakerNoteTag)",
+                N_("Unknown SonyMakerNote tag"),
                 sonyIfdId, makerTags, invalidTypeId, printValue)
     };
 
diff --git a/src/tags.cpp b/src/tags.cpp
index d133b2a6..736a5b63 100644
--- a/src/tags.cpp
+++ b/src/tags.cpp
@@ -225,7 +225,7 @@ namespace Exiv2 {
 
     //! Base IFD Tags (IFD0 and IFD1)
     static const TagInfo ifdTagInfo[] = {
-        TagInfo(0x00fe, "NewSubfileType", N_("New Subfile Type"), 
+        TagInfo(0x00fe, "NewSubfileType", N_("New Subfile Type"),
                 N_("A general indication of the kind of data contained in this subfile."),
                 ifd0Id, imgStruct, unsignedLong, EXV_PRINT_TAG(exifNewSubfileType)), // TIFF tag
         TagInfo(0x0100, "ImageWidth", N_("Image Width"),
@@ -249,15 +249,15 @@ namespace Exiv2 {
                 "not necessary and is omitted. When thumbnails use JPEG "
                 "compression, this tag value is set to 6."),
                 ifd0Id, imgStruct, unsignedShort, EXV_PRINT_TAG(exifCompression)),
-        TagInfo(0x0106, "PhotometricInterpretation", N_("Photometric Interpretation"), 
+        TagInfo(0x0106, "PhotometricInterpretation", N_("Photometric Interpretation"),
                 N_("The pixel composition. In JPEG compressed data a JPEG "
                 "marker is used instead of this tag."),
                 ifd0Id, imgStruct, unsignedShort, EXV_PRINT_TAG(exifPhotometricInterpretation)),
-        TagInfo(0x010a, "FillOrder", N_("Fill Order"), 
-                N_("The logical order of bits within a byte"), 
+        TagInfo(0x010a, "FillOrder", N_("Fill Order"),
+                N_("The logical order of bits within a byte"),
                 ifd0Id, imgStruct, unsignedShort, printValue), // TIFF tag
-        TagInfo(0x010d, "DocumentName", N_("Document Name"), 
-                N_("The name of the document from which this image was scanned"), 
+        TagInfo(0x010d, "DocumentName", N_("Document Name"),
+                N_("The name of the document from which this image was scanned"),
                 ifd0Id, imgStruct, asciiString, printValue), // TIFF tag
         TagInfo(0x010e, "ImageDescription", N_("Image Description"),
                 N_("A character string giving the title of the image. It may be "
@@ -332,7 +332,7 @@ namespace Exiv2 {
                 "firmware of the camera or image input device used to "
                 "generate the image. The detailed format is not specified, but "
                 "it is recommended that the example shown below be "
-                "followed. When the field is left blank, it is treated as unknown."), 
+                "followed. When the field is left blank, it is treated as unknown."),
                 ifd0Id, otherTags, asciiString, printValue),
         TagInfo(0x0132, "DateTime", N_("Date and Time"),
                 N_("The date and time of image creation. In Exif standard, "
@@ -420,10 +420,10 @@ namespace Exiv2 {
                 N_("Contains two values representing the minimum rows and columns "
                 "to define the repeating patterns of the color filter array"),
                 ifd0Id, otherTags, unsignedShort, printValue), // TIFF/EP Tag
-        TagInfo(0x828e, "CFAPattern", N_("CFA Pattern"), 
+        TagInfo(0x828e, "CFAPattern", N_("CFA Pattern"),
                 N_("Indicates the color filter array (CFA) geometric pattern of the image "
                 "sensor when a one-chip color area sensor is used. It does not apply to "
-                "all sensing methods"), 
+                "all sensing methods"),
                 ifd0Id, otherTags, unsignedByte, printValue), // TIFF/EP Tag
         TagInfo(0x828f, "BatteryLevel", N_("Battery Level"),
                 "Contains a value of the battery level as a fraction or string",
@@ -460,28 +460,28 @@ namespace Exiv2 {
                 "Interoperability structure of the GPS Info IFD, like that of "
                 "Exif IFD, has no image data."),
                 ifd0Id, exifFormat, unsignedLong, printValue),
-        TagInfo(0x9216, "TIFFEPStandardID", N_("TIFF/EP Standard ID"), 
+        TagInfo(0x9216, "TIFFEPStandardID", N_("TIFF/EP Standard ID"),
                 N_("Contains four ASCII characters representing the TIFF/EP standard "
-                "version of a TIFF/EP file, eg '1', '0', '0', '0'"), 
+                "version of a TIFF/EP file, eg '1', '0', '0', '0'"),
                 ifd0Id, otherTags, unsignedByte, printValue), // TIFF/EP Tag
         TagInfo(0x9c9b, "XPTitle", N_("Windows Title"),
-                N_("Title tag used by Windows, encoded in UCS2"), 
+                N_("Title tag used by Windows, encoded in UCS2"),
                 ifd0Id, otherTags, unsignedByte, printUcs2), // Windows Tag
-        TagInfo(0x9c9c, "XPComment", N_("Windows Comment"), 
-                N_("Comment tag used by Windows, encoded in UCS2"), 
+        TagInfo(0x9c9c, "XPComment", N_("Windows Comment"),
+                N_("Comment tag used by Windows, encoded in UCS2"),
                 ifd0Id, otherTags, unsignedByte, printUcs2), // Windows Tag
-        TagInfo(0x9c9d, "XPAuthor", N_("Windows Author"), 
+        TagInfo(0x9c9d, "XPAuthor", N_("Windows Author"),
                 N_("Author tag used by Windows, encoded in UCS2"),
                 ifd0Id, otherTags, unsignedByte, printUcs2), // Windows Tag
-        TagInfo(0x9c9e, "XPKeywords", N_("Windows Keywords"), 
+        TagInfo(0x9c9e, "XPKeywords", N_("Windows Keywords"),
                 N_("Keywords tag used by Windows, encoded in UCS2"),
                 ifd0Id, otherTags, unsignedByte, printUcs2), // Windows Tag
-        TagInfo(0x9c9f, "XPSubject", N_("Windows Subject"), 
+        TagInfo(0x9c9f, "XPSubject", N_("Windows Subject"),
                 N_("Subject tag used by Windows, encoded in UCS2"),
                 ifd0Id, otherTags, unsignedByte, printUcs2), // Windows Tag
         // End of list marker
         TagInfo(0xffff, "(UnknownIfdTag)", N_("Unknown IFD tag"),
-                N_("Unknown IFD tag"), 
+                N_("Unknown IFD tag"),
                 ifdIdNotSet, sectionIdNotSet, invalidTypeId, printValue)
     };
 
@@ -586,7 +586,7 @@ namespace Exiv2 {
 
     //! FileSource, tag 0xa300
     extern const TagDetails exifFileSource[] = {
-        { 1, N_("Film scanner")            },	// Not defined to Exif 2.2 spec. 
+        { 1, N_("Film scanner")            },	// Not defined to Exif 2.2 spec.
         { 2, N_("Reflexion print scanner") },	// but used by some scanner device softwares.
         { 3, N_("Digital still camera")    }
     };
@@ -663,42 +663,42 @@ namespace Exiv2 {
 
     // Exif IFD Tags
     static const TagInfo exifTagInfo[] = {
-        TagInfo(0x829a, "ExposureTime", N_("Exposure Time"), 
-                N_("Exposure time, given in seconds (sec)."), 
+        TagInfo(0x829a, "ExposureTime", N_("Exposure Time"),
+                N_("Exposure time, given in seconds (sec)."),
                 exifIfdId, captureCond, unsignedRational, print0x829a),
-        TagInfo(0x829d, "FNumber", N_("FNumber"), 
-                N_("The F number."), 
+        TagInfo(0x829d, "FNumber", N_("FNumber"),
+                N_("The F number."),
                 exifIfdId, captureCond, unsignedRational, print0x829d),
-        TagInfo(0x8822, "ExposureProgram", N_("Exposure Program"), 
+        TagInfo(0x8822, "ExposureProgram", N_("Exposure Program"),
                 N_("The class of the program used by the camera to set exposure "
-                "when the picture is taken."), 
+                "when the picture is taken."),
                 exifIfdId, captureCond, unsignedShort, EXV_PRINT_TAG(exifExposureProgram)),
-        TagInfo(0x8824, "SpectralSensitivity", N_("Spectral Sensitivity"), 
+        TagInfo(0x8824, "SpectralSensitivity", N_("Spectral Sensitivity"),
                 N_("Indicates the spectral sensitivity of each channel of the "
                 "camera used. The tag value is an ASCII string compatible "
-                "with the standard developed by the ASTM Technical Committee."), 
+                "with the standard developed by the ASTM Technical Committee."),
                 exifIfdId, captureCond, asciiString, printValue),
-        TagInfo(0x8827, "ISOSpeedRatings", N_("ISO Speed Ratings"), 
+        TagInfo(0x8827, "ISOSpeedRatings", N_("ISO Speed Ratings"),
                 N_("Indicates the ISO Speed and ISO Latitude of the camera or "
-                "input device as specified in ISO 12232."), 
+                "input device as specified in ISO 12232."),
                 exifIfdId, captureCond, unsignedShort, print0x8827),
-        TagInfo(0x8828, "OECF", N_("Opto-Electoric Conversion Function"), 
+        TagInfo(0x8828, "OECF", N_("Opto-Electoric Conversion Function"),
                 N_("Indicates the Opto-Electoric Conversion Function (OECF) "
                 "specified in ISO 14524. <OECF> is the relationship between "
-                "the camera optical input and the image values."), 
+                "the camera optical input and the image values."),
                 exifIfdId, captureCond, undefined, printValue),
-        TagInfo(0x9000, "ExifVersion", N_("Exif Version"), 
+        TagInfo(0x9000, "ExifVersion", N_("Exif Version"),
                 N_("The version of this standard supported. Nonexistence of this "
-                "field is taken to mean nonconformance to the standard."), 
+                "field is taken to mean nonconformance to the standard."),
                 exifIfdId, exifVersion, undefined, printValue),
-        TagInfo(0x9003, "DateTimeOriginal", N_("Date and Time (original)"), 
+        TagInfo(0x9003, "DateTimeOriginal", N_("Date and Time (original)"),
                 N_("The date and time when the original image data was generated. "
-                "For a digital still camera the date and time the picture was taken are recorded."), 
+                "For a digital still camera the date and time the picture was taken are recorded."),
                 exifIfdId, dateTime, asciiString, printValue),
-        TagInfo(0x9004, "DateTimeDigitized", N_("Date and Time (digitized)"), 
-                N_("The date and time when the image was stored as digital data."), 
+        TagInfo(0x9004, "DateTimeDigitized", N_("Date and Time (digitized)"),
+                N_("The date and time when the image was stored as digital data."),
                 exifIfdId, dateTime, asciiString, printValue),
-        TagInfo(0x9101, "ComponentsConfiguration", N_("Components Configuration"), 
+        TagInfo(0x9101, "ComponentsConfiguration", N_("Components Configuration"),
                 N_("Information specific to compressed data. The channels of "
                 "each component are arranged in order from the 1st "
                 "component to the 4th. For uncompressed data the data "
@@ -706,224 +706,224 @@ namespace Exiv2 {
                 "However, since <PhotometricInterpretation> can only "
                 "express the order of Y, Cb and Cr, this tag is provided "
                 "for cases when compressed data uses components other than "
-                "Y, Cb, and Cr and to enable support of other sequences."), 
+                "Y, Cb, and Cr and to enable support of other sequences."),
                 exifIfdId, imgConfig, undefined, print0x9101),
-        TagInfo(0x9102, "CompressedBitsPerPixel", N_("Compressed Bits per Pixel"), 
+        TagInfo(0x9102, "CompressedBitsPerPixel", N_("Compressed Bits per Pixel"),
                 N_("Information specific to compressed data. The compression mode "
-                "used for a compressed image is indicated in unit bits per pixel."), 
+                "used for a compressed image is indicated in unit bits per pixel."),
                 exifIfdId, imgConfig, unsignedRational, printFloat),
-        TagInfo(0x9201, "ShutterSpeedValue", N_("Shutter speed"), 
+        TagInfo(0x9201, "ShutterSpeedValue", N_("Shutter speed"),
                 N_("Shutter speed. The unit is the APEX (Additive System of "
-                "Photographic Exposure) setting."), 
+                "Photographic Exposure) setting."),
                 exifIfdId, captureCond, signedRational, print0x9201),
-        TagInfo(0x9202, "ApertureValue", N_("Aperture"), 
-                N_("The lens aperture. The unit is the APEX value."), 
+        TagInfo(0x9202, "ApertureValue", N_("Aperture"),
+                N_("The lens aperture. The unit is the APEX value."),
                 exifIfdId, captureCond, unsignedRational, print0x9202),
-        TagInfo(0x9203, "BrightnessValue", N_("Brightness"), 
+        TagInfo(0x9203, "BrightnessValue", N_("Brightness"),
                 N_("The value of brightness. The unit is the APEX value. "
-                "Ordinarily it is given in the range of -99.99 to 99.99."), 
+                "Ordinarily it is given in the range of -99.99 to 99.99."),
                 exifIfdId, captureCond, signedRational, printFloat),
-        TagInfo(0x9204, "ExposureBiasValue", N_("Exposure Bias"), 
+        TagInfo(0x9204, "ExposureBiasValue", N_("Exposure Bias"),
                 N_("The exposure bias. The units is the APEX value. Ordinarily "
-                "it is given in the range of -99.99 to 99.99."), 
+                "it is given in the range of -99.99 to 99.99."),
                 exifIfdId, captureCond, signedRational, print0x9204),
-        TagInfo(0x9205, "MaxApertureValue", N_("Max Aperture Value"), 
+        TagInfo(0x9205, "MaxApertureValue", N_("Max Aperture Value"),
                 N_("The smallest F number of the lens. The unit is the APEX value. "
                 "Ordinarily it is given in the range of 00.00 to 99.99, "
-                "but it is not limited to this range."), 
+                "but it is not limited to this range."),
                 exifIfdId, captureCond, unsignedRational, print0x9202),
-        TagInfo(0x9206, "SubjectDistance", N_("Subject Distance"), 
-                N_("The distance to the subject, given in meters."), 
+        TagInfo(0x9206, "SubjectDistance", N_("Subject Distance"),
+                N_("The distance to the subject, given in meters."),
                 exifIfdId, captureCond, unsignedRational, print0x9206),
-        TagInfo(0x9207, "MeteringMode", N_("Metering Mode"), 
-                N_("The metering mode."), 
+        TagInfo(0x9207, "MeteringMode", N_("Metering Mode"),
+                N_("The metering mode."),
                 exifIfdId, captureCond, unsignedShort, EXV_PRINT_TAG(exifMeteringMode)),
-        TagInfo(0x9208, "LightSource", N_("Light Source"), 
-                N_("The kind of light source."), 
+        TagInfo(0x9208, "LightSource", N_("Light Source"),
+                N_("The kind of light source."),
                 exifIfdId, captureCond, unsignedShort, EXV_PRINT_TAG(exifLightSource)),
-        TagInfo(0x9209, "Flash", N_("Flash"), 
-                N_("This tag is recorded when an image is taken using a strobe light (flash)."), 
+        TagInfo(0x9209, "Flash", N_("Flash"),
+                N_("This tag is recorded when an image is taken using a strobe light (flash)."),
                 exifIfdId, captureCond, unsignedShort, EXV_PRINT_TAG(exifFlash)),
-        TagInfo(0x920a, "FocalLength", N_("Focal Length"), 
+        TagInfo(0x920a, "FocalLength", N_("Focal Length"),
                 N_("The actual focal length of the lens, in mm. Conversion is not "
-                "made to the focal length of a 35 mm film camera."), 
+                "made to the focal length of a 35 mm film camera."),
                 exifIfdId, captureCond, unsignedRational, print0x920a),
-        TagInfo(0x9214, "SubjectArea", N_("Subject Area"), 
+        TagInfo(0x9214, "SubjectArea", N_("Subject Area"),
                 N_("This tag indicates the location and area of the main subject "
-                "in the overall scene."), 
+                "in the overall scene."),
                 exifIfdId, captureCond, unsignedShort, printValue),
-        TagInfo(0x927c, "MakerNote", N_("Maker Note"), 
+        TagInfo(0x927c, "MakerNote", N_("Maker Note"),
                 N_("A tag for manufacturers of Exif writers to record any desired "
-                "information. The contents are up to the manufacturer."), 
+                "information. The contents are up to the manufacturer."),
                 exifIfdId, userInfo, undefined, printValue),
-        TagInfo(0x9286, "UserComment", N_("User Comment"), 
+        TagInfo(0x9286, "UserComment", N_("User Comment"),
                 N_("A tag for Exif users to write keywords or comments on the image "
                 "besides those in <ImageDescription>, and without the "
-                "character code limitations of the <ImageDescription> tag."), 
+                "character code limitations of the <ImageDescription> tag."),
                 exifIfdId, userInfo, comment, print0x9286),
-        TagInfo(0x9290, "SubSecTime", N_("Sub-seconds Time"), 
-                N_("A tag used to record fractions of seconds for the <DateTime> tag."), 
+        TagInfo(0x9290, "SubSecTime", N_("Sub-seconds Time"),
+                N_("A tag used to record fractions of seconds for the <DateTime> tag."),
                 exifIfdId, dateTime, asciiString, printValue),
-        TagInfo(0x9291, "SubSecTimeOriginal", N_("Sub-seconds Time Original"), 
-                N_("A tag used to record fractions of seconds for the <DateTimeOriginal> tag."), 
+        TagInfo(0x9291, "SubSecTimeOriginal", N_("Sub-seconds Time Original"),
+                N_("A tag used to record fractions of seconds for the <DateTimeOriginal> tag."),
                 exifIfdId, dateTime, asciiString, printValue),
-        TagInfo(0x9292, "SubSecTimeDigitized", N_("Sub-seconds Time Digitized"), 
-                N_("A tag used to record fractions of seconds for the <DateTimeDigitized> tag."), 
+        TagInfo(0x9292, "SubSecTimeDigitized", N_("Sub-seconds Time Digitized"),
+                N_("A tag used to record fractions of seconds for the <DateTimeDigitized> tag."),
                 exifIfdId, dateTime, asciiString, printValue),
-        TagInfo(0xa000, "FlashpixVersion", N_("FlashPix Version"), 
-                N_("The FlashPix format version supported by a FPXR file."), 
+        TagInfo(0xa000, "FlashpixVersion", N_("FlashPix Version"),
+                N_("The FlashPix format version supported by a FPXR file."),
                 exifIfdId, exifVersion, undefined, printValue),
-        TagInfo(0xa001, "ColorSpace", N_("Color Space"), 
+        TagInfo(0xa001, "ColorSpace", N_("Color Space"),
                 N_("The color space information tag is always "
                 "recorded as the color space specifier. Normally sRGB "
                 "is used to define the color space based on the PC monitor "
                 "conditions and environment. If a color space other than "
                 "sRGB is used, Uncalibrated is set. Image data "
                 "recorded as Uncalibrated can be treated as sRGB when it is "
-                "converted to FlashPix."), 
+                "converted to FlashPix."),
                 exifIfdId, imgCharacter, unsignedShort, EXV_PRINT_TAG(exifColorSpace)),
-        TagInfo(0xa002, "PixelXDimension", N_("Pixel X Dimension"), 
+        TagInfo(0xa002, "PixelXDimension", N_("Pixel X Dimension"),
                 N_("Information specific to compressed data. When a "
                 "compressed file is recorded, the valid width of the "
                 "meaningful image must be recorded in this tag, whether or "
                 "not there is padding data or a restart marker. This tag "
-                "should not exist in an uncompressed file."), 
+                "should not exist in an uncompressed file."),
                 exifIfdId, imgConfig, unsignedLong, printValue),
-        TagInfo(0xa003, "PixelYDimension", N_("Pixel Y Dimension"), 
+        TagInfo(0xa003, "PixelYDimension", N_("Pixel Y Dimension"),
                 N_("Information specific to compressed data. When a compressed "
                 "file is recorded, the valid height of the meaningful image "
                 "must be recorded in this tag, whether or not there is padding "
                 "data or a restart marker. This tag should not exist in an "
                 "uncompressed file. Since data padding is unnecessary in the vertical "
                 "direction, the number of lines recorded in this valid image height tag "
-	        "will in fact be the same as that recorded in the SOF."), 
+	        "will in fact be the same as that recorded in the SOF."),
                 exifIfdId, imgConfig, unsignedLong, printValue),
-        TagInfo(0xa004, "RelatedSoundFile", N_("Related Sound File"), 
+        TagInfo(0xa004, "RelatedSoundFile", N_("Related Sound File"),
                 N_("This tag is used to record the name of an audio file related "
                 "to the image data. The only relational information "
                 "recorded here is the Exif audio file name and extension (an "
                 "ASCII string consisting of 8 characters + '.' + 3 "
                 "characters). The path is not recorded."),
                 exifIfdId, relatedFile, asciiString, printValue),
-        TagInfo(0xa005, "InteroperabilityTag", N_("Interoperability IFD Pointer"), 
+        TagInfo(0xa005, "InteroperabilityTag", N_("Interoperability IFD Pointer"),
                 N_("Interoperability IFD is composed of tags which stores the "
                 "information to ensure the Interoperability and pointed "
                 "by the following tag located in Exif IFD. "
                 "The Interoperability structure of Interoperability IFD is "
                 "the same as TIFF defined IFD structure but does not contain the "
-                "image data characteristically compared with normal TIFF IFD."), 
+                "image data characteristically compared with normal TIFF IFD."),
                 exifIfdId, exifFormat, unsignedLong, printValue),
-        TagInfo(0xa20b, "FlashEnergy", N_("Flash Energy"), 
+        TagInfo(0xa20b, "FlashEnergy", N_("Flash Energy"),
                 N_("Indicates the strobe energy at the time the image is "
-                "captured, as measured in Beam Candle Power Seconds (BCPS)."), 
+                "captured, as measured in Beam Candle Power Seconds (BCPS)."),
                 exifIfdId, captureCond, unsignedRational, printValue),
-        TagInfo(0xa20c, "SpatialFrequencyResponse", N_("Spatial Frequency Response"), 
+        TagInfo(0xa20c, "SpatialFrequencyResponse", N_("Spatial Frequency Response"),
                 N_("This tag records the camera or input device spatial frequency "
                 "table and SFR values in the direction of image width, "
-                "image height, and diagonal direction, as specified in ISO 12233."), 
+                "image height, and diagonal direction, as specified in ISO 12233."),
                 exifIfdId, captureCond, undefined, printValue),
-        TagInfo(0xa20e, "FocalPlaneXResolution", N_("Focal Plane X-Resolution"), 
+        TagInfo(0xa20e, "FocalPlaneXResolution", N_("Focal Plane X-Resolution"),
                 N_("Indicates the number of pixels in the image width (X) direction "
-                "per <FocalPlaneResolutionUnit> on the camera focal plane."), 
+                "per <FocalPlaneResolutionUnit> on the camera focal plane."),
                 exifIfdId, captureCond, unsignedRational, printFloat),
-        TagInfo(0xa20f, "FocalPlaneYResolution", N_("Focal Plane Y-Resolution"), 
+        TagInfo(0xa20f, "FocalPlaneYResolution", N_("Focal Plane Y-Resolution"),
                 N_("Indicates the number of pixels in the image height (V) direction "
-                "per <FocalPlaneResolutionUnit> on the camera focal plane."), 
+                "per <FocalPlaneResolutionUnit> on the camera focal plane."),
                 exifIfdId, captureCond, unsignedRational, printFloat),
-        TagInfo(0xa210, "FocalPlaneResolutionUnit", N_("Focal Plane Resolution Unit"), 
+        TagInfo(0xa210, "FocalPlaneResolutionUnit", N_("Focal Plane Resolution Unit"),
                 N_("Indicates the unit for measuring <FocalPlaneXResolution> and "
-                "<FocalPlaneYResolution>. This value is the same as the <ResolutionUnit>."), 
+                "<FocalPlaneYResolution>. This value is the same as the <ResolutionUnit>."),
                 exifIfdId, captureCond, unsignedShort, EXV_PRINT_TAG(exifUnit)),
-        TagInfo(0xa214, "SubjectLocation", N_("Subject Location"), 
+        TagInfo(0xa214, "SubjectLocation", N_("Subject Location"),
                 N_("Indicates the location of the main subject in the scene. The "
                 "value of this tag represents the pixel at the center of the "
                 "main subject relative to the left edge, prior to rotation "
                 "processing as per the <Rotation> tag. The first value "
-                "indicates the X column number and second indicates the Y row number."), 
+                "indicates the X column number and second indicates the Y row number."),
                 exifIfdId, captureCond, unsignedShort, printValue),
-        TagInfo(0xa215, "ExposureIndex", N_("Exposure index"), 
+        TagInfo(0xa215, "ExposureIndex", N_("Exposure index"),
                 N_("Indicates the exposure index selected on the camera or "
-                "input device at the time the image is captured."), 
+                "input device at the time the image is captured."),
                 exifIfdId, captureCond, unsignedRational, printValue),
-        TagInfo(0xa217, "SensingMethod", N_("Sensing Method"), 
-                N_("Indicates the image sensor type on the camera or input device."), 
+        TagInfo(0xa217, "SensingMethod", N_("Sensing Method"),
+                N_("Indicates the image sensor type on the camera or input device."),
                 exifIfdId, captureCond, unsignedShort, EXV_PRINT_TAG(exifSensingMethod)),
-        TagInfo(0xa300, "FileSource", N_("File Source"), 
+        TagInfo(0xa300, "FileSource", N_("File Source"),
                 N_("Indicates the image source. If a DSC recorded the image, "
                 "this tag value of this tag always be set to 3, indicating "
-                "that the image was recorded on a DSC."), 
+                "that the image was recorded on a DSC."),
                 exifIfdId, captureCond, undefined, EXV_PRINT_TAG(exifFileSource)),
-        TagInfo(0xa301, "SceneType", N_("Scene Type"), 
+        TagInfo(0xa301, "SceneType", N_("Scene Type"),
                 N_("Indicates the type of scene. If a DSC recorded the image, "
                 "this tag value must always be set to 1, indicating that the "
-                "image was directly photographed."), 
+                "image was directly photographed."),
                 exifIfdId, captureCond, undefined, EXV_PRINT_TAG(exifSceneType)),
-        TagInfo(0xa302, "CFAPattern", N_("Color Filter Array Pattern"), 
+        TagInfo(0xa302, "CFAPattern", N_("Color Filter Array Pattern"),
                 N_("Indicates the color filter array (CFA) geometric pattern of the "
                 "image sensor when a one-chip color area sensor is used. "
-                "It does not apply to all sensing methods."), 
+                "It does not apply to all sensing methods."),
                 exifIfdId, captureCond, undefined, printValue),
-        TagInfo(0xa401, "CustomRendered", N_("Custom Rendered"), 
+        TagInfo(0xa401, "CustomRendered", N_("Custom Rendered"),
                 N_("This tag indicates the use of special processing on image "
                 "data, such as rendering geared to output. When special "
                 "processing is performed, the reader is expected to disable "
-                "or minimize any further processing."), 
+                "or minimize any further processing."),
                 exifIfdId, captureCond, unsignedShort, EXV_PRINT_TAG(exifCustomRendered)),
-        TagInfo(0xa402, "ExposureMode", N_("Exposure Mode"), 
+        TagInfo(0xa402, "ExposureMode", N_("Exposure Mode"),
                 N_("This tag indicates the exposure mode set when the image was "
                 "shot. In auto-bracketing mode, the camera shoots a series of "
-                "frames of the same scene at different exposure settings."), 
+                "frames of the same scene at different exposure settings."),
                 exifIfdId, captureCond, unsignedShort, EXV_PRINT_TAG(exifExposureMode)),
-        TagInfo(0xa403, "WhiteBalance", N_("White Balance"), 
-                N_("This tag indicates the white balance mode set when the image was shot."), 
+        TagInfo(0xa403, "WhiteBalance", N_("White Balance"),
+                N_("This tag indicates the white balance mode set when the image was shot."),
                 exifIfdId, captureCond, unsignedShort, EXV_PRINT_TAG(exifWhiteBalance)),
-        TagInfo(0xa404, "DigitalZoomRatio", N_("Digital Zoom Ratio"), 
+        TagInfo(0xa404, "DigitalZoomRatio", N_("Digital Zoom Ratio"),
                 N_("This tag indicates the digital zoom ratio when the image was "
                 "shot. If the numerator of the recorded value is 0, this "
-                "indicates that digital zoom was not used."), 
+                "indicates that digital zoom was not used."),
                 exifIfdId, captureCond, unsignedRational, print0xa404),
-        TagInfo(0xa405, "FocalLengthIn35mmFilm", N_("Focal Length In 35mm Film"), 
+        TagInfo(0xa405, "FocalLengthIn35mmFilm", N_("Focal Length In 35mm Film"),
                 N_("This tag indicates the equivalent focal length assuming a "
                 "35mm film camera, in mm. A value of 0 means the focal "
                 "length is unknown. Note that this tag differs from the "
-                "<FocalLength> tag."), 
+                "<FocalLength> tag."),
                 exifIfdId, captureCond, unsignedShort, print0xa405),
-        TagInfo(0xa406, "SceneCaptureType", N_("Scene Capture Type"), 
+        TagInfo(0xa406, "SceneCaptureType", N_("Scene Capture Type"),
                 N_("This tag indicates the type of scene that was shot. It can "
                 "also be used to record the mode in which the image was "
-                "shot. Note that this differs from the <SceneType> tag."), 
+                "shot. Note that this differs from the <SceneType> tag."),
                 exifIfdId, captureCond, unsignedShort, EXV_PRINT_TAG(exifSceneCaptureType)),
-        TagInfo(0xa407, "GainControl", N_("Gain Control"), 
-                N_("This tag indicates the degree of overall image gain adjustment."), 
+        TagInfo(0xa407, "GainControl", N_("Gain Control"),
+                N_("This tag indicates the degree of overall image gain adjustment."),
                 exifIfdId, captureCond, unsignedShort, EXV_PRINT_TAG(exifGainControl)),
-        TagInfo(0xa408, "Contrast", N_("Contrast"), 
+        TagInfo(0xa408, "Contrast", N_("Contrast"),
                 N_("This tag indicates the direction of contrast processing "
-                "applied by the camera when the image was shot."), 
+                "applied by the camera when the image was shot."),
                 exifIfdId, captureCond, unsignedShort, EXV_PRINT_TAG(exifContrast)),
-        TagInfo(0xa409, "Saturation", N_("Saturation"), 
+        TagInfo(0xa409, "Saturation", N_("Saturation"),
                 N_("This tag indicates the direction of saturation processing "
-                "applied by the camera when the image was shot."), 
+                "applied by the camera when the image was shot."),
                 exifIfdId, captureCond, unsignedShort, EXV_PRINT_TAG(exifSaturation)),
-        TagInfo(0xa40a, "Sharpness", N_("Sharpness"), 
+        TagInfo(0xa40a, "Sharpness", N_("Sharpness"),
                 N_("This tag indicates the direction of sharpness processing "
-                "applied by the camera when the image was shot."), 
+                "applied by the camera when the image was shot."),
                 exifIfdId, captureCond, unsignedShort, EXV_PRINT_TAG(exifSharpness)),
-        TagInfo(0xa40b, "DeviceSettingDescription", N_("Device Setting Description"), 
+        TagInfo(0xa40b, "DeviceSettingDescription", N_("Device Setting Description"),
                 N_("This tag indicates information on the picture-taking "
                 "conditions of a particular camera model. The tag is used "
-                "only to indicate the picture-taking conditions in the reader."), 
+                "only to indicate the picture-taking conditions in the reader."),
                 exifIfdId, captureCond, undefined, printValue),
-        TagInfo(0xa40c, "SubjectDistanceRange", N_("Subject Distance Range"), 
-                N_("This tag indicates the distance to the subject."), 
+        TagInfo(0xa40c, "SubjectDistanceRange", N_("Subject Distance Range"),
+                N_("This tag indicates the distance to the subject."),
                 exifIfdId, captureCond, unsignedShort, EXV_PRINT_TAG(exifSubjectDistanceRange)),
-        TagInfo(0xa420, "ImageUniqueID", N_("Image Unique ID"), 
+        TagInfo(0xa420, "ImageUniqueID", N_("Image Unique ID"),
                 N_("This tag indicates an identifier assigned uniquely to "
                 "each image. It is recorded as an ASCII string equivalent "
-                "to hexadecimal notation and 128-bit fixed length."), 
+                "to hexadecimal notation and 128-bit fixed length."),
                 exifIfdId, otherTags, asciiString, printValue),
         // End of list marker
-        TagInfo(0xffff, "(UnknownExifTag)", N_("Unknown Exif tag"), 
-                N_("Unknown Exif tag"), 
+        TagInfo(0xffff, "(UnknownExifTag)", N_("Unknown Exif tag"),
+                N_("Unknown Exif tag"),
                 ifdIdNotSet, sectionIdNotSet, invalidTypeId, printValue)
     };
 
@@ -959,158 +959,158 @@ namespace Exiv2 {
 
     // GPS Info Tags
     static const TagInfo gpsTagInfo[] = {
-        TagInfo(0x0000, "GPSVersionID", N_("GPS Version ID"), 
+        TagInfo(0x0000, "GPSVersionID", N_("GPS Version ID"),
                 N_("Indicates the version of <GPSInfoIFD>. The version is given "
                 "as 2.0.0.0. This tag is mandatory when <GPSInfo> tag is "
                 "present. (Note: The <GPSVersionID> tag is given in bytes, "
                 "unlike the <ExifVersion> tag. When the version is "
-                "2.0.0.0, the tag value is 02000000.H)."), 
+                "2.0.0.0, the tag value is 02000000.H)."),
                 gpsIfdId, gpsTags, unsignedByte, printValue),
-        TagInfo(0x0001, "GPSLatitudeRef", N_("GPS Latitude Reference"), 
+        TagInfo(0x0001, "GPSLatitudeRef", N_("GPS Latitude Reference"),
                 N_("Indicates whether the latitude is north or south latitude. The "
-                "ASCII value 'N' indicates north latitude, and 'S' is south latitude."), 
+                "ASCII value 'N' indicates north latitude, and 'S' is south latitude."),
                 gpsIfdId, gpsTags, asciiString, EXV_PRINT_TAG(exifGPSLatitudeRef)),
-        TagInfo(0x0002, "GPSLatitude", N_("GPS Latitude"), 
+        TagInfo(0x0002, "GPSLatitude", N_("GPS Latitude"),
                 N_("Indicates the latitude. The latitude is expressed as three "
                 "RATIONAL values giving the degrees, minutes, and seconds, "
                 "respectively. When degrees, minutes and seconds are expressed, "
                 "the format is dd/1,mm/1,ss/1. When degrees and minutes are used "
                 "and, for example, fractions of minutes are given up to two "
-                "decimal places, the format is dd/1,mmmm/100,0/1."), 
+                "decimal places, the format is dd/1,mmmm/100,0/1."),
                 gpsIfdId, gpsTags, unsignedRational, printDegrees),
-        TagInfo(0x0003, "GPSLongitudeRef", N_("GPS Longitude Reference"), 
+        TagInfo(0x0003, "GPSLongitudeRef", N_("GPS Longitude Reference"),
                 N_("Indicates whether the longitude is east or west longitude. "
-                "ASCII 'E' indicates east longitude, and 'W' is west longitude."), 
+                "ASCII 'E' indicates east longitude, and 'W' is west longitude."),
                 gpsIfdId, gpsTags, asciiString, EXV_PRINT_TAG(exifGPSLongitudeRef)),
-        TagInfo(0x0004, "GPSLongitude", N_("GPS Longitude"), 
+        TagInfo(0x0004, "GPSLongitude", N_("GPS Longitude"),
                 N_("Indicates the longitude. The longitude is expressed as three "
                 "RATIONAL values giving the degrees, minutes, and seconds, "
                 "respectively. When degrees, minutes and seconds are expressed, "
                 "the format is ddd/1,mm/1,ss/1. When degrees and minutes are "
                 "used and, for example, fractions of minutes are given up to "
-                "two decimal places, the format is ddd/1,mmmm/100,0/1."), 
+                "two decimal places, the format is ddd/1,mmmm/100,0/1."),
                 gpsIfdId, gpsTags, unsignedRational, printDegrees),
-        TagInfo(0x0005, "GPSAltitudeRef", N_("GPS Altitude Reference"), 
+        TagInfo(0x0005, "GPSAltitudeRef", N_("GPS Altitude Reference"),
                 N_("Indicates the altitude used as the reference altitude. If the "
                 "reference is sea level and the altitude is above sea level, 0 "
                 "is given. If the altitude is below sea level, a value of 1 is given "
                 "and the altitude is indicated as an absolute value in the "
                 "GSPAltitude tag. The reference unit is meters. Note that this tag "
-                "is BYTE type, unlike other reference tags."), 
+                "is BYTE type, unlike other reference tags."),
                 gpsIfdId, gpsTags, unsignedByte, EXV_PRINT_TAG(exifGPSAltitudeRef)),
-        TagInfo(0x0006, "GPSAltitude", N_("GPS Altitude"), 
+        TagInfo(0x0006, "GPSAltitude", N_("GPS Altitude"),
                 N_("Indicates the altitude based on the reference in GPSAltitudeRef. "
-                "Altitude is expressed as one RATIONAL value. The reference unit is meters."), 
+                "Altitude is expressed as one RATIONAL value. The reference unit is meters."),
                 gpsIfdId, gpsTags, unsignedRational, print0x0006),
-        TagInfo(0x0007, "GPSTimeStamp", N_("GPS Time Stamp"), 
+        TagInfo(0x0007, "GPSTimeStamp", N_("GPS Time Stamp"),
                 N_("Indicates the time as UTC (Coordinated Universal Time). "
                 "<TimeStamp> is expressed as three RATIONAL values "
-                "giving the hour, minute, and second (atomic clock)."), 
+                "giving the hour, minute, and second (atomic clock)."),
                 gpsIfdId, gpsTags, unsignedRational, print0x0007),
-        TagInfo(0x0008, "GPSSatellites", N_("GPS Satellites"), 
+        TagInfo(0x0008, "GPSSatellites", N_("GPS Satellites"),
                 N_("Indicates the GPS satellites used for measurements. This tag can be used "
                 "to describe the number of satellites, their ID number, angle of elevation, "
                 "azimuth, SNR and other information in ASCII notation. The format is not "
                 "specified. If the GPS receiver is incapable of taking measurements, value "
-                "of the tag is set to NULL."), 
+                "of the tag is set to NULL."),
                 gpsIfdId, gpsTags, asciiString, printValue),
-        TagInfo(0x0009, "GPSStatus", N_("GPS Status"), 
+        TagInfo(0x0009, "GPSStatus", N_("GPS Status"),
                 N_("Indicates the status of the GPS receiver when the image is recorded. "
                 "\"A\" means measurement is in progress, and \"V\" means the measurement "
-                "is Interoperability."), 
+                "is Interoperability."),
                 gpsIfdId, gpsTags, asciiString, printValue),
-        TagInfo(0x000a, "GPSMeasureMode", N_("GPS Measure Mode"), 
+        TagInfo(0x000a, "GPSMeasureMode", N_("GPS Measure Mode"),
                 N_("Indicates the GPS measurement mode. \"2\" means two-dimensional measurement and \"3\" "
-                "means three-dimensional measurement is in progress."), 
+                "means three-dimensional measurement is in progress."),
                 gpsIfdId, gpsTags, asciiString, printValue),
-        TagInfo(0x000b, "GPSDOP", N_("GPS Data Degree of Precision"), 
+        TagInfo(0x000b, "GPSDOP", N_("GPS Data Degree of Precision"),
                 N_("Indicates the GPS DOP (data degree of precision). An HDOP value is written "
-                "during two-dimensional measurement, and PDOP during three-dimensional measurement."), 
+                "during two-dimensional measurement, and PDOP during three-dimensional measurement."),
                 gpsIfdId, gpsTags, unsignedRational, printValue),
-        TagInfo(0x000c, "GPSSpeedRef", N_("GPS Speed Reference"), 
+        TagInfo(0x000c, "GPSSpeedRef", N_("GPS Speed Reference"),
                 N_("Indicates the unit used to express the GPS receiver speed of movement. "
-                "\"K\" \"M\" and \"N\" represents kilometers per hour, miles per hour, and knots."), 
+                "\"K\" \"M\" and \"N\" represents kilometers per hour, miles per hour, and knots."),
                 gpsIfdId, gpsTags, asciiString, EXV_PRINT_TAG(exifGPSSpeedRef)),
-        TagInfo(0x000d, "GPSSpeed", N_("GPS Speed"), 
-                N_("Indicates the speed of GPS receiver movement."), 
+        TagInfo(0x000d, "GPSSpeed", N_("GPS Speed"),
+                N_("Indicates the speed of GPS receiver movement."),
                 gpsIfdId, gpsTags, unsignedRational, printValue),
-        TagInfo(0x000e, "GPSTrackRef", N_("GPS Track Ref"), 
+        TagInfo(0x000e, "GPSTrackRef", N_("GPS Track Ref"),
                 N_("Indicates the reference for giving the direction of GPS receiver movement. "
-                "\"T\" denotes true direction and \"M\" is magnetic direction."), 
+                "\"T\" denotes true direction and \"M\" is magnetic direction."),
                 gpsIfdId, gpsTags, asciiString, printValue),
-        TagInfo(0x000f, "GPSTrack", N_("GPS Track"), 
+        TagInfo(0x000f, "GPSTrack", N_("GPS Track"),
                 N_("Indicates the direction of GPS receiver movement. The range of values is "
-                "from 0.00 to 359.99."), 
+                "from 0.00 to 359.99."),
                 gpsIfdId, gpsTags, unsignedRational, printValue),
-        TagInfo(0x0010, "GPSImgDirectionRef", N_("GPS Image Direction Reference"), 
+        TagInfo(0x0010, "GPSImgDirectionRef", N_("GPS Image Direction Reference"),
                 N_("Indicates the reference for giving the direction of the image when it is captured. "
-                "\"T\" denotes true direction and \"M\" is magnetic direction."), 
+                "\"T\" denotes true direction and \"M\" is magnetic direction."),
                 gpsIfdId, gpsTags, asciiString, printValue),
-        TagInfo(0x0011, "GPSImgDirection", N_("GPS Image Direction"), 
+        TagInfo(0x0011, "GPSImgDirection", N_("GPS Image Direction"),
                 N_("Indicates the direction of the image when it was captured. The range of values "
-                "is from 0.00 to 359.99."), 
+                "is from 0.00 to 359.99."),
                 gpsIfdId, gpsTags, unsignedRational, printValue),
-        TagInfo(0x0012, "GPSMapDatum", N_("GPS Map Datum"), 
+        TagInfo(0x0012, "GPSMapDatum", N_("GPS Map Datum"),
                 N_("Indicates the geodetic survey data used by the GPS receiver. If the survey data "
-                "is restricted to Japan, the value of this tag is \"TOKYO\" or \"WGS-84\"."), 
+                "is restricted to Japan, the value of this tag is \"TOKYO\" or \"WGS-84\"."),
                 gpsIfdId, gpsTags, asciiString, printValue),
-        TagInfo(0x0013, "GPSDestLatitudeRef", N_("GPS Destination Latitude Refeference"), 
+        TagInfo(0x0013, "GPSDestLatitudeRef", N_("GPS Destination Latitude Refeference"),
                 N_("Indicates whether the latitude of the destination point is north or south latitude. "
-                "The ASCII value \"N\" indicates north latitude, and \"S\" is south latitude."), 
+                "The ASCII value \"N\" indicates north latitude, and \"S\" is south latitude."),
                 gpsIfdId, gpsTags, asciiString, EXV_PRINT_TAG(exifGPSLatitudeRef)),
-        TagInfo(0x0014, "GPSDestLatitude", N_("GPS Destination Latitude"), 
+        TagInfo(0x0014, "GPSDestLatitude", N_("GPS Destination Latitude"),
                 N_("Indicates the latitude of the destination point. The latitude is expressed as "
                 "three RATIONAL values giving the degrees, minutes, and seconds, respectively. "
                 "If latitude is expressed as degrees, minutes and seconds, a typical format would "
                 "be dd/1,mm/1,ss/1. When degrees and minutes are used and, for example, "
                 "fractions of minutes are given up to two decimal places, the format would be "
-                "dd/1,mmmm/100,0/1."), 
+                "dd/1,mmmm/100,0/1."),
                 gpsIfdId, gpsTags, unsignedRational, printDegrees),
-        TagInfo(0x0015, "GPSDestLongitudeRef", N_("GPS Destination Longitude Reference"), 
+        TagInfo(0x0015, "GPSDestLongitudeRef", N_("GPS Destination Longitude Reference"),
                 N_("Indicates whether the longitude of the destination point is east or west longitude. "
-                "ASCII \"E\" indicates east longitude, and \"W\" is west longitude."), 
+                "ASCII \"E\" indicates east longitude, and \"W\" is west longitude."),
                 gpsIfdId, gpsTags, asciiString, EXV_PRINT_TAG(exifGPSLongitudeRef)),
-        TagInfo(0x0016, "GPSDestLongitude", N_("GPS Destination Longitude"), 
+        TagInfo(0x0016, "GPSDestLongitude", N_("GPS Destination Longitude"),
                 N_("Indicates the longitude of the destination point. The longitude is expressed "
                 "as three RATIONAL values giving the degrees, minutes, and seconds, respectively. "
                 "If longitude is expressed as degrees, minutes and seconds, a typical format would be "
                 "ddd/1,mm/1,ss/1. When degrees and minutes are used and, for example, fractions of "
-                "minutes are given up to two decimal places, the format would be ddd/1,mmmm/100,0/1."), 
+                "minutes are given up to two decimal places, the format would be ddd/1,mmmm/100,0/1."),
                 gpsIfdId, gpsTags, unsignedRational, printDegrees),
-        TagInfo(0x0017, "GPSDestBearingRef", N_("GPS Destination Bearing Reference"), 
+        TagInfo(0x0017, "GPSDestBearingRef", N_("GPS Destination Bearing Reference"),
                 N_("Indicates the reference used for giving the bearing to the destination point. "
-                "\"T\" denotes true direction and \"M\" is magnetic direction."), 
+                "\"T\" denotes true direction and \"M\" is magnetic direction."),
                 gpsIfdId, gpsTags, asciiString, printValue),
-        TagInfo(0x0018, "GPSDestBearing", N_("GPS Destination Bearing"), 
+        TagInfo(0x0018, "GPSDestBearing", N_("GPS Destination Bearing"),
                 N_("Indicates the bearing to the destination point. The range of values is from "
-                "0.00 to 359.99."), 
+                "0.00 to 359.99."),
                 gpsIfdId, gpsTags, unsignedRational, printValue),
-        TagInfo(0x0019, "GPSDestDistanceRef", N_("GPS Destination Distance Reference"), 
+        TagInfo(0x0019, "GPSDestDistanceRef", N_("GPS Destination Distance Reference"),
                 N_("Indicates the unit used to express the distance to the destination point. "
-                "\"K\", \"M\" and \"N\" represent kilometers, miles and knots."), 
+                "\"K\", \"M\" and \"N\" represent kilometers, miles and knots."),
                 gpsIfdId, gpsTags, asciiString, printValue),
-        TagInfo(0x001a, "GPSDestDistance", N_("GPS Destination Distance"), 
-                N_("Indicates the distance to the destination point."), 
+        TagInfo(0x001a, "GPSDestDistance", N_("GPS Destination Distance"),
+                N_("Indicates the distance to the destination point."),
                 gpsIfdId, gpsTags, unsignedRational, printValue),
-        TagInfo(0x001b, "GPSProcessingMethod", N_("GPS Processing Method"), 
+        TagInfo(0x001b, "GPSProcessingMethod", N_("GPS Processing Method"),
                 N_("A character string recording the name of the method used for location finding. "
                 "The first byte indicates the character code used, and this is followed by the name "
-                "of the method."), 
+                "of the method."),
                 gpsIfdId, gpsTags, undefined, printValue),
-        TagInfo(0x001c, "GPSAreaInformation", N_("GPS Area Information"), 
+        TagInfo(0x001c, "GPSAreaInformation", N_("GPS Area Information"),
                 N_("A character string recording the name of the GPS area. The first byte indicates "
-                "the character code used, and this is followed by the name of the GPS area."), 
+                "the character code used, and this is followed by the name of the GPS area."),
                 gpsIfdId, gpsTags, undefined, printValue),
-        TagInfo(0x001d, "GPSDateStamp", N_("GPS Date Stamp"), 
+        TagInfo(0x001d, "GPSDateStamp", N_("GPS Date Stamp"),
                 N_("A character string recording date and time information relative to UTC "
-                "(Coordinated Universal Time). The format is \"YYYY:MM:DD.\"."), 
+                "(Coordinated Universal Time). The format is \"YYYY:MM:DD.\"."),
                 gpsIfdId, gpsTags, asciiString, printValue),
-        TagInfo(0x001e, "GPSDifferential", N_("GPS Differential"), 
-                N_("Indicates whether differential correction is applied to the GPS receiver."), 
+        TagInfo(0x001e, "GPSDifferential", N_("GPS Differential"),
+                N_("Indicates whether differential correction is applied to the GPS receiver."),
                 gpsIfdId, gpsTags, unsignedShort, printValue),
         // End of list marker
-        TagInfo(0xffff, "(UnknownGpsTag)", N_("Unknown GPSInfo tag"), 
-                N_("Unknown GPSInfo tag"), 
+        TagInfo(0xffff, "(UnknownGpsTag)", N_("Unknown GPSInfo tag"),
+                N_("Unknown GPSInfo tag"),
                 ifdIdNotSet, sectionIdNotSet, invalidTypeId, printValue)
     };
 
@@ -1121,15 +1121,15 @@ namespace Exiv2 {
 
     // Exif Interoperability IFD Tags
     static const TagInfo iopTagInfo[] = {
-        TagInfo(0x0001, "InteroperabilityIndex", N_("Interoperability Index"), 
+        TagInfo(0x0001, "InteroperabilityIndex", N_("Interoperability Index"),
                 N_("Indicates the identification of the Interoperability rule. "
                 "Use \"R98\" for stating ExifR98 Rules. Four bytes used "
                 "including the termination code (NULL). see the separate "
                 "volume of Recommended Exif Interoperability Rules (ExifR98) "
                 "for other tags used for ExifR98."),
                 iopIfdId, iopTags, asciiString, printValue),
-        TagInfo(0x0002, "InteroperabilityVersion", N_("Interoperability Version"), 
-                N_("Interoperability version"), 
+        TagInfo(0x0002, "InteroperabilityVersion", N_("Interoperability Version"),
+                N_("Interoperability version"),
                 iopIfdId, iopTags, undefined, printValue),
         TagInfo(0x1000, "RelatedImageFileFormat", N_("Related Image File Format"),
                 N_("File format of image file"),
@@ -1141,8 +1141,8 @@ namespace Exiv2 {
                 N_("Image height"),
                 iopIfdId, iopTags, unsignedLong, printValue),
         // End of list marker
-        TagInfo(0xffff, "(UnknownIopTag)", N_("Unknown Exif Interoperability tag"), 
-                N_("Unknown Exif Interoperability tag"), 
+        TagInfo(0xffff, "(UnknownIopTag)", N_("Unknown Exif Interoperability tag"),
+                N_("Unknown Exif Interoperability tag"),
                 ifdIdNotSet, sectionIdNotSet, invalidTypeId, printValue)
     };
 
@@ -1152,8 +1152,8 @@ namespace Exiv2 {
     }
 
     // Unknown Tag
-    static const TagInfo unknownTag(0xffff, "Unknown tag", N_("Unknown tag"), 
-                                    N_("Unknown tag"), 
+    static const TagInfo unknownTag(0xffff, "Unknown tag", N_("Unknown tag"),
+                                    N_("Unknown tag"),
                                     ifdIdNotSet, sectionIdNotSet, asciiString, printValue);
 
     // Tag lookup lists with tag names, desc and where they (preferably) belong to;
@@ -1647,7 +1647,7 @@ namespace Exiv2 {
             for (n = 2; n > 0; --n) {
                 if (value.toRational(n).first != 0) break;
             }
-            for (int i = 0; i < n + 1; ++i) {                
+            for (int i = 0; i < n + 1; ++i) {
                 const int32_t z = value.toRational(i).first;
                 const int32_t d = value.toRational(i).second;
                 // Hack: Need Value::toDouble
@@ -1664,7 +1664,7 @@ namespace Exiv2 {
 
         return os;
     } // printDegrees
-    
+
     std::ostream& printUcs2(std::ostream& os, const Value& value)
     {
 #ifdef EXV_HAVE_ICONV
@@ -1689,18 +1689,18 @@ namespace Exiv2 {
             char* outptr = reinterpret_cast<char*>(ob.pData_);
             const char* outbuf = outptr;
             size_t outbytesleft = ob.size_;
-            EXV_ICONV_CONST char* inbuf 
+            EXV_ICONV_CONST char* inbuf
                 = reinterpret_cast<EXV_ICONV_CONST char*>(ib.pData_);
             size_t inbytesleft = ib.size_;
             size_t rc = iconv(cd,
-                              &inbuf, 
-                              &inbytesleft, 
+                              &inbuf,
+                              &inbytesleft,
                               &outptr,
                               &outbytesleft);
             if (rc == size_t(-1)) {
 #ifndef SUPPRESS_WARNINGS
                 std::cerr << "Warning: iconv: "
-                          << strError() 
+                          << strError()
                           << " inbytesleft = " << inbytesleft << "\n";
 #endif
                 go = false;
@@ -1740,8 +1740,8 @@ namespace Exiv2 {
         if (value.count() == 3) {
             std::ostringstream oss;
             oss.copyfmt(os);
-            const float sec = 3600 * value.toFloat(0) 
-                              + 60 * value.toFloat(1) 
+            const float sec = 3600 * value.toFloat(0)
+                              + 60 * value.toFloat(1)
                               + value.toFloat(2);
             int p = 0;
             if (sec != static_cast<int>(sec)) p = 1;
@@ -1750,9 +1750,9 @@ namespace Exiv2 {
             const int mm = static_cast<int>((sec - 3600 * hh) / 60);
             const float ss = sec - 3600 * hh - 60 * mm;
 
-            os << std::setw(2) << std::setfill('0') << std::right << hh << ":" 
+            os << std::setw(2) << std::setfill('0') << std::right << hh << ":"
                << std::setw(2) << std::setfill('0') << std::right << mm << ":"
-               << std::setw(2 + p * 2) << std::setfill('0') << std::right 
+               << std::setw(2 + p * 2) << std::setfill('0') << std::right
                << std::fixed << std::setprecision(p) << ss;
 
             os.copyfmt(oss);
diff --git a/src/tifffwd.hpp b/src/tifffwd.hpp
index a8b58762..044bf19d 100644
--- a/src/tifffwd.hpp
+++ b/src/tifffwd.hpp
@@ -73,14 +73,14 @@ namespace Exiv2 {
 // class definitions
 
     /*!
-      @brief Function pointer type for a TiffMetadataDecoder member function 
+      @brief Function pointer type for a TiffMetadataDecoder member function
              to decode a TIFF component.
      */
     typedef void (TiffMetadataDecoder::*DecoderFct)(const TiffEntryBase*);
     /*!
       @brief Type for a function pointer for a function to decode a TIFF component.
      */
-    typedef const DecoderFct (*FindDecoderFct)(const std::string& make, 
+    typedef const DecoderFct (*FindDecoderFct)(const std::string& make,
                                                      uint32_t     extendedTag,
                                                      uint16_t     group);
     /*!
@@ -91,7 +91,7 @@ namespace Exiv2 {
     typedef std::auto_ptr<TiffComponent> (*NewTiffCompFct)(      uint16_t       tag,
                                                            const TiffStructure* ts);
     /*!
-      @brief Type for a factory function to create new TIFF components. 
+      @brief Type for a factory function to create new TIFF components.
              Use TiffComponent::AutoPtr, it is not used in this declaration only
              to reduce dependencies.
      */
diff --git a/src/tiffparser.cpp b/src/tiffparser.cpp
index e45e8064..cf33c535 100644
--- a/src/tiffparser.cpp
+++ b/src/tiffparser.cpp
@@ -145,12 +145,12 @@ namespace Exiv2 {
         { "*",         0x8649, Group::ifd0,    &TiffMetadataDecoder::decodeIrbIptc      }
     };
 
-    const DecoderFct TiffDecoder::findDecoder(const std::string& make, 
+    const DecoderFct TiffDecoder::findDecoder(const std::string& make,
                                                     uint32_t     extendedTag,
                                                     uint16_t     group)
     {
         DecoderFct decoderFct = &TiffMetadataDecoder::decodeStdTiffEntry;
-        const TiffDecoderInfo* td = find(tiffDecoderInfo_, 
+        const TiffDecoderInfo* td = find(tiffDecoderInfo_,
                                          TiffDecoderInfo::Key(make, extendedTag, group));
         if (td) {
             // This may set decoderFct to 0, meaning that the tag should not be decoded
diff --git a/src/tiffparser.hpp b/src/tiffparser.hpp
index 024672fd..9f6e1312 100644
--- a/src/tiffparser.hpp
+++ b/src/tiffparser.hpp
@@ -104,9 +104,9 @@ namespace Exiv2 {
     class TiffDecoder {
     public:
         /*!
-          @brief Find the decoder function for a key. 
+          @brief Find the decoder function for a key.
 
-          If the returned pointer is 0, the tag should not be decoded, 
+          If the returned pointer is 0, the tag should not be decoded,
           else the decoder function should be used.
 
           @param make Camera make
@@ -115,7 +115,7 @@ namespace Exiv2 {
 
           @return Pointer to the decoder function
          */
-        static const DecoderFct findDecoder(const std::string& make, 
+        static const DecoderFct findDecoder(const std::string& make,
                                                   uint32_t     extendedTag,
                                                   uint16_t     group);
 
diff --git a/src/tiffvisitor.cpp b/src/tiffvisitor.cpp
index e215cf88..856493f0 100644
--- a/src/tiffvisitor.cpp
+++ b/src/tiffvisitor.cpp
@@ -121,7 +121,7 @@ namespace Exiv2 {
                                              TiffComponent* const pRoot,
                                              FindDecoderFct findDecoderFct,
                                              uint32_t threshold)
-        : pImage_(pImage), 
+        : pImage_(pImage),
           pRoot_(pRoot),
           findDecoderFct_(findDecoderFct),
           threshold_(threshold)
@@ -240,7 +240,7 @@ namespace Exiv2 {
             groupType_[object->group()] = object->pValue()->toLong();
         }
 
-        const DecoderFct decoderFct = findDecoderFct_(make_, 
+        const DecoderFct decoderFct = findDecoderFct_(make_,
                                                       object->tag(),
                                                       object->group());
         // skip decoding if decoderFct == 0
@@ -516,7 +516,7 @@ namespace Exiv2 {
         long offset = pOffset->toLong(0);
         // Todo: Remove limitation of Jpeg writer: strips must be contiguous
         // Until then we check: last offset + last size - first offset == size?
-        if (  pOffset->toLong(pOffset->count()-1) 
+        if (  pOffset->toLong(pOffset->count()-1)
             + pSize->toLong(pSize->count()-1)
             - offset != size) {
 #ifndef SUPPRESS_WARNINGS
@@ -561,8 +561,8 @@ namespace Exiv2 {
         // Sanity check with an "unreasonably" large number
         if (n > 256) {
 #ifndef SUPPRESS_WARNINGS
-            std::cerr << "Error: " 
-                      << "Directory " << object->groupName() << " with " 
+            std::cerr << "Error: "
+                      << "Directory " << object->groupName() << " with "
                       << n << " entries considered invalid; not read.\n";
 #endif
             return;
@@ -797,8 +797,8 @@ namespace Exiv2 {
         // Todo: This should be somewhere else, maybe in a Value factory
         // which takes a Key and Type
         TypeId t = TypeId(object->typeId());
-        if (   object->tag()    == 0x9286 
-            && object->group()  == Group::exif 
+        if (   object->tag()    == 0x9286
+            && object->group()  == Group::exif
             && object->typeId() == undefined) {
             t = comment;
         }
diff --git a/src/tiffvisitor.hpp b/src/tiffvisitor.hpp
index a23f5e1c..fa8c6efb 100644
--- a/src/tiffvisitor.hpp
+++ b/src/tiffvisitor.hpp
@@ -389,7 +389,7 @@ namespace Exiv2 {
         //! Return the base offset. See class TiffRwState for details
         uint32_t baseOffset() const;
         //! Create a TIFF component for \em extendedTag and group
-        std::auto_ptr<TiffComponent> create(uint32_t extendedTag, 
+        std::auto_ptr<TiffComponent> create(uint32_t extendedTag,
                                             uint16_t group) const;
         //@}
 
diff --git a/src/types.cpp b/src/types.cpp
index dc7c17df..1677e9cf 100644
--- a/src/types.cpp
+++ b/src/types.cpp
@@ -358,7 +358,7 @@ const char* _exvGettext(const char* str)
 # endif
         exvGettextInitialized = true;
     }
-  
+
     return dgettext(EXV_PACKAGE, str);
 }
 #endif // EXV_ENABLE_NLS