"drawinglayer" -> "drawinglayer.emf" log area for some emf code

Change-Id: I83fa2d40225f83b82cea7f8934f4afdee181abe3
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/117000
Tested-by: Jenkins
Reviewed-by: Luboš Luňák <l.lunak@collabora.com>

11 files changed, 294 insertions, 294 deletions

diff --git a/drawinglayer/source/tools/emfpbrush.cxx b/drawinglayer/source/tools/emfpbrush.cxx
index 24c3f281812b..4acc311345a8 100644
--- a/drawinglayer/source/tools/emfpbrush.cxx
+++ b/drawinglayer/source/tools/emfpbrush.cxx
@@ -67,8 +67,8 @@ namespace emfplushelper
 
         s.ReadUInt32(header).ReadUInt32(type);
 
-        SAL_INFO("drawinglayer", "EMF+\t\t\tHeader: 0x" << std::hex << header);
-        SAL_INFO("drawinglayer", "EMF+\t\t\tType: " << BrushTypeToString(type) << "(0x" << type << ")" << std::dec);
+        SAL_INFO("drawinglayer.emf", "EMF+\t\t\tHeader: 0x" << std::hex << header);
+        SAL_INFO("drawinglayer.emf", "EMF+\t\t\tType: " << BrushTypeToString(type) << "(0x" << type << ")" << std::dec);
 
         switch (type)
         {
@@ -78,7 +78,7 @@ namespace emfplushelper
                 s.ReadUInt32(color);
 
                 solidColor = ::Color(ColorAlpha, (color >> 24), (color >> 16) & 0xff, (color >> 8) & 0xff, color & 0xff);
-                SAL_INFO("drawinglayer", "EMF+\t\t\t\tSolid color: 0x" << std::hex << color << std::dec);
+                SAL_INFO("drawinglayer.emf", "EMF+\t\t\t\tSolid color: 0x" << std::hex << color << std::dec);
                 break;
             }
             case BrushTypeHatchFill:
@@ -93,28 +93,28 @@ namespace emfplushelper
                 hatchStyle = static_cast<EmfPlusHatchStyle>(style);
                 solidColor = ::Color(ColorAlpha, (foregroundColor >> 24), (foregroundColor >> 16) & 0xff, (foregroundColor >> 8) & 0xff, foregroundColor & 0xff);
                 secondColor = ::Color(ColorAlpha, (backgroundColor >> 24), (backgroundColor >> 16) & 0xff, (backgroundColor >> 8) & 0xff, backgroundColor & 0xff);
-                SAL_INFO("drawinglayer", "EMF+\t\t\t\tHatch style: 0x" << std::hex << style);
-                SAL_INFO("drawinglayer", "EMF+\t\t\t\tForeground color: 0x" << solidColor.AsRGBHexString());
-                SAL_INFO("drawinglayer", "EMF+\t\t\t\tBackground color: 0x" << secondColor.AsRGBHexString());
+                SAL_INFO("drawinglayer.emf", "EMF+\t\t\t\tHatch style: 0x" << std::hex << style);
+                SAL_INFO("drawinglayer.emf", "EMF+\t\t\t\tForeground color: 0x" << solidColor.AsRGBHexString());
+                SAL_INFO("drawinglayer.emf", "EMF+\t\t\t\tBackground color: 0x" << secondColor.AsRGBHexString());
                 break;
             }
             case BrushTypeTextureFill:
             {
-                SAL_WARN("drawinglayer", "EMF+\tTODO: implement BrushTypeTextureFill brush");
+                SAL_WARN("drawinglayer.emf", "EMF+\tTODO: implement BrushTypeTextureFill brush");
                 break;
             }
             case BrushTypePathGradient:
             {
                 s.ReadUInt32(additionalFlags).ReadInt32(wrapMode);
-                SAL_INFO("drawinglayer", "EMF+\t\t\t\tAdditional flags: 0x" << std::hex << additionalFlags << std::dec);
+                SAL_INFO("drawinglayer.emf", "EMF+\t\t\t\tAdditional flags: 0x" << std::hex << additionalFlags << std::dec);
                 sal_uInt32 color;
                 s.ReadUInt32(color);
                 solidColor = ::Color(ColorAlpha, (color >> 24), (color >> 16) & 0xff, (color >> 8) & 0xff, color & 0xff);
-                SAL_INFO("drawinglayer", "EMF+\t\t\t\tCenter color: 0x" << std::hex << color << std::dec);
+                SAL_INFO("drawinglayer.emf", "EMF+\t\t\t\tCenter color: 0x" << std::hex << color << std::dec);
                 s.ReadFloat(firstPointX).ReadFloat(firstPointY);
-                SAL_INFO("drawinglayer", "EMF+\t\t\t\tCenter point: " << firstPointX << "," << firstPointY);
+                SAL_INFO("drawinglayer.emf", "EMF+\t\t\t\tCenter point: " << firstPointX << "," << firstPointY);
                 s.ReadInt32(surroundColorsNumber);
-                SAL_INFO("drawinglayer", "EMF+\t\t\t\t number of surround colors: " << surroundColorsNumber);
+                SAL_INFO("drawinglayer.emf", "EMF+\t\t\t\t number of surround colors: " << surroundColorsNumber);
 
                 if (surroundColorsNumber<0 || o3tl::make_unsigned(surroundColorsNumber)>SAL_MAX_INT32 / sizeof(::Color))
                 {
@@ -129,7 +129,7 @@ namespace emfplushelper
                     surroundColors[i] = ::Color(ColorAlpha, (color >> 24), (color >> 16) & 0xff, (color >> 8) & 0xff, color & 0xff);
                     if (i == 0)
                         secondColor = surroundColors[0];
-                    SAL_INFO("drawinglayer", "EMF+\t\t\t\tSurround color[" << i << "]: 0x" << std::hex << color << std::dec);
+                    SAL_INFO("drawinglayer.emf", "EMF+\t\t\t\tSurround color[" << i << "]: 0x" << std::hex << color << std::dec);
                 }
 
                 if (additionalFlags & 0x01)
@@ -137,7 +137,7 @@ namespace emfplushelper
                     sal_Int32 pathLength;
 
                     s.ReadInt32(pathLength);
-                    SAL_INFO("drawinglayer", "EMF+\t\t\t\tPath length: " << pathLength);
+                    SAL_INFO("drawinglayer.emf", "EMF+\t\t\t\tPath length: " << pathLength);
 
                     sal_uInt64 const pos = s.Tell();
 
@@ -145,10 +145,10 @@ namespace emfplushelper
                     sal_Int32 pathPoints, pathFlags;
                     s.ReadUInt32(pathHeader).ReadInt32(pathPoints).ReadInt32(pathFlags);
 
-                    SAL_INFO("drawinglayer", "EMF+\t\t\t\tPath (brush path gradient)");
-                    SAL_INFO("drawinglayer", "EMF+\t\t\t\t\tHeader: 0x" << std::hex << pathHeader);
-                    SAL_INFO("drawinglayer", "EMF+\t\t\t\t\tPoints: " << std::dec << pathPoints);
-                    SAL_INFO("drawinglayer", "EMF+\t\t\t\t\tAdditional flags: 0x" << std::hex << pathFlags << std::dec);
+                    SAL_INFO("drawinglayer.emf", "EMF+\t\t\t\tPath (brush path gradient)");
+                    SAL_INFO("drawinglayer.emf", "EMF+\t\t\t\t\tHeader: 0x" << std::hex << pathHeader);
+                    SAL_INFO("drawinglayer.emf", "EMF+\t\t\t\t\tPoints: " << std::dec << pathPoints);
+                    SAL_INFO("drawinglayer.emf", "EMF+\t\t\t\t\tAdditional flags: 0x" << std::hex << pathFlags << std::dec);
 
                     path.reset( new EMFPPath(pathPoints) );
                     path->Read(s, pathFlags);
@@ -158,7 +158,7 @@ namespace emfplushelper
                     const ::basegfx::B2DRectangle aBounds(::basegfx::utils::getRange(path->GetPolygon(rR, false)));
                     aWidth = aBounds.getWidth();
                     aHeight = aBounds.getHeight();
-                    SAL_INFO("drawinglayer", "EMF+\t\t\t\tPolygon bounding box: " << aBounds.getMinX() << "," << aBounds.getMinY() << " "
+                    SAL_INFO("drawinglayer.emf", "EMF+\t\t\t\tPolygon bounding box: " << aBounds.getMinX() << "," << aBounds.getMinY() << " "
                                                                              << aBounds.getWidth() << "x" << aBounds.getHeight());
                 }
                 else
@@ -167,7 +167,7 @@ namespace emfplushelper
                     s.ReadInt32(boundaryPointCount);
 
                     sal_uInt64 const pos = s.Tell();
-                    SAL_INFO("drawinglayer", "EMF+\t use boundary, points: " << boundaryPointCount);
+                    SAL_INFO("drawinglayer.emf", "EMF+\t use boundary, points: " << boundaryPointCount);
                     path.reset( new EMFPPath(boundaryPointCount) );
                     path->Read(s, 0x0);
 
@@ -176,7 +176,7 @@ namespace emfplushelper
                     const ::basegfx::B2DRectangle aBounds(::basegfx::utils::getRange(path->GetPolygon(rR, false)));
                     aWidth = aBounds.getWidth();
                     aHeight = aBounds.getHeight();
-                    SAL_INFO("drawinglayer", "EMF+\t\t\t\tPolygon bounding box: " << aBounds.getMinX() << "," << aBounds.getMinY() << " "
+                    SAL_INFO("drawinglayer.emf", "EMF+\t\t\t\tPolygon bounding box: " << aBounds.getMinX() << "," << aBounds.getMinY() << " "
                                                                              << aBounds.getWidth() << "x" << aBounds.getHeight());
                 }
 
@@ -184,13 +184,13 @@ namespace emfplushelper
                 {
                     EmfPlusHelperData::readXForm(s, brush_transformation);
                     hasTransformation = true;
-                    SAL_INFO("drawinglayer", "EMF+\t\t\t\tUse brush transformation: " << brush_transformation);
+                    SAL_INFO("drawinglayer.emf", "EMF+\t\t\t\tUse brush transformation: " << brush_transformation);
                 }
 
                 if (additionalFlags & 0x08)
                 {
                     s.ReadInt32(blendPoints);
-                    SAL_INFO("drawinglayer", "EMF+\t\t\t\tuse blend, points: " << blendPoints);
+                    SAL_INFO("drawinglayer.emf", "EMF+\t\t\t\tuse blend, points: " << blendPoints);
                     if (blendPoints<0 || o3tl::make_unsigned(blendPoints)>SAL_MAX_INT32 / (2 * sizeof(float)))
                         blendPoints = SAL_MAX_INT32 / (2 * sizeof(float));
                     blendPositions.reset( new float[2 * blendPoints] );
@@ -199,20 +199,20 @@ namespace emfplushelper
                     for (int i = 0; i < blendPoints; i++)
                     {
                         s.ReadFloat(blendPositions[i]);
-                        SAL_INFO("drawinglayer", "EMF+\t\t\t\tposition[" << i << "]: " << blendPositions[i]);
+                        SAL_INFO("drawinglayer.emf", "EMF+\t\t\t\tposition[" << i << "]: " << blendPositions[i]);
                     }
 
                     for (int i = 0; i < blendPoints; i++)
                     {
                         s.ReadFloat(blendFactors[i]);
-                        SAL_INFO("drawinglayer", "EMF+\t\t\t\tFactor[" << i << "]: " << blendFactors[i]);
+                        SAL_INFO("drawinglayer.emf", "EMF+\t\t\t\tFactor[" << i << "]: " << blendFactors[i]);
                     }
                 }
 
                 if (additionalFlags & 0x04)
                 {
                     s.ReadInt32(colorblendPoints);
-                    SAL_INFO("drawinglayer", "EMF+\t\t\t\tUse color blend, points: " << colorblendPoints);
+                    SAL_INFO("drawinglayer.emf", "EMF+\t\t\t\tUse color blend, points: " << colorblendPoints);
 
                     if (colorblendPoints<0 || o3tl::make_unsigned(colorblendPoints)>SAL_MAX_INT32 / sizeof(float))
                     {
@@ -230,14 +230,14 @@ namespace emfplushelper
                     for (int i = 0; i < colorblendPoints; i++)
                     {
                         s.ReadFloat(colorblendPositions[i]);
-                        SAL_INFO("drawinglayer", "EMF+\tposition[" << i << "]: " << colorblendPositions[i]);
+                        SAL_INFO("drawinglayer.emf", "EMF+\tposition[" << i << "]: " << colorblendPositions[i]);
                     }
 
                     for (int i = 0; i < colorblendPoints; i++)
                     {
                         s.ReadUInt32(color);
                         colorblendColors[i] = ::Color(ColorAlpha, (color >> 24), (color >> 16) & 0xff, (color >> 8) & 0xff, color & 0xff);
-                        SAL_INFO("drawinglayer", "EMF+\t\t\t\tColor[" << i << "]: 0x" << std::hex << color << std::dec);
+                        SAL_INFO("drawinglayer.emf", "EMF+\t\t\t\tColor[" << i << "]: 0x" << std::hex << color << std::dec);
                     }
                 }
 
@@ -246,17 +246,17 @@ namespace emfplushelper
             case BrushTypeLinearGradient:
             {
                 s.ReadUInt32(additionalFlags).ReadInt32(wrapMode);
-                SAL_INFO("drawinglayer", "EMF+\t\t\t\tLinear gradient, additional flags: 0x" << std::hex << additionalFlags << std::dec << ", wrapMode: " << wrapMode);
+                SAL_INFO("drawinglayer.emf", "EMF+\t\t\t\tLinear gradient, additional flags: 0x" << std::hex << additionalFlags << std::dec << ", wrapMode: " << wrapMode);
                 s.ReadFloat(firstPointX).ReadFloat(firstPointY).ReadFloat(aWidth).ReadFloat(aHeight);
-                SAL_INFO("drawinglayer", "EMF+\t\t\t\tFirst gradient point: " << firstPointX << ":" << firstPointY
+                SAL_INFO("drawinglayer.emf", "EMF+\t\t\t\tFirst gradient point: " << firstPointX << ":" << firstPointY
                                          << ", size " << aWidth << "x" << aHeight);
                 sal_uInt32 color;
                 s.ReadUInt32(color);
                 solidColor = ::Color(ColorAlpha, (color >> 24), (color >> 16) & 0xff, (color >> 8) & 0xff, color & 0xff);
-                SAL_INFO("drawinglayer", "EMF+\t\t\t\tfirst color: 0x" << std::hex << color << std::dec);
+                SAL_INFO("drawinglayer.emf", "EMF+\t\t\t\tfirst color: 0x" << std::hex << color << std::dec);
                 s.ReadUInt32(color);
                 secondColor = ::Color(ColorAlpha, (color >> 24), (color >> 16) & 0xff, (color >> 8) & 0xff, color & 0xff);
-                SAL_INFO("drawinglayer", "EMF+\t\t\t\tsecond color: 0x" << std::hex << color << std::dec);
+                SAL_INFO("drawinglayer.emf", "EMF+\t\t\t\tsecond color: 0x" << std::hex << color << std::dec);
 
                 // repeated colors, unknown meaning, see http://www.aces.uiuc.edu/~jhtodd/Metafile/MetafileRecords/ObjectBrush.html
                 s.ReadUInt32(color);
@@ -266,13 +266,13 @@ namespace emfplushelper
                 {
                     EmfPlusHelperData::readXForm(s, brush_transformation);
                     hasTransformation = true;
-                    SAL_INFO("drawinglayer", "EMF+\t\t\t\tUse brush transformation: " << brush_transformation);
+                    SAL_INFO("drawinglayer.emf", "EMF+\t\t\t\tUse brush transformation: " << brush_transformation);
                 }
 
                 if (additionalFlags & 0x08)
                 {
                     s.ReadInt32(blendPoints);
-                    SAL_INFO("drawinglayer", "EMF+\t\t\t\tUse blend, points: " << blendPoints);
+                    SAL_INFO("drawinglayer.emf", "EMF+\t\t\t\tUse blend, points: " << blendPoints);
                     if (blendPoints<0 || o3tl::make_unsigned(blendPoints)>SAL_MAX_INT32 / (2 * sizeof(float)))
                         blendPoints = SAL_MAX_INT32 / (2 * sizeof(float));
                     blendPositions.reset( new float[2 * blendPoints] );
@@ -281,20 +281,20 @@ namespace emfplushelper
                     for (int i = 0; i < blendPoints; i++)
                     {
                         s.ReadFloat(blendPositions[i]);
-                        SAL_INFO("drawinglayer", "EMF+\t\t\t\tPosition[" << i << "]: " << blendPositions[i]);
+                        SAL_INFO("drawinglayer.emf", "EMF+\t\t\t\tPosition[" << i << "]: " << blendPositions[i]);
                     }
 
                     for (int i = 0; i < blendPoints; i++)
                     {
                         s.ReadFloat(blendFactors[i]);
-                        SAL_INFO("drawinglayer", "EMF+\t\t\t\tFactor[" << i << "]: " << blendFactors[i]);
+                        SAL_INFO("drawinglayer.emf", "EMF+\t\t\t\tFactor[" << i << "]: " << blendFactors[i]);
                     }
                 }
 
                 if (additionalFlags & 0x04)
                 {
                     s.ReadInt32(colorblendPoints);
-                    SAL_INFO("drawinglayer", "EMF+\t\t\t\tUse color blend, points: " << colorblendPoints);
+                    SAL_INFO("drawinglayer.emf", "EMF+\t\t\t\tUse color blend, points: " << colorblendPoints);
 
                     if (colorblendPoints<0 || o3tl::make_unsigned(colorblendPoints)>SAL_MAX_INT32 / sizeof(float))
                     {
@@ -312,14 +312,14 @@ namespace emfplushelper
                     for (int i = 0; i < colorblendPoints; i++)
                     {
                         s.ReadFloat(colorblendPositions[i]);
-                        SAL_INFO("drawinglayer", "EMF+\t\t\t\tPosition[" << i << "]: " << colorblendPositions[i]);
+                        SAL_INFO("drawinglayer.emf", "EMF+\t\t\t\tPosition[" << i << "]: " << colorblendPositions[i]);
                     }
 
                     for (int i = 0; i < colorblendPoints; i++)
                     {
                         s.ReadUInt32(color);
                         colorblendColors[i] = ::Color(ColorAlpha, (color >> 24), (color >> 16) & 0xff, (color >> 8) & 0xff, color & 0xff);
-                        SAL_INFO("drawinglayer", "EMF+\t\t\t\tColor[" << i << "]: 0x" << std::hex << color << std::dec);
+                        SAL_INFO("drawinglayer.emf", "EMF+\t\t\t\tColor[" << i << "]: 0x" << std::hex << color << std::dec);
                     }
                 }
 
@@ -327,7 +327,7 @@ namespace emfplushelper
             }
             default:
             {
-                SAL_WARN("drawinglayer", "EMF+\tunhandled brush type: " << std::hex << type << std::dec);
+                SAL_WARN("drawinglayer.emf", "EMF+\tunhandled brush type: " << std::hex << type << std::dec);
             }
         }
     }
diff --git a/drawinglayer/source/tools/emfpcustomlinecap.cxx b/drawinglayer/source/tools/emfpcustomlinecap.cxx
index 98af0f5241c7..e24cbcc32cb1 100644
--- a/drawinglayer/source/tools/emfpcustomlinecap.cxx
+++ b/drawinglayer/source/tools/emfpcustomlinecap.cxx
@@ -56,12 +56,12 @@ namespace emfplushelper
     {
         sal_Int32 pathLength;
         s.ReadInt32(pathLength);
-        SAL_INFO("drawinglayer", "EMF+\t\tpath length: " << pathLength);
+        SAL_INFO("drawinglayer.emf", "EMF+\t\tpath length: " << pathLength);
         sal_uInt32 pathHeader;
         sal_Int32 pathPoints, pathFlags;
         s.ReadUInt32(pathHeader).ReadInt32(pathPoints).ReadInt32(pathFlags);
-        SAL_INFO("drawinglayer", "EMF+\t\tpath (custom cap line path)");
-        SAL_INFO("drawinglayer", "EMF+\t\theader: 0x" << std::hex << pathHeader << " points: " << std::dec << pathPoints << " additional flags: 0x" << std::hex << pathFlags << std::dec);
+        SAL_INFO("drawinglayer.emf", "EMF+\t\tpath (custom cap line path)");
+        SAL_INFO("drawinglayer.emf", "EMF+\t\theader: 0x" << std::hex << pathHeader << " points: " << std::dec << pathPoints << " additional flags: 0x" << std::hex << pathFlags << std::dec);
 
         EMFPPath path(pathPoints);
         path.Read(s, pathFlags);
@@ -73,8 +73,8 @@ namespace emfplushelper
     {
         sal_uInt32 header;
         s.ReadUInt32(header).ReadUInt32(type);
-        SAL_INFO("drawinglayer", "EMF+\t\tcustom cap");
-        SAL_INFO("drawinglayer", "EMF+\t\theader: 0x" << std::hex << header << " type: " << type << std::dec);
+        SAL_INFO("drawinglayer.emf", "EMF+\t\tcustom cap");
+        SAL_INFO("drawinglayer.emf", "EMF+\t\theader: 0x" << std::hex << header << " type: " << type << std::dec);
 
         if (type == EmfPlusCustomLineCapDataTypeDefault)
         {
@@ -88,14 +88,14 @@ namespace emfplushelper
                 .ReadFloat(miterLimit).ReadFloat(widthScale)
                 .ReadFloat(fillHotSpotX).ReadFloat(fillHotSpotY).ReadFloat(strokeHotSpotX).ReadFloat(strokeHotSpotY);
 
-            SAL_INFO("drawinglayer", "EMF+\t\tcustomLineCapDataFlags: 0x" << std::hex << customLineCapDataFlags);
-            SAL_INFO("drawinglayer", "EMF+\t\tbaseCap: 0x" << std::hex << baseCap);
-            SAL_INFO("drawinglayer", "EMF+\t\tbaseInset: " << baseInset);
-            SAL_INFO("drawinglayer", "EMF+\t\tstrokeStartCap: 0x" << std::hex << strokeStartCap);
-            SAL_INFO("drawinglayer", "EMF+\t\tstrokeEndCap: 0x" << std::hex << strokeEndCap);
-            SAL_INFO("drawinglayer", "EMF+\t\tstrokeJoin: 0x" << std::hex << strokeJoin);
-            SAL_INFO("drawinglayer", "EMF+\t\tmiterLimit: " << miterLimit);
-            SAL_INFO("drawinglayer", "EMF+\t\twidthScale: " << widthScale);
+            SAL_INFO("drawinglayer.emf", "EMF+\t\tcustomLineCapDataFlags: 0x" << std::hex << customLineCapDataFlags);
+            SAL_INFO("drawinglayer.emf", "EMF+\t\tbaseCap: 0x" << std::hex << baseCap);
+            SAL_INFO("drawinglayer.emf", "EMF+\t\tbaseInset: " << baseInset);
+            SAL_INFO("drawinglayer.emf", "EMF+\t\tstrokeStartCap: 0x" << std::hex << strokeStartCap);
+            SAL_INFO("drawinglayer.emf", "EMF+\t\tstrokeEndCap: 0x" << std::hex << strokeEndCap);
+            SAL_INFO("drawinglayer.emf", "EMF+\t\tstrokeJoin: 0x" << std::hex << strokeJoin);
+            SAL_INFO("drawinglayer.emf", "EMF+\t\tmiterLimit: " << miterLimit);
+            SAL_INFO("drawinglayer.emf", "EMF+\t\twidthScale: " << widthScale);
 
             if (customLineCapDataFlags & EmfPlusCustomLineCapDataFillPath)
             {
@@ -120,7 +120,7 @@ namespace emfplushelper
                 .ReadInt32(lineEndCap).ReadInt32(lineJoin).ReadFloat(miterLimit).ReadInt32(widthScale)
                 .ReadFloat(fillHotSpotX).ReadFloat(fillHotSpotY).ReadFloat(lineHotSpotX).ReadFloat(lineHotSpotY);
 
-            SAL_INFO("drawinglayer", "EMF+\t\tTODO - actually read EmfPlusCustomLineCapArrowData object (section 2.2.2.12)");
+            SAL_INFO("drawinglayer.emf", "EMF+\t\tTODO - actually read EmfPlusCustomLineCapArrowData object (section 2.2.2.12)");
         }
     }
 }
diff --git a/drawinglayer/source/tools/emfpfont.cxx b/drawinglayer/source/tools/emfpfont.cxx
index 609135460992..3fd6537e75a0 100644
--- a/drawinglayer/source/tools/emfpfont.cxx
+++ b/drawinglayer/source/tools/emfpfont.cxx
@@ -48,14 +48,14 @@ namespace emfplushelper
         sal_uInt32 reserved;
         sal_uInt32 length;
         s.ReadUInt32(header).ReadFloat(emSize).ReadUInt32(sizeUnit).ReadInt32(fontFlags).ReadUInt32(reserved).ReadUInt32(length);
-        SAL_WARN_IF((header >> 12) != 0xdbc01, "drawinglayer", "Invalid header - not 0xdbc01");
-        SAL_INFO("drawinglayer", "EMF+\tHeader: 0x" << std::hex << (header >> 12));
-        SAL_INFO("drawinglayer", "EMF+\tVersion: 0x" << (header & 0x1fff));
-        SAL_INFO("drawinglayer", "EMF+\tSize: " << std::dec << emSize);
-        SAL_INFO("drawinglayer", "EMF+\tUnit: " << UnitTypeToString(sizeUnit) << " (0x" << std::hex << sizeUnit << ")" << std::dec);
-        SAL_INFO("drawinglayer", "EMF+\tFlags: " << FontStyleToString(fontFlags) << " (0x" << std::hex << fontFlags << ")");
-        SAL_INFO("drawinglayer", "EMF+\tReserved: 0x" << reserved << std::dec);
-        SAL_INFO("drawinglayer", "EMF+\tLength: " << length);
+        SAL_WARN_IF((header >> 12) != 0xdbc01, "drawinglayer.emf", "Invalid header - not 0xdbc01");
+        SAL_INFO("drawinglayer.emf", "EMF+\tHeader: 0x" << std::hex << (header >> 12));
+        SAL_INFO("drawinglayer.emf", "EMF+\tVersion: 0x" << (header & 0x1fff));
+        SAL_INFO("drawinglayer.emf", "EMF+\tSize: " << std::dec << emSize);
+        SAL_INFO("drawinglayer.emf", "EMF+\tUnit: " << UnitTypeToString(sizeUnit) << " (0x" << std::hex << sizeUnit << ")" << std::dec);
+        SAL_INFO("drawinglayer.emf", "EMF+\tFlags: " << FontStyleToString(fontFlags) << " (0x" << std::hex << fontFlags << ")");
+        SAL_INFO("drawinglayer.emf", "EMF+\tReserved: 0x" << reserved << std::dec);
+        SAL_INFO("drawinglayer.emf", "EMF+\tLength: " << length);
 
         if (length <= 0 || length >= 0x4000)
             return;
@@ -69,7 +69,7 @@ namespace emfplushelper
         }
 
         family = OUString(pStr, SAL_NO_ACQUIRE);
-        SAL_INFO("drawinglayer", "EMF+\tFamily: " << family);
+        SAL_INFO("drawinglayer.emf", "EMF+\tFamily: " << family);
     }
 }
 
diff --git a/drawinglayer/source/tools/emfphelperdata.cxx b/drawinglayer/source/tools/emfphelperdata.cxx
index 76d36529a48a..1f3143112320 100644
--- a/drawinglayer/source/tools/emfphelperdata.cxx
+++ b/drawinglayer/source/tools/emfphelperdata.cxx
@@ -245,11 +245,11 @@ namespace emfplushelper
 
             case UnitTypeWorld:
             case UnitTypeDisplay:
-                SAL_WARN("drawinglayer", "EMF+\t Converting to World/Display.");
+                SAL_WARN("drawinglayer.emf", "EMF+\t Converting to World/Display.");
                 return 1.0f;
 
             default:
-                SAL_WARN("drawinglayer", "EMF+\tTODO Unimplemented support of Unit Type: 0x" << std::hex << aUnitType);
+                SAL_WARN("drawinglayer.emf", "EMF+\tTODO Unimplemented support of Unit Type: 0x" << std::hex << aUnitType);
                 return 1.0f;
         }
     }
@@ -258,9 +258,9 @@ namespace emfplushelper
     {
         sal_uInt16 objecttype = flags & 0x7f00;
         sal_uInt16 index = flags & 0xff;
-        SAL_INFO("drawinglayer", "EMF+ Object: " << emfObjectToName(objecttype) << " (0x" << objecttype << ")");
-        SAL_INFO("drawinglayer", "EMF+\tObject slot: " << index);
-        SAL_INFO("drawinglayer", "EMF+\tFlags: " << (flags & 0xff00));
+        SAL_INFO("drawinglayer.emf", "EMF+ Object: " << emfObjectToName(objecttype) << " (0x" << objecttype << ")");
+        SAL_INFO("drawinglayer.emf", "EMF+\tObject slot: " << index);
+        SAL_INFO("drawinglayer.emf", "EMF+\tFlags: " << (flags & 0xff00));
 
         switch (objecttype)
         {
@@ -285,9 +285,9 @@ namespace emfplushelper
                 sal_Int32 points;
 
                 rObjectStream.ReadUInt32(header).ReadInt32(points).ReadUInt32(pathFlags);
-                SAL_INFO("drawinglayer", "EMF+\t\tHeader: 0x" << std::hex << header);
-                SAL_INFO("drawinglayer", "EMF+\t\tPoints: " << std::dec << points);
-                SAL_INFO("drawinglayer", "EMF+\t\tAdditional flags: 0x" << std::hex << pathFlags << std::dec);
+                SAL_INFO("drawinglayer.emf", "EMF+\t\tHeader: 0x" << std::hex << header);
+                SAL_INFO("drawinglayer.emf", "EMF+\t\tPoints: " << std::dec << points);
+                SAL_INFO("drawinglayer.emf", "EMF+\t\tAdditional flags: 0x" << std::hex << pathFlags << std::dec);
                 EMFPPath *path = new EMFPPath(points);
                 maEMFPObjects[index].reset(path);
                 path->Read(rObjectStream, pathFlags);
@@ -341,12 +341,12 @@ namespace emfplushelper
             }
             case EmfPlusObjectTypeCustomLineCap:
             {
-                SAL_WARN("drawinglayer", "EMF+\t TODO Object type 'custom line cap' not yet implemented");
+                SAL_WARN("drawinglayer.emf", "EMF+\t TODO Object type 'custom line cap' not yet implemented");
                 break;
             }
             default:
             {
-                SAL_WARN("drawinglayer", "EMF+\t TODO Object unhandled flags: 0x" << std::hex << (flags & 0xff00) << std::dec);
+                SAL_WARN("drawinglayer.emf", "EMF+\t TODO Object unhandled flags: 0x" << std::hex << (flags & 0xff00) << std::dec);
             }
         }
     }
@@ -358,7 +358,7 @@ namespace emfplushelper
             // specifies a location in the coordinate space that is relative to
             // the location specified by the previous element in the array. In the case of the first element in
             // PointData, a previous location at coordinates (0,0) is assumed.
-            SAL_WARN("drawinglayer", "EMF+\t\t TODO Relative coordinates bit detected. Implement parse EMFPlusPointR");
+            SAL_WARN("drawinglayer.emf", "EMF+\t\t TODO Relative coordinates bit detected. Implement parse EMFPlusPointR");
         }
 
         if (flags & 0x4000)
@@ -425,7 +425,7 @@ namespace emfplushelper
     {
         if (mnPixX == 0 || mnPixY == 0)
         {
-            SAL_WARN("drawinglayer", "dimensions in pixels is 0");
+            SAL_WARN("drawinglayer.emf", "dimensions in pixels is 0");
             return;
         }
         // Call when mnMmX/mnMmY/mnPixX/mnPixY/mnFrameLeft/mnFrameTop/maWorldTransform/ changes.
@@ -475,7 +475,7 @@ namespace emfplushelper
         if ( iter != map.end() )
         {
             map.erase( iter );
-            SAL_INFO("drawinglayer", "EMF+\t\tStack index: " << index << " found and erased");
+            SAL_INFO("drawinglayer.emf", "EMF+\t\tStack index: " << index << " found and erased");
         }
 
         wmfemfhelper::PropertyHolder state = mrPropertyHolders.Current();
@@ -495,14 +495,14 @@ namespace emfplushelper
             maWorldTransform = state.getTransformation();
             rState.setClipPolyPolygon( state.getClipPolyPolygon() );
             mappingChanged();
-            SAL_INFO("drawinglayer", "EMF+\t\tStack index: " << index << " found, maWorldTransform: " << maWorldTransform);
+            SAL_INFO("drawinglayer.emf", "EMF+\t\tStack index: " << index << " found, maWorldTransform: " << maWorldTransform);
         }
     }
 
     void EmfPlusHelperData::EMFPPlusDrawPolygon(const ::basegfx::B2DPolyPolygon& polygon, sal_uInt32 penIndex)
     {
         const EMFPPen* pen = dynamic_cast<EMFPPen*>(maEMFPObjects[penIndex & 0xff].get());
-        SAL_WARN_IF(!pen, "drawinglayer", "emf+ missing pen");
+        SAL_WARN_IF(!pen, "drawinglayer.emf", "emf+ missing pen");
 
         if (!(pen && polygon.count()))
             return;
@@ -519,7 +519,7 @@ namespace emfplushelper
         if (pen->penDataFlags & EmfPlusPenDataStartCap) // additional line cap information
         {
             lineCap = static_cast<css::drawing::LineCap>(EMFPPen::lcl_convertStrokeCap(pen->startCap));
-            SAL_WARN_IF(pen->startCap != pen->endCap, "drawinglayer", "emf+ pen uses different start and end cap");
+            SAL_WARN_IF(pen->startCap != pen->endCap, "drawinglayer.emf", "emf+ pen uses different start and end cap");
         }
 
         const double transformedPenWidth = maMapTransform.get(0, 0) * pen->penWidth;
@@ -593,7 +593,7 @@ namespace emfplushelper
 
         if ((pen->penDataFlags & EmfPlusPenDataCustomStartCap) && (pen->customStartCap->polygon.begin()->count() > 1))
         {
-            SAL_WARN("drawinglayer", "EMF+\tCustom Start Line Cap");
+            SAL_WARN("drawinglayer.emf", "EMF+\tCustom Start Line Cap");
             ::basegfx::B2DPolyPolygon startCapPolygon(pen->customStartCap->polygon);
 
             // get the gradient of the first line in the polypolygon
@@ -638,7 +638,7 @@ namespace emfplushelper
 
         if ((pen->penDataFlags & EmfPlusPenDataCustomEndCap) && (pen->customEndCap->polygon.begin()->count() > 1))
         {
-            SAL_WARN("drawinglayer", "EMF+\tCustom End Line Cap");
+            SAL_WARN("drawinglayer.emf", "EMF+\tCustom End Line Cap");
 
             ::basegfx::B2DPolyPolygon endCapPolygon(pen->customEndCap->polygon);
 
@@ -720,7 +720,7 @@ namespace emfplushelper
 
         if (isColor) // use Color
         {
-            SAL_INFO("drawinglayer", "EMF+\t\t Fill polygon, ARGB color: 0x" << std::hex << brushIndexOrColor << std::dec);
+            SAL_INFO("drawinglayer.emf", "EMF+\t\t Fill polygon, ARGB color: 0x" << std::hex << brushIndexOrColor << std::dec);
 
             // EMF Alpha (1 byte): An 8-bit unsigned integer that specifies the transparency of the background,
             // ranging from 0 for completely transparent to 0xFF for completely opaque.
@@ -734,7 +734,7 @@ namespace emfplushelper
         else // use Brush
         {
             EMFPBrush* brush = static_cast<EMFPBrush*>( maEMFPObjects[brushIndexOrColor & 0xff].get() );
-            SAL_INFO("drawinglayer", "EMF+\t\t Fill polygon, brush slot: " << brushIndexOrColor << " (brush type: " << (brush ? brush->GetType() : -1) << ")");
+            SAL_INFO("drawinglayer.emf", "EMF+\t\t Fill polygon, brush slot: " << brushIndexOrColor << " (brush type: " << (brush ? brush->GetType() : -1) << ")");
 
             // give up in case something wrong happened
             if( !brush )
@@ -793,14 +793,14 @@ namespace emfplushelper
             }
             else if (brush->type == BrushTypeTextureFill)
             {
-                SAL_WARN("drawinglayer", "EMF+\tTODO: implement BrushTypeTextureFill brush");
+                SAL_WARN("drawinglayer.emf", "EMF+\tTODO: implement BrushTypeTextureFill brush");
             }
             else if (brush->type == BrushTypePathGradient || brush->type == BrushTypeLinearGradient)
 
             {
                 if (brush->type == BrushTypePathGradient && !(brush->additionalFlags & 0x1))
                 {
-                    SAL_WARN("drawinglayer", "EMF+\t TODO Implement displaying BrushTypePathGradient with Boundary: ");
+                    SAL_WARN("drawinglayer.emf", "EMF+\t TODO Implement displaying BrushTypePathGradient with Boundary: ");
                 }
                 ::basegfx::B2DHomMatrix aTextureTransformation;
 
@@ -821,7 +821,7 @@ namespace emfplushelper
 
                 if (brush->blendPositions)
                 {
-                    SAL_INFO("drawinglayer", "EMF+\t\tUse blend");
+                    SAL_INFO("drawinglayer.emf", "EMF+\t\tUse blend");
 
                     // store the blendpoints in the vector
                     for (int i = 0; i < brush->blendPoints; i++)
@@ -846,7 +846,7 @@ namespace emfplushelper
                 }
                 else if (brush->colorblendPositions)
                 {
-                    SAL_INFO("drawinglayer", "EMF+\t\tUse color blend");
+                    SAL_INFO("drawinglayer.emf", "EMF+\t\tUse color blend");
 
                     // store the colorBlends in the vector
                     for (int i = 0; i < brush->colorblendPoints; i++)
@@ -979,11 +979,11 @@ namespace emfplushelper
         bIsGetDCProcessing(false)
     {
         rMS.ReadInt32(mnFrameLeft).ReadInt32(mnFrameTop).ReadInt32(mnFrameRight).ReadInt32(mnFrameBottom);
-        SAL_INFO("drawinglayer", "EMF+ picture frame: " << mnFrameLeft << "," << mnFrameTop << " - " << mnFrameRight << "," << mnFrameBottom);
+        SAL_INFO("drawinglayer.emf", "EMF+ picture frame: " << mnFrameLeft << "," << mnFrameTop << " - " << mnFrameRight << "," << mnFrameBottom);
         rMS.ReadInt32(mnPixX).ReadInt32(mnPixY).ReadInt32(mnMmX).ReadInt32(mnMmY);
-        SAL_INFO("drawinglayer", "EMF+ ref device pixel size: " << mnPixX << "x" << mnPixY << " mm size: " << mnMmX << "x" << mnMmY);
+        SAL_INFO("drawinglayer.emf", "EMF+ ref device pixel size: " << mnPixX << "x" << mnPixY << " mm size: " << mnMmX << "x" << mnMmY);
         readXForm(rMS, maBaseTransform);
-        SAL_INFO("drawinglayer", "EMF+ base transform: " << maBaseTransform);
+        SAL_INFO("drawinglayer.emf", "EMF+ base transform: " << maBaseTransform);
         mappingChanged();
     }
 
@@ -1046,7 +1046,7 @@ namespace emfplushelper
         sal_uInt64 length = rMS.GetSize();
 
         if (length < 12)
-            SAL_WARN("drawinglayer", "length is less than required header size");
+            SAL_WARN("drawinglayer.emf", "length is less than required header size");
 
         // 12 is minimal valid EMF+ record size; remaining bytes are padding
         while (length >= 12)
@@ -1061,29 +1061,29 @@ namespace emfplushelper
 
             if (size < 12)
             {
-                SAL_WARN("drawinglayer", "Size field is less than 12 bytes");
+                SAL_WARN("drawinglayer.emf", "Size field is less than 12 bytes");
                 break;
             }
             else if (size > length)
             {
-                SAL_WARN("drawinglayer", "Size field is greater than bytes left");
+                SAL_WARN("drawinglayer.emf", "Size field is greater than bytes left");
                 break;
             }
 
             if (dataSize > (size - 12))
             {
-                SAL_WARN("drawinglayer", "DataSize field is greater than Size-12");
+                SAL_WARN("drawinglayer.emf", "DataSize field is greater than Size-12");
                 break;
             }
 
-            SAL_INFO("drawinglayer", "EMF+ " << emfTypeToName(type) << " (0x" << std::hex << type << ")" << std::dec);
-            SAL_INFO("drawinglayer", "EMF+\t record size: " << size);
-            SAL_INFO("drawinglayer", "EMF+\t flags: 0x" << std::hex << flags << std::dec);
-            SAL_INFO("drawinglayer", "EMF+\t data size: " << dataSize);
+            SAL_INFO("drawinglayer.emf", "EMF+ " << emfTypeToName(type) << " (0x" << std::hex << type << ")" << std::dec);
+            SAL_INFO("drawinglayer.emf", "EMF+\t record size: " << size);
+            SAL_INFO("drawinglayer.emf", "EMF+\t flags: 0x" << std::hex << flags << std::dec);
+            SAL_INFO("drawinglayer.emf", "EMF+\t data size: " << dataSize);
 
             if (bIsGetDCProcessing)
             {
-                SAL_INFO("drawinglayer", "EMF+\t reset the current clipping region for the world space to infinity.");
+                SAL_INFO("drawinglayer.emf", "EMF+\t reset the current clipping region for the world space to infinity.");
                 wmfemfhelper::HandleNewClipRegion(::basegfx::B2DPolyPolygon(), mrTargetHolders, mrPropertyHolders);
                 bIsGetDCProcessing = false;
             }
@@ -1100,13 +1100,13 @@ namespace emfplushelper
 
                 // 1st 4 bytes are TotalObjectSize
                 mMStream.WriteBytes(static_cast<const char *>(rMS.GetData()) + rMS.Tell() + 4, dataSize - 4);
-                SAL_INFO("drawinglayer", "EMF+ read next object part size: " << size << " type: " << type << " flags: " << flags << " data size: " << dataSize);
+                SAL_INFO("drawinglayer.emf", "EMF+ read next object part size: " << size << " type: " << type << " flags: " << flags << " data size: " << dataSize);
             }
             else
             {
                 if (mbMultipart)
                 {
-                    SAL_INFO("drawinglayer", "EMF+ multipart record flags: " << mMFlags);
+                    SAL_INFO("drawinglayer.emf", "EMF+ multipart record flags: " << mMFlags);
                     mMStream.Seek(0);
                     processObjectRecord(mMStream, mMFlags, 0, true);
                 }
@@ -1123,11 +1123,11 @@ namespace emfplushelper
                         sal_uInt32 header, version;
 
                         rMS.ReadUInt32(header).ReadUInt32(version).ReadUInt32(mnHDPI).ReadUInt32(mnVDPI);
-                        SAL_INFO("drawinglayer", "EMF+\tHeader: 0x" << std::hex << header);
-                        SAL_INFO("drawinglayer", "EMF+\tVersion: " << std::dec << version);
-                        SAL_INFO("drawinglayer", "EMF+\tHorizontal DPI: " << mnHDPI);
-                        SAL_INFO("drawinglayer", "EMF+\tVertical DPI: " << mnVDPI);
-                        SAL_INFO("drawinglayer", "EMF+\tDual: " << ((flags & 1) ? "true" : "false"));
+                        SAL_INFO("drawinglayer.emf", "EMF+\tHeader: 0x" << std::hex << header);
+                        SAL_INFO("drawinglayer.emf", "EMF+\tVersion: " << std::dec << version);
+                        SAL_INFO("drawinglayer.emf", "EMF+\tHorizontal DPI: " << mnHDPI);
+                        SAL_INFO("drawinglayer.emf", "EMF+\tVertical DPI: " << mnVDPI);
+                        SAL_INFO("drawinglayer.emf", "EMF+\tDual: " << ((flags & 1) ? "true" : "false"));
                         break;
                     }
                     case EmfPlusRecordTypeEndOfFile:
@@ -1140,7 +1140,7 @@ namespace emfplushelper
                         unsigned char data;
                         OUString hexdata;
 
-                        SAL_INFO("drawinglayer", "EMF+\tDatasize: 0x" << std::hex << dataSize << std::dec);
+                        SAL_INFO("drawinglayer.emf", "EMF+\tDatasize: 0x" << std::hex << dataSize << std::dec);
 
                         for (sal_uInt32 i=0; i<dataSize; i++)
                         {
@@ -1156,14 +1156,14 @@ namespace emfplushelper
                             hexdata += "0x" + padding + OUString::number(data, 16) + " ";
                         }
 
-                        SAL_INFO("drawinglayer", "EMF+\t" << hexdata);
+                        SAL_INFO("drawinglayer.emf", "EMF+\t" << hexdata);
 #endif
                         break;
                     }
                     case EmfPlusRecordTypeGetDC:
                     {
                         bIsGetDCProcessing = true;
-                        SAL_INFO("drawinglayer", "EMF+\tAlready used in svtools wmf/emf filter parser");
+                        SAL_INFO("drawinglayer.emf", "EMF+\tAlready used in svtools wmf/emf filter parser");
                         break;
                     }
                     case EmfPlusRecordTypeObject:
@@ -1183,21 +1183,21 @@ namespace emfplushelper
                         if (type == EmfPlusRecordTypeFillPie)
                         {
                             rMS.ReadUInt32(brushIndexOrColor);
-                            SAL_INFO("drawinglayer", "EMF+\t FillPie colorOrIndex: " << brushIndexOrColor);
+                            SAL_INFO("drawinglayer.emf", "EMF+\t FillPie colorOrIndex: " << brushIndexOrColor);
                         }
                         else if (type == EmfPlusRecordTypeDrawPie)
                         {
-                            SAL_INFO("drawinglayer", "EMF+\t DrawPie");
+                            SAL_INFO("drawinglayer.emf", "EMF+\t DrawPie");
                         }
                         else
                         {
-                            SAL_INFO("drawinglayer", "EMF+\t DrawArc");
+                            SAL_INFO("drawinglayer.emf", "EMF+\t DrawArc");
                         }
 
                         rMS.ReadFloat(startAngle).ReadFloat(sweepAngle);
                         float dx, dy, dw, dh;
                         ReadRectangle(rMS, dx, dy, dw, dh, bool(flags & 0x4000));
-                        SAL_INFO("drawinglayer", "EMF+\t RectData: " << dx << "," << dy << " " << dw << "x" << dh);
+                        SAL_INFO("drawinglayer.emf", "EMF+\t RectData: " << dx << "," << dy << " " << dw << "x" << dh);
                         startAngle = basegfx::deg2rad(startAngle);
                         sweepAngle = basegfx::deg2rad(sweepAngle);
                         float endAngle = startAngle + sweepAngle;
@@ -1218,7 +1218,7 @@ namespace emfplushelper
                             std::swap(endAngle, startAngle);
                         }
 
-                        SAL_INFO("drawinglayer", "EMF+\t Adjusted angles: start " <<
+                        SAL_INFO("drawinglayer.emf", "EMF+\t Adjusted angles: start " <<
                             basegfx::rad2deg(startAngle) << ", end: " << basegfx::rad2deg(endAngle) <<
                             " startAngle: " << startAngle << " sweepAngle: " << sweepAngle);
                         const ::basegfx::B2DPoint centerPoint(dx + 0.5 * dw, dy + 0.5 * dh);
@@ -1244,13 +1244,13 @@ namespace emfplushelper
                         sal_uInt32 index = flags & 0xff;
                         sal_uInt32 brushIndexOrColor;
                         rMS.ReadUInt32(brushIndexOrColor);
-                        SAL_INFO("drawinglayer", "EMF+ FillPath slot: " << index);
+                        SAL_INFO("drawinglayer.emf", "EMF+ FillPath slot: " << index);
 
                         EMFPPath* path = dynamic_cast<EMFPPath*>(maEMFPObjects[index].get());
                         if (path)
                             EMFPPlusFillPolygon(path->GetPolygon(*this), flags & 0x8000, brushIndexOrColor);
                         else
-                            SAL_WARN("drawinglayer", "EMF+\tEmfPlusRecordTypeFillPath missing path");
+                            SAL_WARN("drawinglayer.emf", "EMF+\tEmfPlusRecordTypeFillPath missing path");
                     }
                     break;
                     case EmfPlusRecordTypeFillRegion:
@@ -1258,7 +1258,7 @@ namespace emfplushelper
                         sal_uInt32 index = flags & 0xff;
                         sal_uInt32 brushIndexOrColor;
                         rMS.ReadUInt32(brushIndexOrColor);
-                        SAL_INFO("drawinglayer", "EMF+\t FillRegion slot: " << index);
+                        SAL_INFO("drawinglayer.emf", "EMF+\t FillRegion slot: " << index);
 
                         EMFPPlusFillPolygon(static_cast<EMFPRegion*>(maEMFPObjects[flags & 0xff].get())->regionPolyPolygon, flags & 0x8000, brushIndexOrColor);
                     }
@@ -1276,10 +1276,10 @@ namespace emfplushelper
                             rMS.ReadUInt32(brushIndexOrColor);
                         }
 
-                        SAL_INFO("drawinglayer", "EMF+\t " << (type == EmfPlusRecordTypeFillEllipse ? "Fill" : "Draw") << "Ellipse slot: " << (flags & 0xff));
+                        SAL_INFO("drawinglayer.emf", "EMF+\t " << (type == EmfPlusRecordTypeFillEllipse ? "Fill" : "Draw") << "Ellipse slot: " << (flags & 0xff));
                         float dx, dy, dw, dh;
                         ReadRectangle(rMS, dx, dy, dw, dh, bool(flags & 0x4000));
-                        SAL_INFO("drawinglayer", "EMF+\t RectData: " << dx << "," << dy << " " << dw << "x" << dh);
+                        SAL_INFO("drawinglayer.emf", "EMF+\t RectData: " << dx << "," << dy << " " << dw << "x" << dh);
                         ::basegfx::B2DPolyPolygon polyPolygon(
                             ::basegfx::utils::createPolygonFromEllipse(::basegfx::B2DPoint(dx + 0.5 * dw, dy + 0.5 * dh),
                                                                        0.5 * dw, 0.5 * dh));
@@ -1301,13 +1301,13 @@ namespace emfplushelper
 
                         if (EmfPlusRecordTypeFillRects == type)
                         {
-                            SAL_INFO("drawinglayer", "EMF+\t FillRects");
+                            SAL_INFO("drawinglayer.emf", "EMF+\t FillRects");
                             rMS.ReadUInt32(brushIndexOrColor);
-                            SAL_INFO("drawinglayer", "EMF+\t" << (isColor ? "color" : "brush index") << ": 0x" << std::hex << brushIndexOrColor << std::dec);
+                            SAL_INFO("drawinglayer.emf", "EMF+\t" << (isColor ? "color" : "brush index") << ": 0x" << std::hex << brushIndexOrColor << std::dec);
                         }
                         else
                         {
-                            SAL_INFO("drawinglayer", "EMF+\t DrawRects");
+                            SAL_INFO("drawinglayer.emf", "EMF+\t DrawRects");
                         }
 
                         rMS.ReadInt32(rectangles);
@@ -1323,7 +1323,7 @@ namespace emfplushelper
                             polygon.append(Map(x, y + height));
                             polygon.setClosed(true);
 
-                            SAL_INFO("drawinglayer", "EMF+\t\t rectangle: " << x << ", "<< y << " " << width << "x" << height);
+                            SAL_INFO("drawinglayer.emf", "EMF+\t\t rectangle: " << x << ", "<< y << " " << width << "x" << height);
 
                             ::basegfx::B2DPolyPolygon polyPolygon(polygon);
                             if (type == EmfPlusRecordTypeFillRects)
@@ -1341,8 +1341,8 @@ namespace emfplushelper
 
                         rMS.ReadUInt32(brushIndexOrColor);
                         rMS.ReadInt32(points);
-                        SAL_INFO("drawinglayer", "EMF+\t FillPolygon in slot: " << index << " points: " << points);
-                        SAL_INFO("drawinglayer", "EMF+\t " << ((flags & 0x8000) ? "Color" : "Brush index") << " : 0x" << std::hex << brushIndexOrColor << std::dec);
+                        SAL_INFO("drawinglayer.emf", "EMF+\t FillPolygon in slot: " << index << " points: " << points);
+                        SAL_INFO("drawinglayer.emf", "EMF+\t " << ((flags & 0x8000) ? "Color" : "Brush index") << " : 0x" << std::hex << brushIndexOrColor << std::dec);
 
                         EMFPPath path(points, true);
                         path.Read(rMS, flags);
@@ -1355,7 +1355,7 @@ namespace emfplushelper
                     {
                         sal_uInt32 points;
                         rMS.ReadUInt32(points);
-                        SAL_INFO("drawinglayer", "EMF+\t DrawLines in slot: " << (flags & 0xff) << " points: " << points);
+                        SAL_INFO("drawinglayer.emf", "EMF+\t DrawLines in slot: " << (flags & 0xff) << " points: " << points);
                         EMFPPath path(points, true);
                         path.Read(rMS, flags);
 
@@ -1369,13 +1369,13 @@ namespace emfplushelper
                     {
                         sal_uInt32 penIndex;
                         rMS.ReadUInt32(penIndex);
-                        SAL_INFO("drawinglayer", "EMF+\t Pen: " << penIndex);
+                        SAL_INFO("drawinglayer.emf", "EMF+\t Pen: " << penIndex);
 
                         EMFPPath* path = dynamic_cast<EMFPPath*>(maEMFPObjects[flags & 0xff].get());
                         if (path)
                             EMFPPlusDrawPolygon(path->GetPolygon(*this), penIndex);
                         else
-                            SAL_WARN("drawinglayer", "\t\tEmfPlusRecordTypeDrawPath missing path");
+                            SAL_WARN("drawinglayer.emf", "\t\tEmfPlusRecordTypeDrawPath missing path");
 
                         break;
                     }
@@ -1386,13 +1386,13 @@ namespace emfplushelper
                         ::basegfx::B2DPoint aStartPoint, aControlPointA, aControlPointB, aEndPoint;
                         ::basegfx::B2DPolygon aPolygon;
                         rMS.ReadUInt32(aCount);
-                        SAL_INFO("drawinglayer", "EMF+\t DrawBeziers slot: " << (flags & 0xff));
-                        SAL_INFO("drawinglayer", "EMF+\t Number of points: " << aCount);
-                        SAL_WARN_IF((aCount - 1) % 3 != 0, "drawinglayer", "EMF+\t Bezier Draw not support number of points other than 4, 7, 10, 13, 16...");
+                        SAL_INFO("drawinglayer.emf", "EMF+\t DrawBeziers slot: " << (flags & 0xff));
+                        SAL_INFO("drawinglayer.emf", "EMF+\t Number of points: " << aCount);
+                        SAL_WARN_IF((aCount - 1) % 3 != 0, "drawinglayer.emf", "EMF+\t Bezier Draw not support number of points other than 4, 7, 10, 13, 16...");
 
                         if (aCount < 4)
                         {
-                            SAL_WARN("drawinglayer", "EMF+\t Bezier Draw does not support less than 4 points. Number of points: " << aCount);
+                            SAL_WARN("drawinglayer.emf", "EMF+\t Bezier Draw does not support less than 4 points. Number of points: " << aCount);
                             break;
                         }
 
@@ -1407,7 +1407,7 @@ namespace emfplushelper
                             ReadPoint(rMS, x3, y3, flags);
                             ReadPoint(rMS, x4, y4, flags);
 
-                            SAL_INFO("drawinglayer", "EMF+\t Bezier points: " << x1 << "," << y1 << " " << x2 << "," << y2 << " " << x3 << "," << y3 << " " << x4 << "," << y4);
+                            SAL_INFO("drawinglayer.emf", "EMF+\t Bezier points: " << x1 << "," << y1 << " " << x2 << "," << y2 << " " << x3 << "," << y3 << " " << x4 << "," << y4);
 
                             aStartPoint = Map(x1, y1);
                             aControlPointA = Map(x2, y2);
@@ -1431,8 +1431,8 @@ namespace emfplushelper
                         sal_uInt32 imageAttributesId;
                         sal_Int32 sourceUnit;
                         rMS.ReadUInt32(imageAttributesId).ReadInt32(sourceUnit);
-                        SAL_INFO("drawinglayer", "EMF+\t " << (type == EmfPlusRecordTypeDrawImagePoints ? "DrawImagePoints" : "DrawImage") << " image attributes Id: " << imageAttributesId << " source unit: " << sourceUnit);
-                        SAL_INFO("drawinglayer", "EMF+\t TODO: use image attributes");
+                        SAL_INFO("drawinglayer.emf", "EMF+\t " << (type == EmfPlusRecordTypeDrawImagePoints ? "DrawImagePoints" : "DrawImage") << " image attributes Id: " << imageAttributesId << " source unit: " << sourceUnit);
+                        SAL_INFO("drawinglayer.emf", "EMF+\t TODO: use image attributes");
 
                         // For DrawImage and DrawImagePoints, source unit of measurement type must be 1 pixel
                         if (sourceUnit == UnitTypePixel && maEMFPObjects[flags & 0xff])
@@ -1441,7 +1441,7 @@ namespace emfplushelper
                             float sx, sy, sw, sh;
                             ReadRectangle(rMS, sx, sy, sw, sh);
                             ::tools::Rectangle aSource(Point(sx, sy), Size(sw, sh));
-                            SAL_INFO("drawinglayer", "EMF+\t " << (type == EmfPlusRecordTypeDrawImagePoints ? "DrawImagePoints" : "DrawImage") << " source rectangle: " << sx << "," << sy << " " << sw << "x" << sh);
+                            SAL_INFO("drawinglayer.emf", "EMF+\t " << (type == EmfPlusRecordTypeDrawImagePoints ? "DrawImagePoints" : "DrawImage") << " source rectangle: " << sx << "," << sy << " " << sw << "x" << sh);
                             ::basegfx::B2DPoint aDstPoint;
                             ::basegfx::B2DSize aDstSize;
 
@@ -1461,7 +1461,7 @@ namespace emfplushelper
                                     ReadPoint(rMS, x2, y2, flags); // upper-right
                                     ReadPoint(rMS, x3, y3, flags); // lower-left
 
-                                    SAL_INFO("drawinglayer", "EMF+\t destination points: P1:" << x1 << "," << y1 << " P2:" << x2 << "," << y2 << " P3:" << x3 << "," << y3);
+                                    SAL_INFO("drawinglayer.emf", "EMF+\t destination points: P1:" << x1 << "," << y1 << " P2:" << x2 << "," << y2 << " P3:" << x3 << "," << y3);
 
                                     aDstPoint = ::basegfx::B2DPoint(x1, y1);
                                     aDstSize = ::basegfx::B2DSize(x2 - x1, y3 - y1);
@@ -1470,7 +1470,7 @@ namespace emfplushelper
                                 }
                                 else
                                 {
-                                    SAL_WARN("drawinglayer", "EMF+\t DrawImagePoints Wrong EMF+ file. Expected 3 points, received: "<< aCount);
+                                    SAL_WARN("drawinglayer.emf", "EMF+\t DrawImagePoints Wrong EMF+ file. Expected 3 points, received: "<< aCount);
                                     break;
                                 }
                             }
@@ -1478,7 +1478,7 @@ namespace emfplushelper
                             {
                                 float dx, dy, dw, dh;
                                 ReadRectangle(rMS, dx, dy, dw, dh, bool(flags & 0x4000));
-                                SAL_INFO("drawinglayer", "EMF+\t destination rectangle: " << dx << "," << dy << " " << dw << "x" << dh);
+                                SAL_INFO("drawinglayer.emf", "EMF+\t destination rectangle: " << dx << "," << dy << " " << dw << "x" << dh);
                                 aDstPoint = ::basegfx::B2DPoint(dx, dy);
                                 aDstSize = ::basegfx::B2DSize(dw, dh);
                             }
@@ -1497,7 +1497,7 @@ namespace emfplushelper
                                 BitmapEx aBmp(image.graphic.GetBitmapEx());
                                 aBmp.Crop(aSource);
                                 Size aSize(aBmp.GetSizePixel());
-                                SAL_INFO("drawinglayer", "EMF+\t Bitmap size: " << aSize.Width() << "x" << aSize.Height());
+                                SAL_INFO("drawinglayer.emf", "EMF+\t Bitmap size: " << aSize.Width() << "x" << aSize.Height());
                                 if (aSize.Width() > 0 && aSize.Height() > 0)
                                 {
                                     mrTargetHolders.Current().append(
@@ -1507,7 +1507,7 @@ namespace emfplushelper
                                 }
                                 else
                                 {
-                                    SAL_WARN("drawinglayer", "EMF+\t warning: empty bitmap");
+                                    SAL_WARN("drawinglayer.emf", "EMF+\t warning: empty bitmap");
                                     break;
                                 }
                             }
@@ -1521,7 +1521,7 @@ namespace emfplushelper
                         }
                         else
                         {
-                            SAL_WARN("drawinglayer", "EMF+\tDrawImage(Points) Wrong EMF+ file. Only Unit Type Pixel is support by EMF+ specification for DrawImage(Points)");
+                            SAL_WARN("drawinglayer.emf", "EMF+\tDrawImage(Points) Wrong EMF+ file. Only Unit Type Pixel is support by EMF+ specification for DrawImage(Points)");
                         }
                         break;
                     }
@@ -1531,10 +1531,10 @@ namespace emfplushelper
                         sal_uInt32 formatId;
                         sal_uInt32 stringLength;
                         rMS.ReadUInt32(brushId).ReadUInt32(formatId).ReadUInt32(stringLength);
-                        SAL_INFO("drawinglayer", "EMF+\t FontId: " << OUString::number(flags & 0xFF));
-                        SAL_INFO("drawinglayer", "EMF+\t BrushId: " << BrushIDToString(flags, brushId));
-                        SAL_INFO("drawinglayer", "EMF+\t FormatId: " << formatId);
-                        SAL_INFO("drawinglayer", "EMF+\t Length: " << stringLength);
+                        SAL_INFO("drawinglayer.emf", "EMF+\t FontId: " << OUString::number(flags & 0xFF));
+                        SAL_INFO("drawinglayer.emf", "EMF+\t BrushId: " << BrushIDToString(flags, brushId));
+                        SAL_INFO("drawinglayer.emf", "EMF+\t FormatId: " << formatId);
+                        SAL_INFO("drawinglayer.emf", "EMF+\t Length: " << stringLength);
 
                         if (flags & 0x8000)
                         {
@@ -1542,10 +1542,10 @@ namespace emfplushelper
                             float lx, ly, lw, lh;
                             rMS.ReadFloat(lx).ReadFloat(ly).ReadFloat(lw).ReadFloat(lh);
 
-                            SAL_INFO("drawinglayer", "EMF+\t DrawString layoutRect: " << lx << "," << ly << " - " << lw << "x" << lh);
+                            SAL_INFO("drawinglayer.emf", "EMF+\t DrawString layoutRect: " << lx << "," << ly << " - " << lw << "x" << lh);
                             // parse the string
                             const OUString text = read_uInt16s_ToOUString(rMS, stringLength);
-                            SAL_INFO("drawinglayer", "EMF+\t DrawString string: " << text);
+                            SAL_INFO("drawinglayer.emf", "EMF+\t DrawString string: " << text);
                             // get the stringFormat from the Object table ( this is OPTIONAL and may be nullptr )
                             const EMFPStringFormat *stringFormat = dynamic_cast<EMFPStringFormat*>(maEMFPObjects[formatId & 0xff].get());
                             // get the font from the flags
@@ -1572,7 +1572,7 @@ namespace emfplushelper
                             double stringAlignmentHorizontalOffset = 0.0;
                             if (stringFormat)
                             {
-                                SAL_WARN_IF(stringFormat->DirectionRightToLeft(), "drawinglayer", "EMF+\t DrawString Alignment TODO For a right-to-left layout rectangle, the origin should be at the upper right.");
+                                SAL_WARN_IF(stringFormat->DirectionRightToLeft(), "drawinglayer.emf", "EMF+\t DrawString Alignment TODO For a right-to-left layout rectangle, the origin should be at the upper right.");
                                 if (stringFormat->stringAlignment == StringAlignmentNear)
                                 // Alignment is to the left side of the layout rectangle (lx, ly, lw, lh)
                                 {
@@ -1681,18 +1681,18 @@ namespace emfplushelper
                         }
                         else
                         {
-                            SAL_WARN("drawinglayer", "EMF+\t DrawString TODO - drawing with brush not yet supported");
+                            SAL_WARN("drawinglayer.emf", "EMF+\t DrawString TODO - drawing with brush not yet supported");
                         }
                         break;
                     }
                     case EmfPlusRecordTypeSetPageTransform:
                     {
                         rMS.ReadFloat(mfPageScale);
-                        SAL_INFO("drawinglayer", "EMF+\t Scale: " << mfPageScale << " unit: " << UnitTypeToString(flags));
+                        SAL_INFO("drawinglayer.emf", "EMF+\t Scale: " << mfPageScale << " unit: " << UnitTypeToString(flags));
 
                         if ((flags == UnitTypeDisplay) || (flags == UnitTypeWorld))
                         {
-                            SAL_WARN("drawinglayer", "EMF+\t file error. UnitTypeDisplay and UnitTypeWorld are not supported by SetPageTransform in EMF+ specification.");
+                            SAL_WARN("drawinglayer.emf", "EMF+\t file error. UnitTypeDisplay and UnitTypeWorld are not supported by SetPageTransform in EMF+ specification.");
                         }
                         else
                         {
@@ -1705,7 +1705,7 @@ namespace emfplushelper
                     case EmfPlusRecordTypeSetRenderingOrigin:
                     {
                         rMS.ReadInt32(mnOriginX).ReadInt32(mnOriginY);
-                        SAL_INFO("drawinglayer", "EMF+\t SetRenderingOrigin, [x,y]: " << mnOriginX << "," << mnOriginY);
+                        SAL_INFO("drawinglayer.emf", "EMF+\t SetRenderingOrigin, [x,y]: " << mnOriginX << "," << mnOriginY);
                         break;
                     }
                     case EmfPlusRecordTypeSetTextContrast:
@@ -1716,51 +1716,51 @@ namespace emfplushelper
                         mbSetTextContrast = true;
                         mnTextContrast = flags & 0xFFF;
                         SAL_WARN_IF(mnTextContrast > UPPERGAMMA || mnTextContrast < LOWERGAMMA,
-                            "drawinglayer", "EMF+\t Gamma value is not with bounds 1000 to 2200, value is " << mnTextContrast);
+                            "drawinglayer.emf", "EMF+\t Gamma value is not with bounds 1000 to 2200, value is " << mnTextContrast);
                         mnTextContrast = std::min(mnTextContrast, UPPERGAMMA);
                         mnTextContrast = std::max(mnTextContrast, LOWERGAMMA);
-                        SAL_INFO("drawinglayer", "EMF+\t Text contrast: " << (mnTextContrast / 1000) << " gamma");
+                        SAL_INFO("drawinglayer.emf", "EMF+\t Text contrast: " << (mnTextContrast / 1000) << " gamma");
                         break;
                     }
                     case EmfPlusRecordTypeSetTextRenderingHint:
                     {
                         sal_uInt8 nTextRenderingHint = (flags & 0xFF) >> 1;
-                        SAL_INFO("drawinglayer", "EMF+\t Text rendering hint: " << TextRenderingHintToString(nTextRenderingHint));
-                        SAL_WARN("drawinglayer", "EMF+\t TODO SetTextRenderingHint");
+                        SAL_INFO("drawinglayer.emf", "EMF+\t Text rendering hint: " << TextRenderingHintToString(nTextRenderingHint));
+                        SAL_WARN("drawinglayer.emf", "EMF+\t TODO SetTextRenderingHint");
                         break;
                     }
                     case EmfPlusRecordTypeSetAntiAliasMode:
                     {
                         bool bUseAntiAlias = (flags & 0x0001);
                         sal_uInt8 nSmoothingMode = (flags & 0xFE00) >> 1;
-                        SAL_INFO("drawinglayer", "EMF+\t Antialiasing: " << (bUseAntiAlias ? "enabled" : "disabled"));
-                        SAL_INFO("drawinglayer", "EMF+\t Smoothing mode: " << SmoothingModeToString(nSmoothingMode));
-                        SAL_WARN("drawinglayer", "EMF+\t TODO SetAntiAliasMode");
+                        SAL_INFO("drawinglayer.emf", "EMF+\t Antialiasing: " << (bUseAntiAlias ? "enabled" : "disabled"));
+                        SAL_INFO("drawinglayer.emf", "EMF+\t Smoothing mode: " << SmoothingModeToString(nSmoothingMode));
+                        SAL_WARN("drawinglayer.emf", "EMF+\t TODO SetAntiAliasMode");
                         break;
                     }
                     case EmfPlusRecordTypeSetInterpolationMode:
                     {
                         sal_uInt16 nInterpolationMode = flags & 0xFF;
-                        SAL_INFO("drawinglayer", "EMF+\t Interpolation mode: " << InterpolationModeToString(nInterpolationMode));
-                        SAL_WARN("drawinglayer", "EMF+\t TODO InterpolationMode");
+                        SAL_INFO("drawinglayer.emf", "EMF+\t Interpolation mode: " << InterpolationModeToString(nInterpolationMode));
+                        SAL_WARN("drawinglayer.emf", "EMF+\t TODO InterpolationMode");
                         break;
                     }
                     case EmfPlusRecordTypeSetPixelOffsetMode:
                     {
-                        SAL_INFO("drawinglayer", "EMF+\t Pixel offset mode: " << PixelOffsetModeToString(flags));
-                        SAL_WARN("drawinglayer", "EMF+\t TODO SetPixelOffsetMode");
+                        SAL_INFO("drawinglayer.emf", "EMF+\t Pixel offset mode: " << PixelOffsetModeToString(flags));
+                        SAL_WARN("drawinglayer.emf", "EMF+\t TODO SetPixelOffsetMode");
                         break;
                     }
                     case EmfPlusRecordTypeSetCompositingQuality:
                     {
-                        SAL_INFO("drawinglayer", "EMF+\t TODO SetCompositingQuality");
+                        SAL_INFO("drawinglayer.emf", "EMF+\t TODO SetCompositingQuality");
                         break;
                     }
                     case EmfPlusRecordTypeSave:
                     {
                         sal_uInt32 stackIndex;
                         rMS.ReadUInt32(stackIndex);
-                        SAL_INFO("drawinglayer", "EMF+\t Save stack index: " << stackIndex);
+                        SAL_INFO("drawinglayer.emf", "EMF+\t Save stack index: " << stackIndex);
 
                         GraphicStatePush(mGSStack, stackIndex);
 
@@ -1770,7 +1770,7 @@ namespace emfplushelper
                     {
                         sal_uInt32 stackIndex;
                         rMS.ReadUInt32(stackIndex);
-                        SAL_INFO("drawinglayer", "EMF+\t Restore stack index: " << stackIndex);
+                        SAL_INFO("drawinglayer.emf", "EMF+\t Restore stack index: " << stackIndex);
 
                         GraphicStatePop(mGSStack, stackIndex, mrPropertyHolders.Current());
                         break;
@@ -1779,19 +1779,19 @@ namespace emfplushelper
                     {
                         float dx, dy, dw, dh;
                         ReadRectangle(rMS, dx, dy, dw, dh);
-                        SAL_INFO("drawinglayer", "EMF+\t Dest RectData: " << dx << "," << dy << " " << dw << "x" << dh);
+                        SAL_INFO("drawinglayer.emf", "EMF+\t Dest RectData: " << dx << "," << dy << " " << dw << "x" << dh);
 
                         float sx, sy, sw, sh;
                         ReadRectangle(rMS, sx, sy, sw, sh);
-                        SAL_INFO("drawinglayer", "EMF+\t Source RectData: " << sx << "," << sy << " " << sw << "x" << sh);
+                        SAL_INFO("drawinglayer.emf", "EMF+\t Source RectData: " << sx << "," << sy << " " << sw << "x" << sh);
 
                         sal_uInt32 stackIndex;
                         rMS.ReadUInt32(stackIndex);
-                        SAL_INFO("drawinglayer", "EMF+\t Begin Container stack index: " << stackIndex << ", PageUnit: " << flags);
+                        SAL_INFO("drawinglayer.emf", "EMF+\t Begin Container stack index: " << stackIndex << ", PageUnit: " << flags);
 
                         if ((flags == UnitTypeDisplay) || (flags == UnitTypeWorld))
                         {
-                            SAL_WARN("drawinglayer", "EMF+\t file error. UnitTypeDisplay and UnitTypeWorld are not supported by BeginContainer in EMF+ specification.");
+                            SAL_WARN("drawinglayer.emf", "EMF+\t file error. UnitTypeDisplay and UnitTypeWorld are not supported by BeginContainer in EMF+ specification.");
                             break;
                         }
                         const float aPageScaleX = getUnitToPixelMultiplier(static_cast<UnitType>(flags), mnHDPI);
@@ -1808,7 +1808,7 @@ namespace emfplushelper
                     {
                         sal_uInt32 stackIndex;
                         rMS.ReadUInt32(stackIndex);
-                        SAL_INFO("drawinglayer", "EMF+\t Begin Container No Params stack index: " << stackIndex);
+                        SAL_INFO("drawinglayer.emf", "EMF+\t Begin Container No Params stack index: " << stackIndex);
 
                         GraphicStatePush(mGSContainerStack, stackIndex);
                         break;
@@ -1817,33 +1817,33 @@ namespace emfplushelper
                     {
                         sal_uInt32 stackIndex;
                         rMS.ReadUInt32(stackIndex);
-                        SAL_INFO("drawinglayer", "EMF+\t End Container stack index: " << stackIndex);
+                        SAL_INFO("drawinglayer.emf", "EMF+\t End Container stack index: " << stackIndex);
 
                         GraphicStatePop(mGSContainerStack, stackIndex, mrPropertyHolders.Current());
                         break;
                     }
                     case EmfPlusRecordTypeSetWorldTransform:
                     {
-                        SAL_INFO("drawinglayer", "EMF+\t SetWorldTransform, Post multiply: " << bool(flags & 0x2000));
+                        SAL_INFO("drawinglayer.emf", "EMF+\t SetWorldTransform, Post multiply: " << bool(flags & 0x2000));
                         readXForm(rMS, maWorldTransform);
                         mappingChanged();
-                        SAL_INFO("drawinglayer", "EMF+\t\t: " << maWorldTransform);
+                        SAL_INFO("drawinglayer.emf", "EMF+\t\t: " << maWorldTransform);
                         break;
                     }
                     case EmfPlusRecordTypeResetWorldTransform:
                     {
                         maWorldTransform.identity();
-                        SAL_INFO("drawinglayer", "EMF+\t World transform: " << maWorldTransform);
+                        SAL_INFO("drawinglayer.emf", "EMF+\t World transform: " << maWorldTransform);
                         mappingChanged();
                         break;
                     }
                     case EmfPlusRecordTypeMultiplyWorldTransform:
                     {
-                        SAL_INFO("drawinglayer", "EMF+\t MultiplyWorldTransform, post multiply: " << bool(flags & 0x2000));
+                        SAL_INFO("drawinglayer.emf", "EMF+\t MultiplyWorldTransform, post multiply: " << bool(flags & 0x2000));
                         basegfx::B2DHomMatrix transform;
                         readXForm(rMS, transform);
 
-                        SAL_INFO("drawinglayer",
+                        SAL_INFO("drawinglayer.emf",
                                  "EMF+\t Transform matrix: " << transform);
 
                         if (flags & 0x2000)
@@ -1860,13 +1860,13 @@ namespace emfplushelper
 
                         mappingChanged();
 
-                        SAL_INFO("drawinglayer",
+                        SAL_INFO("drawinglayer.emf",
                                  "EMF+\t World transform matrix: " << maWorldTransform);
                         break;
                     }
                     case EmfPlusRecordTypeTranslateWorldTransform:
                     {
-                        SAL_INFO("drawinglayer", "EMF+\t TranslateWorldTransform, Post multiply: " << bool(flags & 0x2000));
+                        SAL_INFO("drawinglayer.emf", "EMF+\t TranslateWorldTransform, Post multiply: " << bool(flags & 0x2000));
 
                         basegfx::B2DHomMatrix transform;
                         float eDx, eDy;
@@ -1874,7 +1874,7 @@ namespace emfplushelper
                         transform.set(0, 2, eDx);
                         transform.set(1, 2, eDy);
 
-                        SAL_INFO("drawinglayer",
+                        SAL_INFO("drawinglayer.emf",
                             "EMF+\t Translate matrix: " << transform);
 
                         if (flags & 0x2000)
@@ -1891,7 +1891,7 @@ namespace emfplushelper
 
                         mappingChanged();
 
-                        SAL_INFO("drawinglayer",
+                        SAL_INFO("drawinglayer.emf",
                                  "EMF+\t World transform matrix: " << maWorldTransform);
                         break;
                     }
@@ -1903,9 +1903,9 @@ namespace emfplushelper
                         transform.set(0, 0, eSx);
                         transform.set(1, 1, eSy);
 
-                        SAL_INFO("drawinglayer", "EMF+\t ScaleWorldTransform Sx: " << eSx <<
+                        SAL_INFO("drawinglayer.emf", "EMF+\t ScaleWorldTransform Sx: " << eSx <<
                                  " Sy: " << eSy << ", Post multiply:" << bool(flags & 0x2000));
-                        SAL_INFO("drawinglayer",
+                        SAL_INFO("drawinglayer.emf",
                                  "EMF+\t World transform matrix: " << maWorldTransform);
 
                         if (flags & 0x2000)
@@ -1922,7 +1922,7 @@ namespace emfplushelper
 
                         mappingChanged();
 
-                        SAL_INFO("drawinglayer",
+                        SAL_INFO("drawinglayer.emf",
                                  "EMF+\t World transform matrix: " << maWorldTransform);
                         break;
                     }
@@ -1932,20 +1932,20 @@ namespace emfplushelper
                         float eAngle;
                         rMS.ReadFloat(eAngle);
 
-                        SAL_INFO("drawinglayer", "EMF+\t RotateWorldTransform Angle: " << eAngle <<
+                        SAL_INFO("drawinglayer.emf", "EMF+\t RotateWorldTransform Angle: " << eAngle <<
                                  ", post multiply: " << bool(flags & 0x2000));
                         // Skipping flags & 0x2000
                         // For rotation transformation there is no difference between post and pre multiply
                         maWorldTransform.rotate(basegfx::deg2rad(eAngle));
                         mappingChanged();
 
-                        SAL_INFO("drawinglayer",
+                        SAL_INFO("drawinglayer.emf",
                                 "EMF+\t " << maWorldTransform);
                         break;
                     }
                     case EmfPlusRecordTypeResetClip:
                     {
-                        SAL_INFO("drawinglayer", "EMF+ ResetClip");
+                        SAL_INFO("drawinglayer.emf", "EMF+ ResetClip");
                         // We don't need to read anything more, as Size needs to be set 0x0000000C
                         // and DataSize must be set to 0.
 
@@ -1957,11 +1957,11 @@ namespace emfplushelper
                     {
                         int combineMode = (flags >> 8) & 0xf;
 
-                        SAL_INFO("drawinglayer", "EMF+\t SetClipRect combine mode: " << combineMode);
+                        SAL_INFO("drawinglayer.emf", "EMF+\t SetClipRect combine mode: " << combineMode);
 
                         float dx, dy, dw, dh;
                         ReadRectangle(rMS, dx, dy, dw, dh);
-                        SAL_INFO("drawinglayer", "EMF+\t RectData: " << dx << "," << dy << " " << dw << "x" << dh);
+                        SAL_INFO("drawinglayer.emf", "EMF+\t RectData: " << dx << "," << dy << " " << dw << "x" << dh);
                         ::basegfx::B2DPoint mappedPoint1(Map(dx, dy));
                         ::basegfx::B2DPoint mappedPoint2(Map(dx + dw, dy + dh));
 
@@ -1980,13 +1980,13 @@ namespace emfplushelper
                     case EmfPlusRecordTypeSetClipPath:
                     {
                         int combineMode = (flags >> 8) & 0xf;
-                        SAL_INFO("drawinglayer", "EMF+\t SetClipPath combine mode: " << combineMode);
-                        SAL_INFO("drawinglayer", "EMF+\t Path in slot: " << (flags & 0xff));
+                        SAL_INFO("drawinglayer.emf", "EMF+\t SetClipPath combine mode: " << combineMode);
+                        SAL_INFO("drawinglayer.emf", "EMF+\t Path in slot: " << (flags & 0xff));
 
                         EMFPPath *path = static_cast<EMFPPath*>(maEMFPObjects[flags & 0xff].get());
                         if (!path)
                         {
-                            SAL_WARN("drawinglayer", "EMF+\t TODO Unable to find path in slot: " << (flags & 0xff));
+                            SAL_WARN("drawinglayer.emf", "EMF+\t TODO Unable to find path in slot: " << (flags & 0xff));
                             break;
                         }
 
@@ -1999,12 +1999,12 @@ namespace emfplushelper
                     case EmfPlusRecordTypeSetClipRegion:
                     {
                         int combineMode = (flags >> 8) & 0xf;
-                        SAL_INFO("drawinglayer", "EMF+\t Region in slot: " << (flags & 0xff));
-                        SAL_INFO("drawinglayer", "EMF+\t Combine mode: " << combineMode);
+                        SAL_INFO("drawinglayer.emf", "EMF+\t Region in slot: " << (flags & 0xff));
+                        SAL_INFO("drawinglayer.emf", "EMF+\t Combine mode: " << combineMode);
                         EMFPRegion *region = static_cast<EMFPRegion*>(maEMFPObjects[flags & 0xff].get());
                         if (!region)
                         {
-                            SAL_WARN("drawinglayer", "EMF+\t TODO Unable to find region in slot: " << (flags & 0xff));
+                            SAL_WARN("drawinglayer.emf", "EMF+\t TODO Unable to find region in slot: " << (flags & 0xff));
                             break;
                         }
 
@@ -2016,12 +2016,12 @@ namespace emfplushelper
                     {
                         float dx, dy;
                         rMS.ReadFloat(dx).ReadFloat(dy);
-                        SAL_INFO("drawinglayer", "EMF+\tOffset x:" << dx << ", y:" << dy);
+                        SAL_INFO("drawinglayer.emf", "EMF+\tOffset x:" << dx << ", y:" << dy);
 
                         basegfx::B2DPolyPolygon aPolyPolygon(
                                     mrPropertyHolders.Current().getClipPolyPolygon());
 
-                        SAL_INFO("drawinglayer",
+                        SAL_INFO("drawinglayer.emf",
                                  "EMF+\t PolyPolygon before translate: " << aPolyPolygon);
 
                         basegfx::B2DPoint aOffset = Map(dx, dy);
@@ -2030,7 +2030,7 @@ namespace emfplushelper
                         transformMatrix.set(1, 2, aOffset.getY());
                         aPolyPolygon.transform(transformMatrix);
 
-                        SAL_INFO("drawinglayer",
+                        SAL_INFO("drawinglayer.emf",
                                  "EMF+\t PolyPolygon after translate: " << aPolyPolygon <<
                                  ", mapped offset x" << aOffset.getX() << ", mapped offset y" << aOffset.getY());
                         HandleNewClipRegion(aPolyPolygon, mrTargetHolders, mrPropertyHolders);
@@ -2043,22 +2043,22 @@ namespace emfplushelper
                         sal_uInt32 hasMatrix;
                         sal_uInt32 glyphsCount;
                         rMS.ReadUInt32(brushIndexOrColor).ReadUInt32(optionFlags).ReadUInt32(hasMatrix).ReadUInt32(glyphsCount);
-                        SAL_INFO("drawinglayer", "EMF+\t " << ((flags & 0x8000) ? "Color" : "Brush index") << ": 0x" << std::hex << brushIndexOrColor << std::dec);
-                        SAL_INFO("drawinglayer", "EMF+\t Option flags: 0x" << std::hex << optionFlags << std::dec);
-                        SAL_INFO("drawinglayer", "EMF+\t Has matrix: " << hasMatrix);
-                        SAL_INFO("drawinglayer", "EMF+\t Glyphs: " << glyphsCount);
+                        SAL_INFO("drawinglayer.emf", "EMF+\t " << ((flags & 0x8000) ? "Color" : "Brush index") << ": 0x" << std::hex << brushIndexOrColor << std::dec);
+                        SAL_INFO("drawinglayer.emf", "EMF+\t Option flags: 0x" << std::hex << optionFlags << std::dec);
+                        SAL_INFO("drawinglayer.emf", "EMF+\t Has matrix: " << hasMatrix);
+                        SAL_INFO("drawinglayer.emf", "EMF+\t Glyphs: " << glyphsCount);
 
                         if ((optionFlags & 1) && glyphsCount > 0)
                         {
                             std::unique_ptr<float[]> charsPosX(new float[glyphsCount]);
                             std::unique_ptr<float[]> charsPosY(new float[glyphsCount]);
                             OUString text = read_uInt16s_ToOUString(rMS, glyphsCount);
-                            SAL_INFO("drawinglayer", "EMF+\t DrawDriverString string: " << text);
+                            SAL_INFO("drawinglayer.emf", "EMF+\t DrawDriverString string: " << text);
 
                             for (sal_uInt32 i = 0; i<glyphsCount; i++)
                             {
                                 rMS.ReadFloat(charsPosX[i]).ReadFloat(charsPosY[i]);
-                                SAL_INFO("drawinglayer", "EMF+\t\t glyphPosition[" << i << "]: " << charsPosX[i] << "," << charsPosY[i]);
+                                SAL_INFO("drawinglayer.emf", "EMF+\t\t glyphPosition[" << i << "]: " << charsPosX[i] << "," << charsPosY[i]);
                             }
 
                             basegfx::B2DHomMatrix transform;
@@ -2066,7 +2066,7 @@ namespace emfplushelper
                             if (hasMatrix)
                             {
                                 readXForm(rMS, transform);
-                                SAL_INFO("drawinglayer", "EMF+\tmatrix: " << transform);
+                                SAL_INFO("drawinglayer.emf", "EMF+\tmatrix: " << transform);
                             }
 
                             // get the font from the flags
@@ -2169,13 +2169,13 @@ namespace emfplushelper
                         }
                         else
                         {
-                            SAL_WARN("drawinglayer", "EMF+\tTODO: fonts (non-unicode glyphs chars)");
+                            SAL_WARN("drawinglayer.emf", "EMF+\tTODO: fonts (non-unicode glyphs chars)");
                         }
                         break;
                     }
                     default:
                     {
-                        SAL_WARN("drawinglayer", "EMF+ TODO unhandled record type: 0x" << std::hex << type << std::dec);
+                        SAL_WARN("drawinglayer.emf", "EMF+ TODO unhandled record type: 0x" << std::hex << type << std::dec);
                     }
                 }
             }
@@ -2188,7 +2188,7 @@ namespace emfplushelper
             }
             else
             {
-                SAL_WARN("drawinglayer", "ImplRenderer::processEMFPlus: "
+                SAL_WARN("drawinglayer.emf", "ImplRenderer::processEMFPlus: "
                     "size " << size << " > length " << length);
                 length = 0;
             }
diff --git a/drawinglayer/source/tools/emfpimage.cxx b/drawinglayer/source/tools/emfpimage.cxx
index 502eb2b74f0f..a3300168e7f6 100644
--- a/drawinglayer/source/tools/emfpimage.cxx
+++ b/drawinglayer/source/tools/emfpimage.cxx
@@ -26,20 +26,20 @@ namespace emfplushelper
     {
         sal_uInt32 header, bitmapType;
         s.ReadUInt32(header).ReadUInt32(type);
-        SAL_INFO("drawinglayer", "EMF+\timage\nEMF+\theader: 0x" << std::hex << header << " type: " << type << std::dec);
+        SAL_INFO("drawinglayer.emf", "EMF+\timage\nEMF+\theader: 0x" << std::hex << header << " type: " << type << std::dec);
 
         if (ImageDataTypeBitmap == type)
         {
             // bitmap
             s.ReadInt32(width).ReadInt32(height).ReadInt32(stride).ReadUInt32(pixelFormat).ReadUInt32(bitmapType);
-            SAL_INFO("drawinglayer", "EMF+\tbitmap width: " << width << " height: " << height << " stride: " << stride << " pixelFormat: 0x" << std::hex << pixelFormat << " bitmapType: 0x" << bitmapType << std::dec);
+            SAL_INFO("drawinglayer.emf", "EMF+\tbitmap width: " << width << " height: " << height << " stride: " << stride << " pixelFormat: 0x" << std::hex << pixelFormat << " bitmapType: 0x" << bitmapType << std::dec);
 
             if ((bitmapType != 0) || (width == 0))
             {
                 // non native formats
                 GraphicFilter filter;
                 filter.ImportGraphic(graphic, OUString(), s);
-                SAL_INFO("drawinglayer", "EMF+\tbitmap width: " << graphic.GetSizePixel().Width() << " height: " << graphic.GetSizePixel().Height());
+                SAL_INFO("drawinglayer.emf", "EMF+\tbitmap width: " << graphic.GetSizePixel().Width() << " height: " << graphic.GetSizePixel().Height());
             }
         }
         else if (ImageDataTypeMetafile == type)
@@ -53,7 +53,7 @@ namespace emfplushelper
             else
                 dataSize -= 16;
 
-            SAL_INFO("drawinglayer", "EMF+\tmetafile type: " << mfType << " dataSize: " << mfSize << " real size calculated from record dataSize: " << dataSize);
+            SAL_INFO("drawinglayer.emf", "EMF+\tmetafile type: " << mfType << " dataSize: " << mfSize << " real size calculated from record dataSize: " << dataSize);
 
             GraphicFilter filter;
             // workaround buggy metafiles, which have wrong mfSize set (n#705956 for example)
diff --git a/drawinglayer/source/tools/emfpimageattributes.cxx b/drawinglayer/source/tools/emfpimageattributes.cxx
index 1cb72b080ab8..a78261c0c330 100644
--- a/drawinglayer/source/tools/emfpimageattributes.cxx
+++ b/drawinglayer/source/tools/emfpimageattributes.cxx
@@ -58,16 +58,16 @@ void EMFPImageAttributes::Read(SvStream& s)
     clampColor.SetBlue(clampColorBlue);
     clampColor.SetAlpha(255 - clampColorAlpha);
 
-    SAL_INFO("drawinglayer", "EMF+\timage attributes");
-    SAL_WARN_IF((reserved1 != 0) || (reserved2 != 0), "drawinglayer",
+    SAL_INFO("drawinglayer.emf", "EMF+\timage attributes");
+    SAL_WARN_IF((reserved1 != 0) || (reserved2 != 0), "drawinglayer.emf",
                 "Reserved field(s) not zero - reserved1: " << std::hex << reserved1
                                                            << " reserved2: " << reserved2);
     SAL_WARN_IF((objectClamp != EmpPlusRectClamp) && (objectClamp != EmpPlusBitmapClamp),
-                "drawinglayer", "Invalid object clamp - set to" << std::hex << objectClamp);
-    SAL_INFO("drawinglayer", "EMF+\t image graphics version: 0x"
-                                 << std::hex << graphicsVersion << " wrap mode: " << wrapMode
-                                 << " clamp color: " << clampColor
-                                 << " object clamp: " << objectClamp);
+                "drawinglayer.emf", "Invalid object clamp - set to" << std::hex << objectClamp);
+    SAL_INFO("drawinglayer.emf", "EMF+\t image graphics version: 0x"
+                                     << std::hex << graphicsVersion << " wrap mode: " << wrapMode
+                                     << " clamp color: " << clampColor
+                                     << " object clamp: " << objectClamp);
 }
 }
 
diff --git a/drawinglayer/source/tools/emfppath.cxx b/drawinglayer/source/tools/emfppath.cxx
index 1f16c292cad8..bfb92e0bd4a7 100644
--- a/drawinglayer/source/tools/emfppath.cxx
+++ b/drawinglayer/source/tools/emfppath.cxx
@@ -89,7 +89,7 @@ namespace emfplushelper
                 sal_Int32 y = GetEmfPlusInteger(s);
                 pPoints [i*2] = x;
                 pPoints [i*2 + 1] = y;
-                SAL_INFO("drawinglayer", "EMF+\t\t\tEmfPlusPointR [x,y]: " << x << ", " << y);
+                SAL_INFO("drawinglayer.emf", "EMF+\t\t\tEmfPlusPointR [x,y]: " << x << ", " << y);
             }
             else if (pathFlags & 0x4000)
             {
@@ -97,7 +97,7 @@ namespace emfplushelper
                 sal_Int16 x, y;
 
                 s.ReadInt16( x ).ReadInt16( y );
-                SAL_INFO ("drawinglayer", "EMF+\t\t\tEmfPlusPoint [x,y]: " << x << "," << y);
+                SAL_INFO ("drawinglayer.emf", "EMF+\t\t\tEmfPlusPoint [x,y]: " << x << "," << y);
                 pPoints [i*2] = x;
                 pPoints [i*2 + 1] = y;
             }
@@ -105,7 +105,7 @@ namespace emfplushelper
             {
                 // EMFPlusPointF: stored in Single (float) format
                 s.ReadFloat( pPoints [i*2] ).ReadFloat( pPoints [i*2 + 1] );
-                SAL_INFO ("drawinglayer", "EMF+\t EMFPlusPointF [x,y]: " << pPoints [i*2] << "," << pPoints [i*2 + 1]);
+                SAL_INFO ("drawinglayer.emf", "EMF+\t EMFPlusPointF [x,y]: " << pPoints [i*2] << "," << pPoints [i*2 + 1]);
             }
         }
 
@@ -114,7 +114,7 @@ namespace emfplushelper
             for (int i = 0; i < nPoints; i++)
             {
                 s.ReadUChar(pPointTypes[i]);
-                SAL_INFO("drawinglayer", "EMF+\tpoint type: " << static_cast<int>(pPointTypes[i]));
+                SAL_INFO("drawinglayer.emf", "EMF+\tpoint type: " << static_cast<int>(pPointTypes[i]));
             }
         }
 
@@ -151,7 +151,7 @@ namespace emfplushelper
                     if (((i - last_normal )% 3) == 1)
                     {
                         polygon.setNextControlPoint (p - 1, mapped);
-                        SAL_INFO ("drawinglayer", "EMF+\t\tPolygon append next: " << p - 1 << " mapped: " << mapped.getX () << "," << mapped.getY ());
+                        SAL_INFO ("drawinglayer.emf", "EMF+\t\tPolygon append next: " << p - 1 << " mapped: " << mapped.getX () << "," << mapped.getY ());
                         continue;
                     }
                     else if (((i - last_normal) % 3) == 2)
@@ -168,12 +168,12 @@ namespace emfplushelper
             }
 
             polygon.append (mapped);
-            SAL_INFO ("drawinglayer", "EMF+\t\tPolygon append point: " << pPoints [i*2] << "," << pPoints [i*2 + 1] << " mapped: " << mapped.getX () << ":" << mapped.getY ());
+            SAL_INFO ("drawinglayer.emf", "EMF+\t\tPolygon append point: " << pPoints [i*2] << "," << pPoints [i*2 + 1] << " mapped: " << mapped.getX () << ":" << mapped.getY ());
 
             if (hasPrev)
             {
                 polygon.setPrevControlPoint (p, prev);
-                SAL_INFO ("drawinglayer", "EMF+\t\tPolygon append  prev: " << p << " mapped: " << prev.getX () << "," << prev.getY ());
+                SAL_INFO ("drawinglayer.emf", "EMF+\t\tPolygon append  prev: " << p << " mapped: " << prev.getX () << "," << prev.getY ());
                 hasPrev = false;
             }
 
@@ -184,7 +184,7 @@ namespace emfplushelper
                 // closed polygon
                 polygon.setClosed (true);
                 aPolygon.append (polygon);
-                SAL_INFO ("drawinglayer", "EMF+\t\tClose polygon");
+                SAL_INFO ("drawinglayer.emf", "EMF+\t\tClose polygon");
                 last_normal = i + 1;
                 p = 0;
                 polygon.clear ();
@@ -204,17 +204,17 @@ namespace emfplushelper
 #if OSL_DEBUG_LEVEL > 1
             for (unsigned int i=0; i<aPolygon.count(); i++) {
                 polygon = aPolygon.getB2DPolygon(i);
-                SAL_INFO ("drawinglayer", "EMF+\t\tPolygon: " << i);
+                SAL_INFO ("drawinglayer.emf", "EMF+\t\tPolygon: " << i);
                 for (unsigned int j=0; j<polygon.count(); j++) {
                     ::basegfx::B2DPoint point = polygon.getB2DPoint(j);
-                    SAL_INFO ("drawinglayer", "EMF+\t\t\tPoint: " << point.getX() << "," << point.getY());
+                    SAL_INFO ("drawinglayer.emf", "EMF+\t\t\tPoint: " << point.getX() << "," << point.getY());
                     if (polygon.isPrevControlPointUsed(j)) {
                         point = polygon.getPrevControlPoint(j);
-                        SAL_INFO ("drawinglayer", "EMF+\t\t\tPrev: " << point.getX() << "," << point.getY());
+                        SAL_INFO ("drawinglayer.emf", "EMF+\t\t\tPrev: " << point.getX() << "," << point.getY());
                     }
                     if (polygon.isNextControlPointUsed(j)) {
                         point = polygon.getNextControlPoint(j);
-                        SAL_INFO ("drawinglayer", "EMF+\t\t\tNext: " << point.getX() << "," << point.getY());
+                        SAL_INFO ("drawinglayer.emf", "EMF+\t\t\tNext: " << point.getX() << "," << point.getY());
                     }
                 }
             }
diff --git a/drawinglayer/source/tools/emfppen.cxx b/drawinglayer/source/tools/emfppen.cxx
index 60500b6bf7ec..62532ce84b8f 100644
--- a/drawinglayer/source/tools/emfppen.cxx
+++ b/drawinglayer/source/tools/emfppen.cxx
@@ -208,11 +208,11 @@ namespace emfplushelper
         sal_uInt32 graphicsVersion, penType;
         int i;
         s.ReadUInt32(graphicsVersion).ReadUInt32(penType).ReadUInt32(penDataFlags).ReadUInt32(penUnit).ReadFloat(penWidth);
-        SAL_INFO("drawinglayer", "EMF+\t\tGraphics version: 0x" << std::hex << graphicsVersion);
-        SAL_INFO("drawinglayer", "EMF+\t\tType: " << penType);
-        SAL_INFO("drawinglayer", "EMF+\t\tPen data flags: 0x" << penDataFlags << PenDataFlagsToString(penDataFlags));
-        SAL_INFO("drawinglayer", "EMF+\t\tUnit: " << UnitTypeToString(penUnit));
-        SAL_INFO("drawinglayer", "EMF+\t\tWidth: " << std::dec << penWidth);
+        SAL_INFO("drawinglayer.emf", "EMF+\t\tGraphics version: 0x" << std::hex << graphicsVersion);
+        SAL_INFO("drawinglayer.emf", "EMF+\t\tType: " << penType);
+        SAL_INFO("drawinglayer.emf", "EMF+\t\tPen data flags: 0x" << penDataFlags << PenDataFlagsToString(penDataFlags));
+        SAL_INFO("drawinglayer.emf", "EMF+\t\tUnit: " << UnitTypeToString(penUnit));
+        SAL_INFO("drawinglayer.emf", "EMF+\t\tWidth: " << std::dec << penWidth);
 
         // If a zero width is specified, a minimum value must be used, which is determined by the units
         if (penWidth == 0.0)
@@ -224,13 +224,13 @@ namespace emfplushelper
         if (penDataFlags & PenDataTransform)
         {
             EmfPlusHelperData::readXForm(s, pen_transformation);
-            SAL_WARN("drawinglayer", "EMF+\t\t TODO PenDataTransform: " << pen_transformation);
+            SAL_WARN("drawinglayer.emf", "EMF+\t\t TODO PenDataTransform: " << pen_transformation);
         }
 
         if (penDataFlags & PenDataStartCap)
         {
             s.ReadInt32(startCap);
-            SAL_INFO("drawinglayer", "EMF+\t\tstartCap: " << LineCapTypeToString(startCap) << " (0x" << std::hex << startCap << ")");
+            SAL_INFO("drawinglayer.emf", "EMF+\t\tstartCap: " << LineCapTypeToString(startCap) << " (0x" << std::hex << startCap << ")");
         }
         else
         {
@@ -240,7 +240,7 @@ namespace emfplushelper
         if (penDataFlags & PenDataEndCap)
         {
             s.ReadInt32(endCap);
-            SAL_INFO("drawinglayer", "EMF+\t\tendCap: " << LineCapTypeToString(endCap) << " (0x" << std::hex << startCap << ")");
+            SAL_INFO("drawinglayer.emf", "EMF+\t\tendCap: " << LineCapTypeToString(endCap) << " (0x" << std::hex << startCap << ")");
         }
         else
         {
@@ -250,7 +250,7 @@ namespace emfplushelper
         if (penDataFlags & PenDataJoin)
         {
             s.ReadInt32(lineJoin);
-            SAL_WARN("drawinglayer", "EMF+\t\tTODO PenDataJoin: " << LineJoinTypeToString(lineJoin) << " (0x" << std::hex << lineJoin << ")");
+            SAL_WARN("drawinglayer.emf", "EMF+\t\tTODO PenDataJoin: " << LineJoinTypeToString(lineJoin) << " (0x" << std::hex << lineJoin << ")");
         }
         else
         {
@@ -260,7 +260,7 @@ namespace emfplushelper
         if (penDataFlags & PenDataMiterLimit)
         {
             s.ReadFloat(miterLimit);
-            SAL_WARN("drawinglayer", "EMF+\t\tTODO PenDataMiterLimit: " << std::dec << miterLimit);
+            SAL_WARN("drawinglayer.emf", "EMF+\t\tTODO PenDataMiterLimit: " << std::dec << miterLimit);
         }
         else
         {
@@ -270,7 +270,7 @@ namespace emfplushelper
         if (penDataFlags & PenDataLineStyle)
         {
             s.ReadInt32(dashStyle);
-            SAL_INFO("drawinglayer", "EMF+\t\tdashStyle: " << DashedLineCapTypeToString(dashStyle) << " (0x" << std::hex << dashStyle << ")");
+            SAL_INFO("drawinglayer.emf", "EMF+\t\tdashStyle: " << DashedLineCapTypeToString(dashStyle) << " (0x" << std::hex << dashStyle << ")");
         }
         else
         {
@@ -280,7 +280,7 @@ namespace emfplushelper
         if (penDataFlags & PenDataDashedLineCap)
         {
             s.ReadInt32(dashCap);
-            SAL_WARN("drawinglayer", "EMF+\t\t TODO PenDataDashedLineCap: 0x" << std::hex << dashCap);
+            SAL_WARN("drawinglayer.emf", "EMF+\t\t TODO PenDataDashedLineCap: 0x" << std::hex << dashCap);
         }
         else
         {
@@ -290,7 +290,7 @@ namespace emfplushelper
         if (penDataFlags & PenDataDashedLineOffset)
         {
             s.ReadFloat(dashOffset);
-            SAL_WARN("drawinglayer", "EMF+\t\t TODO PenDataDashedLineOffset: 0x" << std::hex << dashOffset);
+            SAL_WARN("drawinglayer.emf", "EMF+\t\t TODO PenDataDashedLineOffset: 0x" << std::hex << dashOffset);
         }
         else
         {
@@ -303,7 +303,7 @@ namespace emfplushelper
             sal_Int32 dashPatternLen;
 
             s.ReadInt32(dashPatternLen);
-            SAL_INFO("drawinglayer", "EMF+\t\t\tdashPatternLen: " << dashPatternLen);
+            SAL_INFO("drawinglayer.emf", "EMF+\t\t\tdashPatternLen: " << dashPatternLen);
 
             if (dashPatternLen<0 || o3tl::make_unsigned(dashPatternLen)>SAL_MAX_INT32 / sizeof(float))
             {
@@ -315,14 +315,14 @@ namespace emfplushelper
             for (i = 0; i < dashPatternLen; i++)
             {
                 s.ReadFloat(dashPattern[i]);
-                SAL_INFO("drawinglayer", "EMF+\t\t\t\tdashPattern[" << i << "]: " << dashPattern[i]);
+                SAL_INFO("drawinglayer.emf", "EMF+\t\t\t\tdashPattern[" << i << "]: " << dashPattern[i]);
             }
         }
 
         if (penDataFlags & PenDataAlignment)
         {
             s.ReadInt32(alignment);
-            SAL_WARN("drawinglayer", "EMF+\t\t\tTODO PenDataAlignment: " << PenAlignmentToString(alignment) << " (0x" << std::hex << alignment << ")");
+            SAL_WARN("drawinglayer.emf", "EMF+\t\t\tTODO PenDataAlignment: " << PenAlignmentToString(alignment) << " (0x" << std::hex << alignment << ")");
         }
         else
         {
@@ -331,7 +331,7 @@ namespace emfplushelper
 
         if (penDataFlags & PenDataCompoundLine)
         {
-            SAL_WARN("drawinglayer", "EMF+\t\t\tTODO PenDataCompoundLine");
+            SAL_WARN("drawinglayer.emf", "EMF+\t\t\tTODO PenDataCompoundLine");
             sal_Int32 compoundArrayLen;
             s.ReadInt32(compoundArrayLen);
 
@@ -345,14 +345,14 @@ namespace emfplushelper
             for (i = 0; i < compoundArrayLen; i++)
             {
                 s.ReadFloat(compoundArray[i]);
-                SAL_INFO("drawinglayer", "EMF+\t\t\t\tcompoundArray[" << i << "]: " << compoundArray[i]);
+                SAL_INFO("drawinglayer.emf", "EMF+\t\t\t\tcompoundArray[" << i << "]: " << compoundArray[i]);
             }
         }
 
         if (penDataFlags & PenDataCustomStartCap)
         {
             s.ReadInt32(customStartCapLen);
-            SAL_INFO("drawinglayer", "EMF+\t\t\tcustomStartCapLen: " << customStartCapLen);
+            SAL_INFO("drawinglayer.emf", "EMF+\t\t\tcustomStartCapLen: " << customStartCapLen);
             sal_uInt64 const pos = s.Tell();
 
             customStartCap.reset( new EMFPCustomLineCap() );
@@ -369,7 +369,7 @@ namespace emfplushelper
         if (penDataFlags & PenDataCustomEndCap)
         {
             s.ReadInt32(customEndCapLen);
-            SAL_INFO("drawinglayer", "EMF+\t\t\tcustomEndCapLen: " << customEndCapLen);
+            SAL_INFO("drawinglayer.emf", "EMF+\t\t\tcustomEndCapLen: " << customEndCapLen);
             sal_uInt64 const pos = s.Tell();
 
             customEndCap.reset( new EMFPCustomLineCap() );
diff --git a/drawinglayer/source/tools/emfpregion.cxx b/drawinglayer/source/tools/emfpregion.cxx
index 4856d3b08fef..9fcced337733 100644
--- a/drawinglayer/source/tools/emfpregion.cxx
+++ b/drawinglayer/source/tools/emfpregion.cxx
@@ -46,7 +46,7 @@ namespace emfplushelper
         sal_uInt32 dataType;
         ::basegfx::B2DPolyPolygon polygon;
         s.ReadUInt32(dataType);
-        SAL_INFO("drawinglayer", "EMF+\t Region node data type 0x" << std::hex << dataType << std::dec);
+        SAL_INFO("drawinglayer.emf", "EMF+\t Region node data type 0x" << std::hex << dataType << std::dec);
 
         switch (dataType)
         {
@@ -65,7 +65,7 @@ namespace emfplushelper
         {
             float dx, dy, dw, dh;
             s.ReadFloat(dx).ReadFloat(dy).ReadFloat(dw).ReadFloat(dh);
-            SAL_INFO("drawinglayer", "EMF+\t\t RegionNodeDataTypeRect x:" << dx << ", y:" << dy <<
+            SAL_INFO("drawinglayer.emf", "EMF+\t\t RegionNodeDataTypeRect x:" << dx << ", y:" << dy <<
                      ", width:" << dw << ", height:" << dh);
 
             const ::basegfx::B2DPoint mappedStartPoint(rR.Map(dx, dy));
@@ -83,13 +83,13 @@ namespace emfplushelper
         {
             sal_Int32 pathLength;
             s.ReadInt32(pathLength);
-            SAL_INFO("drawinglayer", "EMF+\t\t RegionNodeDataTypePath, Path Length: " << pathLength << " bytes");
+            SAL_INFO("drawinglayer.emf", "EMF+\t\t RegionNodeDataTypePath, Path Length: " << pathLength << " bytes");
 
             sal_uInt32 header, pathFlags;
             sal_Int32 points;
 
             s.ReadUInt32(header).ReadInt32(points).ReadUInt32(pathFlags);
-            SAL_INFO("drawinglayer", "EMF+\t\t header: 0x" << std::hex << header <<
+            SAL_INFO("drawinglayer.emf", "EMF+\t\t header: 0x" << std::hex << header <<
                      " points: " << std::dec << points << " additional flags: 0x" << std::hex << pathFlags << std::dec);
 
             EMFPPath path(points);
@@ -99,21 +99,21 @@ namespace emfplushelper
         }
         case RegionNodeDataTypeEmpty:
         {
-            SAL_INFO("drawinglayer", "EMF+\t\t RegionNodeDataTypeEmpty");
-            SAL_WARN("drawinglayer", "EMF+\t\t TODO we need to set empty polygon here");
+            SAL_INFO("drawinglayer.emf", "EMF+\t\t RegionNodeDataTypeEmpty");
+            SAL_WARN("drawinglayer.emf", "EMF+\t\t TODO we need to set empty polygon here");
             polygon = ::basegfx::B2DPolyPolygon();
 
             break;
         }
         case RegionNodeDataTypeInfinite:
         {
-            SAL_INFO("drawinglayer", "EMF+\t\t RegionNodeDataTypeInfinite");
+            SAL_INFO("drawinglayer.emf", "EMF+\t\t RegionNodeDataTypeInfinite");
             polygon = ::basegfx::B2DPolyPolygon();
             break;
         }
         default:
         {
-            SAL_WARN("drawinglayer", "EMF+\t\t Unhandled region type: 0x" << std::hex << dataType << std::dec);
+            SAL_WARN("drawinglayer.emf", "EMF+\t\t Unhandled region type: 0x" << std::hex << dataType << std::dec);
             polygon = ::basegfx::B2DPolyPolygon();
         }
         }
@@ -125,7 +125,7 @@ namespace emfplushelper
         sal_uInt32 header, count;
         s.ReadUInt32(header).ReadUInt32(count);
         // An array should be RegionNodeCount+1 of EmfPlusRegionNode objects.
-        SAL_INFO("drawinglayer", "EMF+\t version: 0x" << std::hex << header << std::dec << ", region node count: " << count);
+        SAL_INFO("drawinglayer.emf", "EMF+\t version: 0x" << std::hex << header << std::dec << ", region node count: " << count);
 
         regionPolyPolygon = ReadRegionNode(s, rR);
     }
diff --git a/drawinglayer/source/tools/emfpstringformat.cxx b/drawinglayer/source/tools/emfpstringformat.cxx
index a523ab80e531..63cc42471b3b 100644
--- a/drawinglayer/source/tools/emfpstringformat.cxx
+++ b/drawinglayer/source/tools/emfpstringformat.cxx
@@ -199,36 +199,36 @@ namespace emfplushelper
         // keep only the last 16 bits of language
         language >>= 16;
         digitLanguage >>= 16;
-        SAL_WARN_IF((header >> 12) != 0xdbc01, "drawinglayer", "Invalid header - not 0xdbc01");
-        SAL_INFO("drawinglayer", "EMF+\tString format");
-        SAL_INFO("drawinglayer", "EMF+\t\tHeader: 0x" << std::hex << (header >> 12));
-        SAL_INFO("drawinglayer", "EMF+\t\tVersion: 0x" << (header & 0x1fff) << std::dec);
-        SAL_INFO("drawinglayer", "EMF+\t\tStringFormatFlags: " << StringFormatFlags(stringFormatFlags));
-        SAL_INFO("drawinglayer", "EMF+\t\tLanguage: sublangid: 0x" << std::hex << (language >> 10) << ", primarylangid: 0x" << (language & 0xF800));
-        SAL_INFO("drawinglayer", "EMF+\t\tLineAlign: " << StringAlignmentString(lineAlign));
-        SAL_INFO("drawinglayer", "EMF+\t\tDigitSubstitution: " << DigitSubstitutionString(digitSubstitution));
-        SAL_INFO("drawinglayer", "EMF+\t\tDigitLanguage: sublangid: 0x" << std::hex << (digitLanguage >> 10) << ", primarylangid: 0x" << (digitLanguage & 0xF800));
-        SAL_INFO("drawinglayer", "EMF+\t\tFirstTabOffset: " << firstTabOffset);
-        SAL_INFO("drawinglayer", "EMF+\t\tHotkeyPrefix: " << HotkeyPrefixString(hotkeyPrefix));
-        SAL_INFO("drawinglayer", "EMF+\t\tLeadingMargin: " << leadingMargin);
-        SAL_INFO("drawinglayer", "EMF+\t\tTrailingMargin: " << trailingMargin);
-        SAL_INFO("drawinglayer", "EMF+\t\tTracking: " << tracking);
-        SAL_INFO("drawinglayer", "EMF+\t\tTrimming: " << StringTrimmingString(trimming));
-        SAL_INFO("drawinglayer", "EMF+\t\tTabStopCount: " << tabStopCount);
-        SAL_INFO("drawinglayer", "EMF+\t\tRangeCount: " << rangeCount);
-
-        SAL_WARN_IF(stringAlignment != StringAlignment::StringAlignmentNear, "drawinglayer", "EMF+\t TODO EMFPStringFormat:StringAlignment");
-        SAL_WARN_IF(lineAlign != StringAlignment::StringAlignmentNear, "drawinglayer", "EMF+\t TODO EMFPStringFormat:lineAlign");
+        SAL_WARN_IF((header >> 12) != 0xdbc01, "drawinglayer.emf", "Invalid header - not 0xdbc01");
+        SAL_INFO("drawinglayer.emf", "EMF+\tString format");
+        SAL_INFO("drawinglayer.emf", "EMF+\t\tHeader: 0x" << std::hex << (header >> 12));
+        SAL_INFO("drawinglayer.emf", "EMF+\t\tVersion: 0x" << (header & 0x1fff) << std::dec);
+        SAL_INFO("drawinglayer.emf", "EMF+\t\tStringFormatFlags: " << StringFormatFlags(stringFormatFlags));
+        SAL_INFO("drawinglayer.emf", "EMF+\t\tLanguage: sublangid: 0x" << std::hex << (language >> 10) << ", primarylangid: 0x" << (language & 0xF800));
+        SAL_INFO("drawinglayer.emf", "EMF+\t\tLineAlign: " << StringAlignmentString(lineAlign));
+        SAL_INFO("drawinglayer.emf", "EMF+\t\tDigitSubstitution: " << DigitSubstitutionString(digitSubstitution));
+        SAL_INFO("drawinglayer.emf", "EMF+\t\tDigitLanguage: sublangid: 0x" << std::hex << (digitLanguage >> 10) << ", primarylangid: 0x" << (digitLanguage & 0xF800));
+        SAL_INFO("drawinglayer.emf", "EMF+\t\tFirstTabOffset: " << firstTabOffset);
+        SAL_INFO("drawinglayer.emf", "EMF+\t\tHotkeyPrefix: " << HotkeyPrefixString(hotkeyPrefix));
+        SAL_INFO("drawinglayer.emf", "EMF+\t\tLeadingMargin: " << leadingMargin);
+        SAL_INFO("drawinglayer.emf", "EMF+\t\tTrailingMargin: " << trailingMargin);
+        SAL_INFO("drawinglayer.emf", "EMF+\t\tTracking: " << tracking);
+        SAL_INFO("drawinglayer.emf", "EMF+\t\tTrimming: " << StringTrimmingString(trimming));
+        SAL_INFO("drawinglayer.emf", "EMF+\t\tTabStopCount: " << tabStopCount);
+        SAL_INFO("drawinglayer.emf", "EMF+\t\tRangeCount: " << rangeCount);
+
+        SAL_WARN_IF(stringAlignment != StringAlignment::StringAlignmentNear, "drawinglayer.emf", "EMF+\t TODO EMFPStringFormat:StringAlignment");
+        SAL_WARN_IF(lineAlign != StringAlignment::StringAlignmentNear, "drawinglayer.emf", "EMF+\t TODO EMFPStringFormat:lineAlign");
         SAL_WARN_IF(digitSubstitution != StringDigitSubstitution::StringDigitSubstitutionNone,
-                        "drawinglayer", "EMF+\t TODO EMFPStringFormat:digitSubstitution");
-        SAL_WARN_IF(firstTabOffset != 0.0, "drawinglayer", "EMF+\t TODO EMFPStringFormat:firstTabOffset");
-        SAL_WARN_IF(hotkeyPrefix != HotkeyPrefix::HotkeyPrefixNone, "drawinglayer", "EMF+\t TODO EMFPStringFormat:hotkeyPrefix");
-        SAL_WARN_IF(leadingMargin != 0.0, "drawinglayer", "EMF+\t TODO EMFPStringFormat:leadingMargin");
-        SAL_WARN_IF(trailingMargin != 0.0, "drawinglayer", "EMF+\t TODO EMFPStringFormat:trailingMargin");
-        SAL_WARN_IF(tracking != 1.0, "drawinglayer", "EMF+\t TODO EMFPStringFormat:tracking");
-        SAL_WARN_IF(trimming != StringTrimming::StringTrimmingNone, "drawinglayer", "EMF+\t TODO EMFPStringFormat:trimming");
-        SAL_WARN_IF(tabStopCount, "drawinglayer", "EMF+\t TODO EMFPStringFormat:tabStopCount");
-        SAL_WARN_IF(rangeCount, "drawinglayer", "EMF+\t TODO EMFPStringFormat:StringFormatData");
+                        "drawinglayer.emf", "EMF+\t TODO EMFPStringFormat:digitSubstitution");
+        SAL_WARN_IF(firstTabOffset != 0.0, "drawinglayer.emf", "EMF+\t TODO EMFPStringFormat:firstTabOffset");
+        SAL_WARN_IF(hotkeyPrefix != HotkeyPrefix::HotkeyPrefixNone, "drawinglayer.emf", "EMF+\t TODO EMFPStringFormat:hotkeyPrefix");
+        SAL_WARN_IF(leadingMargin != 0.0, "drawinglayer.emf", "EMF+\t TODO EMFPStringFormat:leadingMargin");
+        SAL_WARN_IF(trailingMargin != 0.0, "drawinglayer.emf", "EMF+\t TODO EMFPStringFormat:trailingMargin");
+        SAL_WARN_IF(tracking != 1.0, "drawinglayer.emf", "EMF+\t TODO EMFPStringFormat:tracking");
+        SAL_WARN_IF(trimming != StringTrimming::StringTrimmingNone, "drawinglayer.emf", "EMF+\t TODO EMFPStringFormat:trimming");
+        SAL_WARN_IF(tabStopCount, "drawinglayer.emf", "EMF+\t TODO EMFPStringFormat:tabStopCount");
+        SAL_WARN_IF(rangeCount, "drawinglayer.emf", "EMF+\t TODO EMFPStringFormat:StringFormatData");
     }
 }
 
diff --git a/drawinglayer/source/tools/wmfemfhelper.cxx b/drawinglayer/source/tools/wmfemfhelper.cxx
index 8b3f3562e35b..a54893025984 100644
--- a/drawinglayer/source/tools/wmfemfhelper.cxx
+++ b/drawinglayer/source/tools/wmfemfhelper.cxx
@@ -2982,11 +2982,11 @@ namespace wmfemfhelper
                         if (aEMFPlus)
                         {
                             // error: should not yet exist
-                            SAL_INFO("drawinglayer", "Error: multiple EMF_PLUS_HEADER_INFO");
+                            SAL_INFO("drawinglayer.emf", "Error: multiple EMF_PLUS_HEADER_INFO");
                         }
                         else
                         {
-                            SAL_INFO("drawinglayer", "EMF+ passed to canvas mtf renderer - header info, size: " << pA->GetDataSize());
+                            SAL_INFO("drawinglayer.emf", "EMF+ passed to canvas mtf renderer - header info, size: " << pA->GetDataSize());
                             SvMemoryStream aMemoryStream(const_cast<sal_uInt8 *>(pA->GetData()), pA->GetDataSize(), StreamMode::READ);
 
                             aEMFPlus.reset(
@@ -3001,7 +3001,7 @@ namespace wmfemfhelper
                         if (!aEMFPlus)
                         {
                             // error: should exist
-                            SAL_INFO("drawinglayer", "Error: EMF_PLUS before EMF_PLUS_HEADER_INFO");
+                            SAL_INFO("drawinglayer.emf", "Error: EMF_PLUS before EMF_PLUS_HEADER_INFO");
                         }
                         else
                         {
@@ -3014,11 +3014,11 @@ namespace wmfemfhelper
                                 if (char *env = getenv("EMF_PLUS_LIMIT"))
                                 {
                                     limit = atoi(env);
-                                    SAL_INFO("drawinglayer", "EMF+ records limit: " << limit);
+                                    SAL_INFO("drawinglayer.emf", "EMF+ records limit: " << limit);
                                 }
                             }
 
-                            SAL_INFO("drawinglayer", "EMF+ passed to canvas mtf renderer, size: " << pA->GetDataSize());
+                            SAL_INFO("drawinglayer.emf", "EMF+ passed to canvas mtf renderer, size: " << pA->GetDataSize());
 
                             if (count < limit)
                             {