Translated some comments in filter

20 files changed, 559 insertions, 566 deletions

diff --git a/filter/inc/filter/msfilter/escherex.hxx b/filter/inc/filter/msfilter/escherex.hxx
index 329d37996f18..a5b7352ecb5a 100644
--- a/filter/inc/filter/msfilter/escherex.hxx
+++ b/filter/inc/filter/msfilter/escherex.hxx
@@ -49,7 +49,7 @@
 #include "filter/msfilter/msfilterdllapi.h"
 
         /*Record Name       FBT-Value   Instance                  Contents                                                          Wrd Exl PPt Ver*/
-// In der Mickysoft-Doku heissen die msofbt... statt ESCHER_...
+// In the Microsoft documentation the naming scheme is msofbt... instead of ESCHER_...
 #define ESCHER_DggContainer     0xF000  /*                           per-document data                                                  X   X   X     */
 #define ESCHER_Dgg              0xF006  /*                           an FDGG and several FIDCLs                                         X   X   X   0 */
 #define ESCHER_CLSID            0xF016  /*                           the CLSID of the application that put the data on the clipboard    C   C   C   0 */
@@ -1042,7 +1042,7 @@ class EscherBlibEntry
 protected:
 
     sal_uInt32      mnIdentifier[ 4 ];
-    sal_uInt32      mnPictureOffset;        // offset auf die grafik im PictureStreams
+    sal_uInt32      mnPictureOffset;        // offset to the graphic im PictureStreams
     sal_uInt32      mnSize;                 // size of real graphic
 
     sal_uInt32      mnRefCount;             // !! reference count
@@ -1594,12 +1594,12 @@ public:
         class ImplEscherExSdr.
      */
     inline SvStream*    QueryPictureStream() { return mxGlobal->QueryPictureStream(); }
-
-                /// Fuegt in den EscherStream interne Daten ein, dieser Vorgang
-                /// darf und muss nur einmal ausgefuehrt werden.
-                /// Wenn pPicStreamMergeBSE angegeben ist, werden die BLIPs
-                /// aus diesem Stream in die MsofbtBSE Records des EscherStream
-                /// gemerged, wie es fuer Excel (und Word?) benoetigt wird.
+    
+                /// Inserts internal data into the EscherStream, this process
+                /// may and has to be executed only once
+                /// If pPicStreamMergeBSE is known, the BLIPs from this stream are being
+                /// merged into the MsofbtBSE Records of the EscherStream like it's
+                /// required for Excel (and maybe Word?)
         virtual void Flush( SvStream* pPicStreamMergeBSE = NULL );
 
     /** Inserts the passed number of bytes at the current position of the
@@ -1622,22 +1622,22 @@ public:
      */
     void            InsertAtCurrentPos( sal_uInt32 nBytes, bool bExpandEndOfAtom );
 
-    void            InsertPersistOffset( sal_uInt32 nKey, sal_uInt32 nOffset ); // Es wird nicht geprueft, ob sich jener schluessel schon in der PersistantTable befindet
+    void            InsertPersistOffset( sal_uInt32 nKey, sal_uInt32 nOffset ); // It is not being checked if this key is already in the PersistantTable
     void            ReplacePersistOffset( sal_uInt32 nKey, sal_uInt32 nOffset );
     sal_uInt32      GetPersistOffset( sal_uInt32 nKey );
     sal_Bool        SeekToPersistOffset( sal_uInt32 nKey );
-    virtual sal_Bool InsertAtPersistOffset( sal_uInt32 nKey, sal_uInt32 nValue );// nValue wird im Stream an entrsprechender Stelle eingefuegt(overwrite modus), ohne dass sich die
-                                                                    // aktuelle StreamPosition aendert
+    virtual sal_Bool InsertAtPersistOffset( sal_uInt32 nKey, sal_uInt32 nValue );   // nValue is being inserted into the Stream where it's appropriate (overwrite modus), without that the
+                                                                                    // current StreamPosition changes
 
     SvStream&       GetStream() const   { return *mpOutStrm; }
     sal_uLong       GetStreamPos() const    { return mpOutStrm->Tell(); }
 
-    virtual sal_Bool SeekBehindRecHeader( sal_uInt16 nRecType );                // der stream muss vor einem gueltigen Record Header oder Atom stehen
+    virtual sal_Bool SeekBehindRecHeader( sal_uInt16 nRecType );                // the stream has to be in front of a valid Record Headeror Atom
 
-                // features beim erzeugen folgender Container:
+                // features during the creation of the following Containers:
                 //
-                //      ESCHER_DggContainer:    ein EscherDgg Atom wird automatisch erzeugt und verwaltet
-                //      ESCHER_DgContainer:     ein EscherDg Atom wird automatisch erzeugt und verwaltet
+                //      ESCHER_DggContainer:    a EscherDgg Atom is automatically being created and managed
+                //      ESCHER_DgContainer:     a EscherDg Atom is automatically being created and managed
                 //      ESCHER_SpgrContainer:
                 //      ESCHER_SpContainer:
 
@@ -1657,7 +1657,7 @@ public:
     virtual sal_Bool SetGroupLogicRect( sal_uInt32 nGroupLevel, const Rectangle& rRect );
     virtual void LeaveGroup();
 
-                // ein ESCHER_Sp wird geschrieben ( Ein ESCHER_DgContainer muss dazu geoeffnet sein !!)
+                // a ESCHER_Sp is being written ( a ESCHER_DgContainer has to be opened for this purpose!)
     virtual void AddShape( sal_uInt32 nShpInstance, sal_uInt32 nFlagIds, sal_uInt32 nShapeID = 0 );
 
     virtual void Commit( EscherPropertyContainer& rProps, const Rectangle& rRect );
diff --git a/filter/inc/filter/msfilter/svdfppt.hxx b/filter/inc/filter/msfilter/svdfppt.hxx
index dba6d37d3060..18b8574de005 100644
--- a/filter/inc/filter/msfilter/svdfppt.hxx
+++ b/filter/inc/filter/msfilter/svdfppt.hxx
@@ -179,14 +179,14 @@ const sal_uInt32 PPTInventor = sal_uInt32('P') * 0x00000001
 
 struct MSFILTER_DLLPUBLIC PptDocumentAtom
 {
-    Size            aSlidesPageSize;                    // Seitengroesse der Slides in 576DPI
-    Size            aNotesPageSize;                     // Seitengroesse der Notes in 576DPI
+    Size            aSlidesPageSize;                    // page size of the slides in 576DPI
+    Size            aNotesPageSize;                     // page size of the notes in 576DPI
     // RatioAtom erstmal weggelassen
-    sal_uInt32      nNotesMasterPersist;                // 0=nicht vorhanden
-    sal_uInt32      nHandoutMasterPersist;              // 0=nicht vorhanden
-    sal_uInt16      n1stPageNumber;                     // Seitennummer des ersten Slides
-    PptPageFormat   eSlidesPageFormat;                  // Seitenformat der Slides
-    sal_Bool        bEmbeddedTrueType           : 1;    // TrueType direkt im File?
+    sal_uInt32      nNotesMasterPersist;                // 0=non-existent
+    sal_uInt32      nHandoutMasterPersist;              // 0=non-existent
+    sal_uInt16      n1stPageNumber;                     // page number of the first slide
+    PptPageFormat   eSlidesPageFormat;                  // page format of the slides
+    sal_Bool        bEmbeddedTrueType           : 1;    // TrueType direcly within the File?
     sal_Bool        bTitlePlaceholdersOmitted   : 1;
     sal_Bool        bRightToLeft                : 1;
     sal_Bool        bShowComments               : 1;
@@ -292,7 +292,7 @@ struct PptUserEditAtom
     sal_uInt32          nOffsetLastEdit;         // File offset of prev PptUserEditAtom
     sal_uInt32          nOffsetPersistDirectory; // Offset to PersistPtrs for this file version.
     sal_uInt32          nDocumentRef;
-    sal_uInt32          nMaxPersistWritten;      // Gesamtanzahl der Persisteintraege bis hierher.
+    sal_uInt32          nMaxPersistWritten;      // total number of Persist entries up to this point
     sal_Int16           eLastViewType;           // enum view type
 
 public:
@@ -340,9 +340,9 @@ struct PptSlidePersistEntry
     void*               pDummy2;
     PptPageKind         ePageKind;              //
 
-    sal_Bool            bNotesMaster    : 1;    // fuer NotesMaster
-    sal_Bool            bHandoutMaster  : 1;    // fuer HandoutMaster
-    sal_Bool            bStarDrawFiller : 1;    // speziell fuer StarDraw
+    sal_Bool            bNotesMaster    : 1;    // for NotesMaster
+    sal_Bool            bHandoutMaster  : 1;    // for HandoutMaster
+    sal_Bool            bStarDrawFiller : 1;    // special for StarDraw
 public:
                         PptSlidePersistEntry();
                         ~PptSlidePersistEntry();
diff --git a/filter/source/graphicfilter/egif/egif.cxx b/filter/source/graphicfilter/egif/egif.cxx
index fa4044e44e2e..0891d8b7a17d 100644
--- a/filter/source/graphicfilter/egif/egif.cxx
+++ b/filter/source/graphicfilter/egif/egif.cxx
@@ -310,21 +310,21 @@ void GIFWriter::WriteGlobalHeader( const Size& rSize )
 {
     if( bStatus )
     {
-        // 256 Farben
+        // 256 colors
         const sal_uInt16    nWidth = (sal_uInt16) rSize.Width();
         const sal_uInt16    nHeight = (sal_uInt16) rSize.Height();
         const sal_uInt8     cFlags = 128 | ( 7 << 4 );
 
-        // Werte rausschreiben
+        // write values
         m_rGIF << nWidth;
         m_rGIF << nHeight;
         m_rGIF << cFlags;
         m_rGIF << (sal_uInt8) 0x00;
         m_rGIF << (sal_uInt8) 0x00;
-
-        // Dummy-Palette mit zwei Eintraegen (Schwarz/Weiss) schreiben;
-        // dieses nur wegen Photoshop-Bug, da die keine Bilder ohne
-        // globale Farbpalette lesen koennen
+        
+        // write dummy palette with two entries (black/white);
+        // we do this only because of a bug in Photoshop, since those can't
+        // read pictures without a global color palette
         m_rGIF << (sal_uInt16) 0;
         m_rGIF << (sal_uInt16) 255;
         m_rGIF << (sal_uInt16) 65535;
@@ -341,14 +341,14 @@ void GIFWriter::WriteLoopExtension( const Animation& rAnimation )
     DBG_ASSERT( rAnimation.Count() > 0, "Animation has no bitmaps!" );
 
     sal_uInt16 nLoopCount = (sal_uInt16) rAnimation.GetLoopCount();
-
-    // falls nur ein Durchlauf stattfinden soll,
-    // wird keine LoopExtension geschrieben;
-    // Default ist dann immer ein Durchlauf
+    
+    // if only one run should take place
+    // the LoopExtension won't be written
+    // The default in this case is a single run
     if( nLoopCount != 1 )
     {
-        // Netscape interpretiert den LoopCount
-        // als reine Anzahl der _Wiederholungen_
+        // Netscape interprets the LoopCount
+        // as the sole number of _repetitions_
         if( nLoopCount )
             nLoopCount--;
 
@@ -371,7 +371,7 @@ void GIFWriter::WriteLoopExtension( const Animation& rAnimation )
 
 void GIFWriter::WriteLogSizeExtension( const Size& rSize100 )
 {
-    // PrefSize in 100th-mm als ApplicationExtension schreiben
+    // writer PrefSize in 100th-mm as ApplicationExtension
     if( rSize100.Width() && rSize100.Height() )
     {
         m_rGIF << (sal_uInt8) 0x21;
@@ -395,11 +395,11 @@ void GIFWriter::WriteImageExtension( long nTimer, Disposal eDisposal )
         const sal_uInt16    nDelay = (sal_uInt16) nTimer;
         sal_uInt8           cFlags = 0;
 
-        // Transparent-Flag setzen
+        // set Transparency-Flag
         if( bTransparent )
             cFlags |= 1;
 
-        // Disposal-Wert setzen
+        // set Disposal-value
         if( eDisposal == DISPOSE_BACK )
             cFlags |= ( 2 << 2 );
         else if( eDisposal == DISPOSE_PREVIOUS )
@@ -430,11 +430,11 @@ void GIFWriter::WriteLocalHeader()
         const sal_uInt16    nHeight = (sal_uInt16) m_pAcc->Height();
         sal_uInt8       cFlags = (sal_uInt8) ( m_pAcc->GetBitCount() - 1 );
 
-        // Interlaced-Flag setzen
+        // set Interlaced-Flag
         if( nInterlaced )
             cFlags |= 0x40;
 
-        // Flag fuer lokale Farbpalette setzen
+        // set Flag for the local color palette
         cFlags |= 0x80;
 
         // alles rausschreiben
@@ -468,7 +468,7 @@ void GIFWriter::WritePalette()
             m_rGIF << rColor.GetBlue();
         }
 
-        // Rest mit 0 auffuellen
+        // fill up the rest with 0
         if( nCount < nMaxCount )
             m_rGIF.SeekRel( ( nMaxCount - nCount ) * 3 );
 
diff --git a/filter/source/graphicfilter/egif/giflzwc.cxx b/filter/source/graphicfilter/egif/giflzwc.cxx
index 43a0b202575b..4c7ca0b503be 100644
--- a/filter/source/graphicfilter/egif/giflzwc.cxx
+++ b/filter/source/graphicfilter/egif/giflzwc.cxx
@@ -115,10 +115,10 @@ void GIFImageDataOutputStream::FlushBlockBuf()
 struct GIFLZWCTreeNode
 {
 
-    GIFLZWCTreeNode*    pBrother;       // naechster Knoten, der den selben Vater hat
-    GIFLZWCTreeNode*    pFirstChild;    // erster Sohn
-    sal_uInt16              nCode;          // Der Code fuer den String von Pixelwerten, der sich ergibt, wenn
-    sal_uInt16              nValue;         // Der Pixelwert
+    GIFLZWCTreeNode*    pBrother;       // next node which has the same father
+    GIFLZWCTreeNode*    pFirstChild;    // first 
+    sal_uInt16              nCode;          // the code for the string of pixel values which comes about
+    sal_uInt16              nValue;         // the pixel value
 };
 
 // --------------------
diff --git a/filter/source/graphicfilter/eos2met/eos2met.cxx b/filter/source/graphicfilter/eos2met/eos2met.cxx
index 64ba6ed43def..08280a6c3c4e 100644
--- a/filter/source/graphicfilter/eos2met/eos2met.cxx
+++ b/filter/source/graphicfilter/eos2met/eos2met.cxx
@@ -47,7 +47,7 @@
 #include <svl/solar.hrc>
 
 
-// -----------------------------Feld-Typen-------------------------------
+// -----------------------------Field Types-------------------------------
 
 #define BegDocumnMagic 0xA8A8 /* Begin Document */
 #define EndDocumnMagic 0xA8A9 /* End Document   */
@@ -134,19 +134,19 @@ class METWriter
 private:
 
     sal_Bool                bStatus;
-    sal_uLong               nLastPercent; // Mit welcher Zahl pCallback zuletzt aufgerufen wurde.
+    sal_uLong               nLastPercent; // with which number pCallback has been called the last time
     SvStream*           pMET;
     Rectangle           aPictureRect;
     MapMode             aPictureMapMode;
     MapMode             aTargetMapMode;
-    sal_uLong               nActualFieldStartPos;     // Anfangs-Position des aktuellen 'Field'
-    sal_uLong               nNumberOfDataFields;  // Anzahl der angefangenen 'Graphcis Data Fields'
+    sal_uLong               nActualFieldStartPos;     // start position of the current 'Field'
+    sal_uLong               nNumberOfDataFields;  // number of commenced 'Graphcis Data Fields'
     Color               aGDILineColor;
     Color               aGDIFillColor;
     RasterOp            eGDIRasterOp;
     Font                aGDIFont;
-    MapMode             aGDIMapMode;   // derzeit unbenutzt!
-    Rectangle           aGDIClipRect; // derzeit unbenutzt!
+    MapMode             aGDIMapMode;   // currently ununsed!
+    Rectangle           aGDIClipRect; // currently ununsed!
     METGDIStackMember*  pGDIStack;
     Color               aMETColor;
     Color               aMETBackgroundColor;
@@ -156,14 +156,14 @@ private:
     Size                aMETChrCellSize;
     short               nMETChrAngle;
     sal_uInt8               nMETChrSet;
-    METChrSet*          pChrSetList; // Liste der Character-Sets
-    sal_uInt8               nNextChrSetId; // die erste unbenutzte ChrSet-Id
-    sal_uLong               nActBitmapId; // Field-Id der naechsten Bitmap
-    sal_uLong               nNumberOfActions; // Anzahl der Actions im GDIMetafile
-    sal_uLong               nNumberOfBitmaps; // Anzahl der Bitmaps
-    sal_uLong               nWrittenActions;  // Anzahl der bereits verarbeiteten Actions beim Schreiben der Orders
-    sal_uLong               nWrittenBitmaps;  // Anzahl der bereits geschriebenen Bitmaps
-    sal_uLong               nActBitmapPercent; // Wieviel Prozent die naechste Bitmap schon geschrieben ist.
+    METChrSet*          pChrSetList; // list of Character-Sets
+    sal_uInt8               nNextChrSetId; // the first unused ChrSet-Id
+    sal_uLong               nActBitmapId; // Field-Id of the next Bitmap
+    sal_uLong               nNumberOfActions; // number of Actions in the GDIMetafile
+    sal_uLong               nNumberOfBitmaps; // number of Bitmaps
+    sal_uLong               nWrittenActions;  // number of already processed actions during the writing of the orders
+    sal_uLong               nWrittenBitmaps;  // number of already written Bitmaps
+    sal_uLong               nActBitmapPercent; // percentage of the next bitmap that's already written
 
     ::std::auto_ptr< VirtualDevice >    apDummyVDev;
     OutputDevice*                       pCompDev;
@@ -171,13 +171,12 @@ private:
     com::sun::star::uno::Reference< com::sun::star::task::XStatusIndicator > xStatusIndicator;
 
     void MayCallback();
-        // Berechnet anhand der obigen 5 Parameter eine Prozentzahl
-        // und macht dann ggf. einen Callback. Setzt bStatus auf sal_False wenn User abbrechen
-        // moechte.
+        // calculates a percentage based on the 5 parameters above and then does a
+        // Callback as the case may be. Sets bStatus to sal_False if the user wants to cancel
 
     void CountActionsAndBitmaps(const GDIMetaFile * pMTF);
-        // Zaehlt die Bitmaps und Actions (nNumberOfActions und nNumberOfBitmaps muessen
-        // zu Anfang auf 0 gesetzt werden, weil diese Methode rekursiv ist)
+        // Counts the bitmaps and actions (nNumberOfActions and nNumberOfBitmaps have to 
+        // be set to 0 at the beginning, since this method is recursive)
 
     void WriteBigEndianShort(sal_uInt16 nWord);
     void WriteBigEndianLong(sal_uLong nLong);
@@ -264,7 +263,7 @@ public:
 };
 
 
-//========================== Methoden von METWriter ==========================
+//========================== Methods of METWriter ==========================
 
 void METWriter::MayCallback()
 {
@@ -508,11 +507,11 @@ void METWriter::WriteColorAttributeTable(sal_uLong nFieldId, BitmapPalette* pPal
 
     if (bStatus==sal_False) return;
 
-    //--- Das Feld 'Begin Color Attribute Table':
+    //--- The Field 'Begin Color Attribute Table':
     WriteFieldIntroducer(16,BegColAtrMagic,0,0);
     WriteFieldId(nFieldId);
 
-    //--- Das Feld 'Color Attribute Table':
+    //--- The Field 'Color Attribute Table':
     WriteFieldIntroducer(0,BlkColAtrMagic,0,0);
     *pMET << nBasePartFlags << (sal_uInt8)0x00 << nBasePartLCTID; // 'Base Part'
     if (pPalette!=NULL)
@@ -522,11 +521,11 @@ void METWriter::WriteColorAttributeTable(sal_uLong nFieldId, BitmapPalette* pPal
         {
             nNumI=pPalette->GetEntryCount()-nIndex;
             if (nNumI>81) nNumI=81;
-            *pMET << (sal_uInt8)(11+nNumI*3);                   // Laenge des Parameters
+            *pMET << (sal_uInt8)(11+nNumI*3);                   // length of the parameter
             *pMET << (sal_uInt8)1 << (sal_uInt8)0 << (sal_uInt8)1;        // typ: element list, Reserved, Format: RGB
-            *pMET << (sal_uInt8)0; WriteBigEndianShort(nIndex); // Start-Index (3 Bytes)
-            *pMET << (sal_uInt8)8 << (sal_uInt8)8 << (sal_uInt8)8;        // Bits je Komponente R,G,B
-            *pMET << (sal_uInt8)3;                              // Anzahl Bytes je Eintrag
+            *pMET << (sal_uInt8)0; WriteBigEndianShort(nIndex); // start-Index (3 Bytes)
+            *pMET << (sal_uInt8)8 << (sal_uInt8)8 << (sal_uInt8)8;        // Bits per component R,G,B
+            *pMET << (sal_uInt8)3;                              // number of bytes per entry
             for (i=0; i<nNumI; i++)
             {
                 const BitmapColor& rCol = (*pPalette)[ nIndex ];
@@ -546,7 +545,7 @@ void METWriter::WriteColorAttributeTable(sal_uLong nFieldId, BitmapPalette* pPal
     }
     UpdateFieldSize();
 
-    //--- Das Feld 'End Color Attribute Table':
+    //--- The Field 'End Color Attribute Table':
     WriteFieldIntroducer(16,EndColAtrMagic,0,0);
     WriteFieldId(nFieldId);
 
@@ -570,14 +569,14 @@ void METWriter::WriteImageObject(const Bitmap & rBitmap)
     nActColMapId=((nActBitmapId>>24)&0x000000ff) | ((nActBitmapId>> 8)&0x0000ff00) |
                  ((nActBitmapId<< 8)&0x00ff0000) | ((nActBitmapId<<24)&0xff000000);
 
-    //--- Das Feld 'Begin Image Object':
+    //--- The Field 'Begin Image Object':
     WriteFieldIntroducer(16,BegImgObjMagic,0,0);
     WriteFieldId(nActBitmapId);
 
-    // Windows-BMP-Datei erzeugen:
+    // generate Windows-BMP file
     aTemp << rBitmap;
 
-    // Header der Windows-BMP-Datei einlesen:
+    // read header of the Windows-BMP file:
     aTemp.SetNumberFormatInt(NUMBERFORMAT_INT_LITTLEENDIAN);
     aTemp.Seek(18);
     aTemp >> nWidth >> nHeight;
@@ -590,7 +589,7 @@ void METWriter::WriteImageObject(const Bitmap & rBitmap)
     nNumColors=1<<nBitsPerPixel;
     nBytesPerLine=((nWidth*nBitsPerPixel+0x0000001f) & 0xffffffe0 ) >> 3;
 
-    // ggf. Farbpalette einlesen und in die MET-Datei schreiben:
+    // read color palette as the case may be and write it to the MET file:
     if (nBitsPerPixel<=8)
     {
         BitmapPalette   aPal( (sal_uInt16) nNumColors );
@@ -602,34 +601,34 @@ void METWriter::WriteImageObject(const Bitmap & rBitmap)
             aPal[ (sal_uInt16) i ] = BitmapColor( nr, ng, nb );
         }
 
-        //--- Das Feld 'Begin Resource Group':
+        //--- The Field 'Begin Resource Group':
         WriteFieldIntroducer(16,BegResGrpMagic,0,0);
         WriteFieldId(nActColMapId);
 
-        //--- Farbtabelle schreiben:
+        //--- writer color table:
         WriteColorAttributeTable(nActColMapId,&aPal,0,1);
 
-        //--- Das Feld 'End Resource Group':
+        //--- The Field 'End Resource Group':
         WriteFieldIntroducer(16,EndResGrpMagic,0,0);
         WriteFieldId(nActColMapId);
 
-        //--- Das Feld 'Begin Object Environment Group':
+        //--- The Field 'Begin Object Environment Group':
         WriteFieldIntroducer(16,BegObjEnvMagic,0,0);
         WriteFieldId(nActBitmapId);
 
-        //--- Das Feld 'Map Color Attribute Table':
+        //--- The Field 'Map Color Attribute Table':
         WriteFieldIntroducer(26,MapColAtrMagic,0,0);
         WriteBigEndianShort(0x0012);
         *pMET << (sal_uInt8)0x0c << (sal_uInt8)0x02 << (sal_uInt8)0x84 << (sal_uInt8)0x00;
         WriteFieldId(nActColMapId);
         *pMET << (sal_uInt8)0x04 << (sal_uInt8)0x24 << (sal_uInt8)0x07 << (sal_uInt8)0x01;
 
-        //--- Das Feld 'End Object Environment Group':
+        //--- The Field 'End Object Environment Group':
         WriteFieldIntroducer(16,EndObjEnvMagic,0,0);
         WriteFieldId(nActBitmapId);
     }
 
-    //--- Das Feld 'Image Data Descriptor':
+    //--- The Field 'Image Data Descriptor':
     WriteFieldIntroducer(17,DscImgObjMagic,0,0);
     *pMET << (sal_uInt8)0x01; // Unit of measure: tens of centimeters
     WriteBigEndianShort((sal_uInt16)nResX);
@@ -637,7 +636,7 @@ void METWriter::WriteImageObject(const Bitmap & rBitmap)
     WriteBigEndianShort((sal_uInt16)nWidth);
     WriteBigEndianShort((sal_uInt16)nHeight);
 
-    //--- Das erste Feld 'Image Picture Data':
+    //--- The first Field 'Image Picture Data':
     WriteFieldIntroducer(0,DatImgObjMagic,0,0);
 
     // Begin Segment:
@@ -673,13 +672,13 @@ void METWriter::WriteImageObject(const Bitmap & rBitmap)
     ny=0;
     while (ny<nHeight) {
 
-        // Abschliessen des vorherigen Feldes 'Image Picture Data':
+        // finalize the previous field 'Image Picture Data':
         UpdateFieldSize();
 
-        // Und ein neues Feld 'Image Picture Data' anfangen:
+        // and start a new field 'Image Picture Data':
         WriteFieldIntroducer(0,DatImgObjMagic,0,0);
 
-        // Einige Scanlines lesen und schreiben:
+        // read and write several Scanlines:
         nLines=nHeight-ny;
         if (nLines*nBytesPerLine>30000) nLines=30000/nBytesPerLine;
         if (nLines<1) nLines=1;
@@ -708,17 +707,17 @@ void METWriter::WriteImageObject(const Bitmap & rBitmap)
     // End Segment:
     *pMET << (sal_uInt8)0x71 << (sal_uInt8)0x00;
 
-    // Abschliessen des letzten Feldes 'Image Picture Data':
+    // finalize the last field 'Image Picture Data':
     UpdateFieldSize();
 
-    //--- Das Feld 'End Image Object':
+    //--- The Field 'End Image Object':
     WriteFieldIntroducer(16,EndImgObjMagic,0,0);
     WriteFieldId(nActBitmapId);
 
-    // Ids erhoehen:
+    // increase Ids:
     nActBitmapId++;
 
-    // Bitmaps zaehlen:
+    // count Bitmaps:
     nWrittenBitmaps++;
     nActBitmapPercent=0;
 
@@ -829,7 +828,7 @@ void METWriter::WriteDataDescriptor(const GDIMetaFile *)
     WriteFieldIntroducer(0,DscGrfObjMagic,0,0);
 
     //------------------------------------------------------------------------------
-    // Im Folgenden die OS2-Orginal-Dokumentation und die Implementation dazu (uff)
+    // The following is the OS2 original documentation and the associated implementation
     //------------------------------------------------------------------------------
 
     //  Parameters (all required and in this order)
@@ -2359,17 +2358,17 @@ void METWriter::WriteObjectEnvironmentGroup(const GDIMetaFile * pMTF)
 {
     sal_uLong i, nId;
 
-    //--- Das Feld 'Begin Object Environment Group':
+    //--- The Field 'Begin Object Environment Group':
     WriteFieldIntroducer(16,BegObjEnvMagic,0,0);
     WriteFieldId(7);
 
-    //--- Das Feld 'Map Color Attribute Table':
+    //--- The Field 'Map Color Attribute Table':
     WriteFieldIntroducer(22,MapColAtrMagic,0,0);
     WriteBigEndianShort(0x000e);
     *pMET << (sal_uInt8)0x0c << (sal_uInt8)0x02 << (sal_uInt8)0x84 << (sal_uInt8)0x00;
     WriteFieldId(4);
 
-    //--- Das erste Feld 'Map Coded Font':
+    //--- The first Field 'Map Coded Font':
     WriteFieldIntroducer(32,MapCodFntMagic,0,0);
     WriteBigEndianShort(0x0018);
     *pMET << (sal_uInt8)0x0c << (sal_uInt8)0x02 << (sal_uInt8)0x84 << (sal_uInt8)0x00;
@@ -2383,7 +2382,7 @@ void METWriter::WriteObjectEnvironmentGroup(const GDIMetaFile * pMTF)
     CreateChrSets(pMTF);
     WriteChrSets();
 
-    //--- Die Felder 'Map Data Resource':
+    //--- The Fields 'Map Data Resource':
     nId=nActBitmapId;
     for (i=0; i<nNumberOfBitmaps; i++)
     {
@@ -2413,49 +2412,49 @@ void METWriter::WriteGraphicsObject(const GDIMetaFile * pMTF)
     WriteFieldIntroducer(16,BegGrfObjMagic,0,0);
     WriteFieldId(7);
 
-    // Map Color Attribute Table, Fonts und anderes:
+    // Map Color Attribute Table, Fonts and other stuff:
     WriteObjectEnvironmentGroup(pMTF);
 
-    //--- Das Feld 'Graphics Data Descriptor':
+    //--- The Field 'Graphics Data Descriptor':
     WriteDataDescriptor(pMTF);
 
-    // Zaehler fuer Data Fields initialisieren:
+    // initialise the counter for Data Fields:
     nNumberOfDataFields=0;
 
-    // Und Position des ersten Data Fields merken:
+    // and remember the position of the first Data Field:
     nDataFieldsStartPos=pMET->Tell();
 
-    //--- Anfang des ersten Feldes 'Graphics Data'
+    //--- start of the first Field 'Graphics Data'
     WriteFieldIntroducer(0,DatGrfObjMagic,0,0);
     nNumberOfDataFields++;
 
-    // Nun schreiben wir zunaechst den Kopf des Segments:
+    // now at first we write the head of the segment:
     *pMET << (sal_uInt8)0x70 << (sal_uInt8)0x0e << (sal_uInt32)0;
     *pMET << (sal_uInt8)0x70 << (sal_uInt8)0x10; // Flags
-    *pMET << (sal_uInt16)0; // Lo-Wort der Laenge der Segementdaten (Big Endian)
+    *pMET << (sal_uInt16)0; // Lo-Word of the length of the segment data  (Big Endian)
     *pMET << (sal_uInt32)0;  // Reserved
-    *pMET << (sal_uInt16)0; // Hi-Wort der Laenge der Segementdaten (Big Endian) (Ohh Ohh OS2)
-    // Anmerkung: die richtige Daten-Laenge schreiben wir weiter unten nochmal
+    *pMET << (sal_uInt16)0; // Hi-Word of the length of the segment (Big Endian) (Ohh Ohh OS2)
+    // Annotation: we're writing the correct data length again below
 
-    // Jetzt werden alle Orders rausgeschrieben:
+    // now all orders are being written out:
     // (wobei die Sache ggf. in mehrere 'Graphics Data Fields' aufgeteilt
     // wird, per Methode WillWriteOrder(..))
     WriteOrders(pMTF);
 
-    //--- Das letzte Feld 'Graphic Data' beenden:
+    //--- terminate the last Field 'Graphic Data':
     UpdateFieldSize();
 
-    //--- Und schliesslich die Segmentgroesse richtigstellen:
+    //--- and finally correct the segment size:
     nPos=pMET->Tell();
     nSegmentSize=nPos-nDataFieldsStartPos;
-    nSegmentSize-=nNumberOfDataFields*8; // Structured Field Introducers zaehlen nicht mit
-    pMET->Seek(nDataFieldsStartPos+16); // Zum Lo-Wort der Segmentgroesse seeken
+    nSegmentSize-=nNumberOfDataFields*8; // Structured Field Introducers are not counted
+    pMET->Seek(nDataFieldsStartPos+16); // seek to the Lo-Word of the segment size
     WriteBigEndianShort((sal_uInt16)(nSegmentSize&0x0000ffff)); // Und schreiben
-    pMET->Seek(nDataFieldsStartPos+22); // Zum Hi-Wort der Segmentgroesse seeken
-    WriteBigEndianShort((sal_uInt16)(nSegmentSize>>16)); // Und schreiben
-    pMET->Seek(nPos); // Zurueck zur Tagesordnung
+    pMET->Seek(nDataFieldsStartPos+22); // seek to the Hi-Word of the segment size
+    WriteBigEndianShort((sal_uInt16)(nSegmentSize>>16)); // and writing it
+    pMET->Seek(nPos); // back to business as usual
 
-    //--- Das Feld 'End Graphic Objects':
+    //--- The Field 'End Graphic Objects':
     WriteFieldIntroducer(16,EndGrfObjMagic,0,0);
     WriteFieldId(7);
 
@@ -2469,18 +2468,18 @@ void METWriter::WriteResourceGroup(const GDIMetaFile * pMTF)
     if( bStatus==sal_False )
         return;
 
-    //--- Das Feld 'Begin Resource Group':
+    //--- The Field 'Begin Resource Group':
     WriteFieldIntroducer(16,BegResGrpMagic,0,0);
     WriteFieldId(2);
 
-    //--- Der Inhalt:
+    //--- The Content:
     WriteColorAttributeTable();
     nActBitmapId=0x77777700;
     WriteImageObjects(pMTF);
     nActBitmapId=0x77777700;
     WriteGraphicsObject(pMTF);
 
-    //--- Das Feld 'End Resource Group':
+    //--- The Field 'End Resource Group':
     WriteFieldIntroducer(16,EndResGrpMagic,0,0);
     WriteFieldId(2);
 
@@ -2494,7 +2493,7 @@ void METWriter::WriteDocument(const GDIMetaFile * pMTF)
     if( bStatus==sal_False )
         return;
 
-    //--- Das Feld 'Begin Document':
+    //--- The Field 'Begin Document':
     WriteFieldIntroducer(0,BegDocumnMagic,0,0);
     WriteFieldId(1);
     *pMET << (sal_uInt8)0x00 << (sal_uInt8)0x00;
@@ -2503,10 +2502,10 @@ void METWriter::WriteDocument(const GDIMetaFile * pMTF)
     *pMET << (sal_uInt8)0x03 << (sal_uInt8)0x65 << (sal_uInt8)0x00;
     UpdateFieldSize();
 
-    //--- Der Inhalt:
+    //--- The Content:
     WriteResourceGroup(pMTF);
 
-    //--- Das Feld 'End Document':
+    //--- The Field 'End Document':
     WriteFieldIntroducer(16,EndDocumnMagic,0,0);
     WriteFieldId(1);
 
@@ -2584,7 +2583,7 @@ sal_Bool METWriter::WriteMET( const GDIMetaFile& rMTF, SvStream& rTargetStream,
     return bStatus;
 }
 
-//================== GraphicExport - die exportierte Funktion ================
+//================== GraphicExport - the exported Function ================
 
 extern "C" SAL_DLLPUBLIC_EXPORT sal_Bool __LOADONCALLAPI
 GraphicExport( SvStream & rStream, Graphic & rGraphic, FilterConfigItem* pFilterConfigItem, sal_Bool )
diff --git a/filter/source/graphicfilter/epict/epict.cxx b/filter/source/graphicfilter/epict/epict.cxx
index 7646ed2da0b0..3ca68633da8d 100644
--- a/filter/source/graphicfilter/epict/epict.cxx
+++ b/filter/source/graphicfilter/epict/epict.cxx
@@ -77,12 +77,12 @@ class PictWriter {
 private:
 
     sal_Bool bStatus;
-    sal_uLong nLastPercent; // Mit welcher Zahl pCallback zuletzt aufgerufen wurde.
+    sal_uLong nLastPercent; // with wich number pCallback has been called the last time
     com::sun::star::uno::Reference< com::sun::star::task::XStatusIndicator > xStatusIndicator;
 
     SvStream * pPict;
 
-    // Aktuelle Attribute im Quell-Metafile:
+    // current attributes in the source-metafile:
     Color       aLineColor;
     Color       aFillColor;
     RasterOp    eSrcRasterOp;
@@ -92,7 +92,7 @@ private:
     Rectangle   aClipRect;
     PictWriterAttrStackMember * pAttrStack;
 
-    // Aktuelle Attribute im Ziel-Metafile, und ob sie gueltig sind
+    // current attributes in the target-metafile and whether they are valid
     sal_Bool        bDstBkPatVisible;   sal_Bool bDstBkPatValid;
     sal_uInt8        nDstTxFace;            sal_Bool bDstTxFaceValid;
     RasterOp    eDstTxMode;         sal_Bool bDstTxModeValid;
@@ -107,23 +107,23 @@ private:
     Point       aDstTextPosition;   sal_Bool bDstTextPositionValid;
     String      aDstFontName; sal_uInt16 nDstFontNameId; sal_Bool bDstFontNameValid;
 
-    sal_uLong nNumberOfActions;  // Anzahl der Actions im GDIMetafile
-    sal_uLong nNumberOfBitmaps;  // Anzahl der Bitmaps
-    sal_uLong nWrittenActions;   // Anzahl der bereits verarbeiteten Actions beim Schreiben der Opcodes
-    sal_uLong nWrittenBitmaps;   // Anzahl der bereits geschriebenen Bitmaps
-    sal_uLong nActBitmapPercent; // Wieviel Prozent die naechste Bitmap schon geschrieben ist.
+    sal_uLong nNumberOfActions;  // number of actions in the GDIMetafile
+    sal_uLong nNumberOfBitmaps;  // number of bitmaps
+    sal_uLong nWrittenActions;   // number of already processed actions during writing the Opcodes
+    sal_uLong nWrittenBitmaps;   // number of already written Bitmaps
+    sal_uLong nActBitmapPercent; // what percentage of the next bitmap is already written
 
     void MayCallback();
-        // Berechnet anhand der obigen 5 Parameter eine Prozentzahl
-        // und macht dann ggf. einen Callback. Setzt bStatus auf sal_False wenn User abbrechen
-        // moechte.
+        // calculates a percentage on the basis of the 5 parameters above
+        // and then does a Callback should the situation arise. Sets bStatus to sal_False
+        // if the user wants to cancel
 
     void CountActionsAndBitmaps(const GDIMetaFile & rMTF);
-        // Zaehlt die Bitmaps und Actions (nNumberOfActions und nNumberOfBitmaps muessen
-        // zu Anfang auf 0 gesetzt werden, weil diese Methode rekursiv ist)
+        // counts the bitmaps and actions (nNumberOfActions and nNumberOfBitmaps
+        // have to be set to 0 at the beginning, since this method is recursive)
 
     Polygon PolyPolygonToPolygon(const PolyPolygon & rPoly);
-        // Macht aus einem PolyPolygon ein halbwegs vernuenftiges Polygon
+        // generates a relatively sane polygon on the basis of a PolyPolygon
 
     Rectangle MapRectangle( const Rectangle& rRect );
     void WritePoint(const Point & rPoint);
@@ -184,7 +184,7 @@ public:
 };
 
 
-//========================== Methoden von PictWriter ==========================
+//========================== Methods of PictWriter ==========================
 
 
 void PictWriter::MayCallback()
@@ -248,11 +248,13 @@ Polygon PictWriter::PolyPolygonToPolygon(const PolyPolygon & rPolyPoly)
     for (np=1; np<nCount; np++) {
         aPoly2=rPolyPoly.GetObject(np);
 
-        //-----------------Folgendes verschmilzt aPoly1 und aPoly2 zu aPoly1-----------------
+        //-----------------The following code merges aPoly1 and aPoly2 to aPoly1-----------------
 
         nSize1=aPoly1.GetSize();
         nSize2=aPoly2.GetSize();
 
+        // At first we look for a point in aPoly1 (referenced by nBestIdx1) and a
+        // point in aPoly2 (referenced by nBestid2), which 
         // Zunaechst werden ein Punkt in aPoly1 (referenziert durch nBestIdx1) und ein
         // Punkt in aPoly2 (referenziert durch nBestIdx2) gesucht, die moeglichst dicht
         // beieinander liegen. Da dies mit quadratischem Aufwand einher geht, und somit
@@ -279,9 +281,8 @@ Polygon PictWriter::PolyPolygonToPolygon(const PolyPolygon & rPolyPoly)
             if (nCountdownTests<=0) break;
         }
 
-        // Nun werden aPoly1 und aPoly2 zu einem Polygon aPoly3 (spaeter aPoly1) zusammengefuegt.
-        // Die beiden Polygone werden verbunden durch zwei zusaetzliche Kanten zwischen den oben
-        // gefundenen Punkten.
+        // Now aPoly1 and aPoly2 are being merged to a polygon aPoly3 (later aPoly1)
+        // Both polygons are being connected by two additional edges between the points found above
         aPoly3.Clear();
         aPoly3.SetSize(nSize1+nSize2+2);
         i3=0;
@@ -898,7 +899,7 @@ void PictWriter::WriteOpcode_BitsRect(const Point & rPoint, const Size & rSize,
 
     SetAttrForPaint();
 
-    // temopraere Windows-BMP-Datei erzeugen:
+    // generating a temporary Windows-BMP-File:
     nActBitmapPercent=30;
     MayCallback();
 
@@ -916,15 +917,14 @@ void PictWriter::WriteOpcode_BitsRect(const Point & rPoint, const Size & rSize,
     nWidth = pAcc->Width();
     nHeight = pAcc->Height();
 
-    // Wenn 24-Bit, dann den Opcode 'DirectBitsRect' erzeugen:
+    // If 24-Bit, then create the Opcode 'DirectBitsRect':
     if ( nBitsPerPixel == 24 )
     {
-
-        // Anzahl Bytes einer (ungepackten) Zeile in Quelle und Ziel berechnen:
+:Anzahl Bytes einer (ungepackten) Zeile in Quelle und Ziel berechnen:
         nSrcRowBytes =( ( 3 * nWidth ) + 0x0003 ) & 0xfffc;
         nDstRowBytes = nWidth * 4;
 
-        // Opcode und BaseAddr (?) schreiben:
+        // writing Opcode and BaseAddr (?):
         *pPict << (sal_uInt16)0x009a << (sal_uInt32)0x000000ff;
 
         // Normalerweise wollen wir den Packing-Type 4 (Run length encoding
@@ -938,12 +938,12 @@ void PictWriter::WriteOpcode_BitsRect(const Point & rPoint, const Size & rSize,
         else
             nPackType = 4;
 
-        // PixMap-Struktur schreiben:
-        *pPict << (sal_uInt16)(nDstRowBytes|0x8000) // Bytes pro Zeile und dass es eine 'PixMap' ist
-               << (sal_uInt16)0x0000                // Y1-Position der Bitmap in der Quelle
-               << (sal_uInt16)0x0000                // X1-Position der Bitmap in der Quelle
-               << (sal_uInt16)nHeight               // Y2-Position der Bitmap in der Quelle
-               << (sal_uInt16)nWidth                // X2-Position der Bitmap in der Quelle
+        // writing PixMap-Structure:
+        *pPict << (sal_uInt16)(nDstRowBytes|0x8000) // Bytes per row and the fact that it's a 'PixMap'
+               << (sal_uInt16)0x0000                // Y1-position of the bitmap in the source
+               << (sal_uInt16)0x0000                // X1-position of the bitmap in the source
+               << (sal_uInt16)nHeight               // Y2-position of the bitmap in the source
+               << (sal_uInt16)nWidth                // X2-position of the bitmap in the source
                << (sal_uInt16)0x0000                // Version
                << (sal_uInt16)nPackType             // Packing type
                << (sal_uInt32) 0x00000000            // Packing size (?)
@@ -951,48 +951,48 @@ void PictWriter::WriteOpcode_BitsRect(const Point & rPoint, const Size & rSize,
                << (sal_uInt32) 0x00480000            // V-Res
                << (sal_uInt16)0x0010                // Pixel type (?)
                << (sal_uInt16)0x0020                // Pixel size: 32 bit
-               << (sal_uInt16)0x0004                // CmpCount: 4 Komponenten
-               << (sal_uInt16)0x0008                // CmpSize: 8 Bits
+               << (sal_uInt16)0x0004                // CmpCount: 4 components
+               << (sal_uInt16)0x0008                // CmpSize: 8 bits
                << (sal_uInt32) 0x00000000            // PlaneBytes (?)
                << (sal_uInt32) 0x00000000            // (?)
                << (sal_uInt32) 0x00000000;           // (?)
 
         // Source-Rectangle schreiben:
-        *pPict << (sal_uInt16)0x0000                // Y1-Position auf der Bitmap
-               << (sal_uInt16)0x0000                // X1-Position auf der Bitmap
-               << (sal_uInt16)nHeight               // Y2-Position auf der Bitmap
-               << (sal_uInt16)nWidth;               // X2-Position auf der Bitmap
+        *pPict << (sal_uInt16)0x0000                // Y1-position on the bitmap
+               << (sal_uInt16)0x0000                // X1-position on the bitmap
+               << (sal_uInt16)nHeight               // Y2-position on the bitmap
+               << (sal_uInt16)nWidth;               // X2-position on the bitmap
 
-        // Destination-Rectangle schreiben:
+        // writing the Destination-Rectangle:
         WritePoint( rPoint );
         WritePoint( Point( rPoint.X() + rSize.Width(), rPoint.Y() + rSize.Height() ) );
 
-        // Transfer mode schreiben:
+        // writing the Transfer mode:
         *pPict << (sal_uInt16)0x0000; // (?)
 
-        // Position der Map-Daten in Ziel merken:
+        // remember position of the Map-data in the target:
         nDstMapPos=pPict->Tell();
 
-        if ( nPackType == 1 )               // bei 24 bits nWidth == 1 !!
-        {                                   // nicht packen
+        if ( nPackType == 1 )               //  when 24 bits nWidth == 1 !!
+        {                                   // don't pack
             for ( ny = 0; ny < nHeight; ny++ )
             {
                 *pPict << (sal_uInt8)0;
                 *pPict << (sal_uInt8)pAcc->GetPixel( ny, 0 ).GetRed();
                 *pPict << (sal_uInt8)pAcc->GetPixel( ny, 0 ).GetGreen();
                 *pPict << (sal_uInt8)pAcc->GetPixel( ny, 0 ).GetBlue();
-                // Prozente zaehlen, Callback, Fehler pruefen:
-                nActBitmapPercent = ( ny * 70 / nHeight ) + 30; // (30% machten schon das Schreiben der Win-BMP-Datei aus)
+                // count percentages, Callback, check errors:
+                nActBitmapPercent = ( ny * 70 / nHeight ) + 30; // (30% already added up to the writing of the Win-BMP file)
                 MayCallback();
             }
         }
-        else    // packen ( PackType == 4 )
+        else    // packing ( PackType == 4 )
         {
             // Speicher fuer Zeilen-Zwischen-Datenstruktur allozieren:
             for ( nc = 0; nc < 4; nc++ )
                 pComp[ nc ] = new sal_uInt8[ nWidth ];
 
-            // Schleife ueber Zeilen:
+            // loop trough rows:
             for ( ny = 0; ny < nHeight; ny++ )
             {
                 // Zeil ny der Quelle in die Zwischen-Datenstrktur einlesen:
@@ -1005,25 +1005,25 @@ void PictWriter::WriteOpcode_BitsRect(const Point & rPoint, const Size & rSize,
                     pComp[ 0 ][ nx ] = 0;
                 }
 
-                // Anfang der Zeile im Ziel merken:
+                // remember start of the row in the target:
                 nDstRowPos = pPict->Tell();
 
-                // ByteCount (das ist die Groesse der gepackten Zeile) zunaechst 0 (wird spaeter berichtigt):
+                // ByteCount (that's the size of the packed row) is at first 0 (will be corrected later):
                 if ( nDstRowBytes > 250 )
                     *pPict << (sal_uInt16)0;
                 else
                     *pPict << (sal_uInt8)0;
 
-                // Schleife ueber Componenten:
+                // loop trough components:
                 for ( nc = 0; nc < 4; nc++ )
                 {
-                    // Schleife ueber x:
+                    // loop through x:
                     nx = 0;
                     while ( nx < nWidth )
                     {
-                        // Die Position von 3 gleichen Bytes suchen und in nEqu3 merken.
-                        // wenn nicht gefunden, dann nEqu3=nWidth setzten.
-                        // Wenn doch gefunden, dann in nEquData den Wert der Bytes merken.
+                        // look up the position of 3 equal bytes and seve it in nEqu3
+                        // if it's not found, set nEqu3=nWidth
+                        // if it's found save the value of the bytes in nEquData
                         nEqu3 = nx;
                         for (;;)
                         {
@@ -1057,23 +1057,23 @@ void PictWriter::WriteOpcode_BitsRect(const Point & rPoint, const Size & rSize,
                         // Jetzt einen Komprimierungs-Record erzeugen (falls oben mindestens 3
                         // gleiche Bytes gefunden):
                         if ( nx < nWidth )
-                        {               // Hinweis: es gilt nx==nEqu3 (hoffentlich)
-                            nCount=3;   // Drei Bytes sind gleich, wie weiter oben herausgefunden.
-                                        // Pruefen, ob es weitere gleiche Bytes gibts (dabei Max.-Record-Groesse beachten):
+                        {               // Hint: Then one has nx==nEqu3 (hopefully)
+                            nCount=3;   // Three bytes are equal, as we found out above
+                                        // Check, whether there are further equal bytes (and pay attention to Max.-Record-Size):
                             while ( nx + nCount < nWidth && nCount < 128 )
                             {
                                 if ( nEquData != pComp[ nc ][ nx + nCount ] )
                                     break;
                                 nCount++;
                             }
-                            // nCount gleiche Bytes komprimiert schreiben:
+                            // nCount write equal Bytes compressed:
                             nFlagCounterByte = (sal_uInt8)( 1 - (long)nCount );
                             *pPict << nFlagCounterByte << nEquData;
                             nx += nCount;
                         }
                     }
                 }
-                // ByteCount berichtigen:
+                // correct ByteCount:
                 nPos = pPict->Tell();
                 pPict->Seek( nDstRowPos );
                 if ( nDstRowBytes > 250 )
@@ -1082,17 +1082,17 @@ void PictWriter::WriteOpcode_BitsRect(const Point & rPoint, const Size & rSize,
                     *pPict << ( (sal_uInt8)( nPos - nDstRowPos - 1 ) );
                 pPict->Seek( nPos );
 
-                // Prozente zaehlen, Callback, Fehler pruefen:
+                // count percentages, Callback, check errors:
                 nActBitmapPercent = ( ny * 70 / nHeight ) + 30; // (30% machten schon das Schreiben der Win-BMP-Datei aus)
                 MayCallback();
             }
-            // Aufraeumen:
+            // clean up:
             for ( nc = 0; nc < 4; nc++ )
                 delete pComp[ nc ];
         }
     }
     else
-    {   // nicht 24-Bit also Opcode 'PackBitsRect' erzeugen:
+    {   // don't generate 24-bit i.e. Opcode 'PackBitsRect':
 
         // Bei 1-Bit-Bildern ignorieren manche Import-Filter die Palette und nehmen statt
         // dessen die Vorder- und Hintergrundfarbe:
@@ -1111,7 +1111,7 @@ void PictWriter::WriteOpcode_BitsRect(const Point & rPoint, const Size & rSize,
         nDstRowBytes = ( nWidth * nBitsPerPixel + 7 ) >> 3;
         nSrcRowBytes = ( nDstRowBytes + 3 ) & 0xfffffffc;
 
-        // Opcode schreiben:
+        // writing Opcode:
         *pPict << (sal_uInt16)0x0098;
 
         // Normalerweise wollen wir den Packing-Type 0 (default Packing) erzeugen.
@@ -1124,12 +1124,12 @@ void PictWriter::WriteOpcode_BitsRect(const Point & rPoint, const Size & rSize,
         else
             nPackType = 0;
 
-        // PixMap-Struktur schreiben:
-        *pPict << (sal_uInt16)(nDstRowBytes|0x8000) // Bytes pro Zeile und dass es eine 'PixMap' ist
-               << (sal_uInt16)0x0000                // Y1-Position der Bitmap in der Quelle
-               << (sal_uInt16)0x0000                // X1-Position der Bitmap in der Quelle
-               << (sal_uInt16)nHeight               // Y2-Position der Bitmap in der Quelle
-               << (sal_uInt16)nWidth                // X2-Position der Bitmap in der Quelle
+        // write PixMap-Structure:
+        *pPict << (sal_uInt16)(nDstRowBytes|0x8000) // Bytes per row and the fact that it's a 'PixMap'
+               << (sal_uInt16)0x0000                // Y1-position of the bitmap in the source
+               << (sal_uInt16)0x0000                // X1-position of the bitmap in the source
+               << (sal_uInt16)nHeight               // Y2-position of the bitmap in the source
+               << (sal_uInt16)nWidth                // X2-position of the bitmap in the source
                << (sal_uInt16)0x0000                // Version
                << (sal_uInt16)nPackType             // Packing type
                << (sal_uInt32) 0x00000000            // Packing size (?)
@@ -1137,13 +1137,13 @@ void PictWriter::WriteOpcode_BitsRect(const Point & rPoint, const Size & rSize,
                << (sal_uInt32) 0x00480000            // V-Res
                << (sal_uInt16)0x0000                // Pixel type (?)
                << (sal_uInt16)nBitsPerPixel         // Pixel size
-               << (sal_uInt16)0x0001                // CmpCount: 1 Komponente
+               << (sal_uInt16)0x0001                // CmpCount: 1 component
                << (sal_uInt16)nBitsPerPixel         // CmpSize
                << (sal_uInt32) 0x00000000            // PlaneBytes (?)
                << (sal_uInt32) 0x00000000            // (?)
                << (sal_uInt32) 0x00000000;           // (?)
 
-        // Palette lesen und schreiben:
+        // writing and reading the palette:
         nColTabSize = pAcc->GetPaletteEntryCount();
         *pPict << (sal_uInt32)0 << (sal_uInt16)0x8000 << (sal_uInt16)( nColTabSize - 1 );
 
@@ -1155,23 +1155,23 @@ void PictWriter::WriteOpcode_BitsRect(const Point & rPoint, const Size & rSize,
             *pPict << (sal_uInt16)0 << nRed << nRed << nGreen << nGreen << nBlue << nBlue;
         }
 
-        // Source-Rectangle schreiben:
+        // writing Source-Rectangle:
         *pPict << (sal_uInt16)0 << (sal_uInt16)0 << (sal_uInt16)nHeight << (sal_uInt16)nWidth;
 
-        // Destination-Rectangle schreiben:
+        // writing Destination-Rectangle:
         WritePoint( rPoint );
         WritePoint( Point( rPoint.X() + rSize.Width(), rPoint.Y() + rSize.Height() ) );
 
-        // Transfer mode schreiben:
+        // writing Transfer mode:
         *pPict << (sal_uInt16)0;            // (?)
 
-        // Speicher fuer eine Zeile allozieren:
+        // allocate memory for a row:
         pPix = new sal_uInt8[ nSrcRowBytes ];
 
         // Position der Map-Daten in Ziel merken:
         nDstMapPos=pPict->Tell();
 
-        // Schleife ueber Zeilen:
+        // loop trough rows:
         for ( ny = 0; ny < nHeight; ny++ )
         {
 
@@ -1198,13 +1198,13 @@ void PictWriter::WriteOpcode_BitsRect(const Point & rPoint, const Size & rSize,
             }
 
             if ( nPackType == 1 )
-            {   // nicht packen
+            {   // don't pack
                 pPict->Write( pPix, nDstRowBytes );
             }
             else
-            {   // Packen (nPackType==0)
+            {   // Ppacking (nPackType==0)
 
-                // Anfang der Zeile im Ziel merken:
+                // remeber start of the row in the target:
                 nDstRowPos = pPict->Tell();
 
                 // ByteCount (das ist die Groesse der gepackten Zeile) zunaechst 0 (wird spaeter berichtigt):
@@ -1213,7 +1213,7 @@ void PictWriter::WriteOpcode_BitsRect(const Point & rPoint, const Size & rSize,
                 else
                     *pPict << (sal_uInt8)0;
 
-                // Schleife ueber Bytes der Zeile:
+                // loop trough bytes of the row:
                 nx=0;
                 while ( nx < nDstRowBytes && bStatus )
                 {
@@ -1268,7 +1268,7 @@ void PictWriter::WriteOpcode_BitsRect(const Point & rPoint, const Size & rSize,
                     }
                 }
 
-                // ByteCount berichtigen:
+                // correct ByteCount:
                 nPos = pPict->Tell();
                 pPict->Seek( nDstRowPos );
                 if ( nDstRowBytes > 250 )
@@ -1278,21 +1278,21 @@ void PictWriter::WriteOpcode_BitsRect(const Point & rPoint, const Size & rSize,
                 pPict->Seek( nPos );
             }
 
-            // Prozente zaehlen, Callback, Fehler pruefen:
+            // count percentages, Callback, check errors:
             nActBitmapPercent =( ny * 70 / nHeight ) + 30; // (30% machten schon das Schreiben der Win-BMP-Datei aus)
             MayCallback();
             if ( pPict->GetError() )
                 bStatus = sal_False;
         }
-        // Aufraeumen:
+        // cleaning up:
         delete[] pPix;
     }
 
-    // Map-Daten muessen gerade Anzahl von Bytes sein:
+    // Map-Data has to be an even number of bytes:
     if ( ( ( pPict->Tell() - nDstMapPos ) & 1 ) != 0 )
         *pPict << (sal_uInt8)0;
 
-    // Bitmaps zaehlen:
+    // counting Bitmaps:
     nWrittenBitmaps++;
     nActBitmapPercent = 0;
     if ( pAcc )
@@ -2183,13 +2183,13 @@ void PictWriter::WriteHeader(const GDIMetaFile & rMTF)
     Point aPoint;
     Rectangle   aRect( aPoint, aSize );
 
-    // 512 Bytes "Muell" am Anfang:
+    // 512 Bytes "trash" at the beginning:
     for (i=0;i<128;i++) *pPict << (sal_uInt32)0;
 
-    // Lo-16-Bits der Groesse der Datei ohne die 512 Bytes Muell:
-    *pPict << (sal_uInt16)0; // wird spaeter durch UpdateHeader() berichtigt
+    // Lo-16-Bits of the file size without the 512 bytes trash:
+    *pPict << (sal_uInt16)0; // gets corrected later on by UpdateHeader()
 
-    // Das Bounding-Rectangle (y1,x1,y2,x2 !):
+    // The Bounding-Rectangle (y1,x1,y2,x2 !):
     WriteRectangle( aRect );
 
     // Version 2:
@@ -2204,8 +2204,8 @@ void PictWriter::WriteHeader(const GDIMetaFile & rMTF)
     WriteRectangle( aRect );
     *pPict << (sal_uInt32)0x00000000;                        // Reserved
 
-    // viele Import-Filter verlangen die Angabe eines
-    // Clipping-Bereichs am Anfang
+    // many import filters demand the declaration
+    // of a clipping area at the beginning
 
     WriteOpcode_ClipRect( aRect );
 }
@@ -2215,7 +2215,7 @@ void PictWriter::UpdateHeader()
 {
     sal_uLong nPos;
 
-    // Lo-16-Bits der Groesse der Datei ohne die 512 Bytes Muell berichtigen:
+    // correct the Lo-16-Bits of the file size without the 512 bytes trash:
     nPos=pPict->Tell();
     pPict->Seek(512);
     *pPict << (sal_uInt16)((nPos-512)&0x0000ffff);
@@ -2296,7 +2296,7 @@ sal_Bool PictWriter::WritePict(const GDIMetaFile & rMTF, SvStream & rTargetStrea
     return bStatus;
 }
 
-//================== GraphicExport - die exportierte Funktion ================
+//================== GraphicExport - the exported Function ================
 
 extern "C" SAL_DLLPUBLIC_EXPORT sal_Bool __LOADONCALLAPI
 GraphicExport(SvStream & rStream, Graphic & rGraphic, FilterConfigItem* pFilterConfigItem, sal_Bool)
diff --git a/filter/source/graphicfilter/eppm/eppm.cxx b/filter/source/graphicfilter/eppm/eppm.cxx
index e65343aff2da..0b114e653c29 100644
--- a/filter/source/graphicfilter/eppm/eppm.cxx
+++ b/filter/source/graphicfilter/eppm/eppm.cxx
@@ -62,7 +62,7 @@ public:
     sal_Bool                WritePPM( const Graphic& rGraphic, FilterConfigItem* pFilterConfigItem );
 };
 
-//=================== Methoden von PPMWriter ==============================
+//=================== Methods of PPMWriter ==============================
 
 PPMWriter::PPMWriter(SvStream &rStrm)
     : m_rOStm(rStrm)
@@ -217,7 +217,7 @@ void PPMWriter::ImplWriteBody()
 }
 
 // ------------------------------------------------------------------------
-// eine Dezimalzahl im ASCII format wird in den Stream geschrieben
+// a decimal number in ASCII format is being written into the stream
 
 void PPMWriter::ImplWriteNumber(sal_Int32 nNumber)
 {
diff --git a/filter/source/graphicfilter/idxf/dxfreprd.cxx b/filter/source/graphicfilter/idxf/dxfreprd.cxx
index 074ce3282e02..7a2c93a9d276 100644
--- a/filter/source/graphicfilter/idxf/dxfreprd.cxx
+++ b/filter/source/graphicfilter/idxf/dxfreprd.cxx
@@ -59,20 +59,20 @@ DXFPalette::DXFPalette()
     pGreen=new sal_uInt8[256];
     pBlue =new sal_uInt8[256];
 
-    // Farben 0 - 9 (normale Farben)
-    SetColor(0, 0x00, 0x00, 0x00); // eigentlich nie benutzt
+    // colors 0 - 9 (normal colors)
+    SetColor(0, 0x00, 0x00, 0x00); // actually never being used
     SetColor(1, 0xff, 0x00, 0x00);
     SetColor(2, 0xff, 0xff, 0x00);
     SetColor(3, 0x00, 0xff, 0x00);
     SetColor(4, 0x00, 0xff, 0xff);
     SetColor(5, 0x00, 0x00, 0xff);
     SetColor(6, 0xff, 0x00, 0xff);
-    SetColor(7, 0x0f, 0x0f, 0x0f); // eigentlich weiss ???
+    SetColor(7, 0x0f, 0x0f, 0x0f); // actually white???
     SetColor(8, 0x80, 0x80, 0x80);
     SetColor(9, 0xc0, 0xc0, 0xc0);
 
-    // Farben 10 - 249
-    // (Universal-Palette: 24 Farbtoene * 5 Helligkeiten * 2 Saettigungen )
+    // colors 10 - 249
+    // (Universal-Palette: 24 hues * 5 lightnesses * 2 saturations )
     i=10;
     for (nHue=0; nHue<24; nHue++) {
         for (nVal=5; nVal>=1; nVal--) {
@@ -100,7 +100,7 @@ DXFPalette::DXFPalette()
         }
     }
 
-    // Farben 250 - 255 (Grautoenne)
+    // Farben 250 - 255 (shades of gray)
     for (i=0; i<6; i++) {
         nV=(sal_uInt8)(i*38+65);
         SetColor((sal_uInt8)(250+i),nV,nV,nV);
diff --git a/filter/source/graphicfilter/idxf/dxfreprd.hxx b/filter/source/graphicfilter/idxf/dxfreprd.hxx
index 2b804c91b66f..32db3c2d99b5 100644
--- a/filter/source/graphicfilter/idxf/dxfreprd.hxx
+++ b/filter/source/graphicfilter/idxf/dxfreprd.hxx
@@ -25,10 +25,10 @@
 
 
 //----------------------------------------------------------------------------
-//--------------------Nebensachen---------------------------------------------
+//--------------------Other stuff---------------------------------------------
 //----------------------------------------------------------------------------
 
-//-------------------Eine 3D-Min/Max-Box--------------------------------------
+//-------------------A 3D-Min/Max-Box-----------------------------------------
 
 class DXFBoundingBox {
 public:
@@ -45,7 +45,7 @@ public:
 };
 
 
-//-------------------Die (konstante) Palette fuer DXF-------------------------
+//-------------------The (constant) palette for DXF-------------------------
 
 class DXFPalette {
 
@@ -67,7 +67,7 @@ private:
 
 
 //----------------------------------------------------------------------------
-//-----------------DXF Datei lesen und repraesentieren------------------------
+//-----------------read and represent DXF file--------------------------------
 //----------------------------------------------------------------------------
 
 class DXFRepresentation {
@@ -75,20 +75,20 @@ class DXFRepresentation {
 public:
 
     DXFPalette aPalette;
-        // Die immer gleiche DXF-Farb-Palette
+        // The always equal DXF color palette
 
     DXFBoundingBox aBoundingBox;
-        // Ist gleich den AutoCAD-Variablen EXTMIN, EXTMAX sofern in DXF-Datei
-        // vorhanden, anderenfalls wird die BoundingBox berechnet (in Read()).
+        // is equal to the AutoCAD variables EXTMIN, EXTMAX if those exist
+        // within the DXF file. Otherwise the BoundingBox gets calculated (in Read())
 
     DXFTables aTables;
-        // Die Tabellen der DXF-Datei
+        // the tables of the DXF file
 
     DXFBlocks aBlocks;
-        // Die Bloecke der DXF-Datei
+        // the blocks of the DXF file
 
     DXFEntities aEntities;
-        // Die Entities (aus der Entities-Section) der DXF-Datei
+        // the entities (from the Entities-Section) of the DXF file
 
     rtl_TextEncoding mEnc;  // $DWGCODEPAGE
 
diff --git a/filter/source/graphicfilter/idxf/dxfvec.cxx b/filter/source/graphicfilter/idxf/dxfvec.cxx
index 9c8c110ade6f..e8ae4afa923f 100644
--- a/filter/source/graphicfilter/idxf/dxfvec.cxx
+++ b/filter/source/graphicfilter/idxf/dxfvec.cxx
@@ -83,7 +83,7 @@ DXFTransform::DXFTransform(double fScaleX, double fScaleY, double fScaleZ,
 DXFTransform::DXFTransform(const DXFVector & rExtrusion) :
     aMX(), aMY(), aMZ(), aMP(0.0, 0.0, 0.0)
 {
-    // 'Arbitrary Axis Algorithm' (siehe DXF-Doku von Autodesk)
+    // 'Arbitrary Axis Algorithm' (cf. DXF documentation by Autodesk)
     if ( fabs(rExtrusion.fx) < 1.0/64.0 && fabs(rExtrusion.fy) < 1.0/64.0) {
         aMX = DXFVector(0.0, 1.0, 0.0) * rExtrusion;
     }
diff --git a/filter/source/graphicfilter/idxf/dxfvec.hxx b/filter/source/graphicfilter/idxf/dxfvec.hxx
index 1f1b34a016b7..41cfcc0b7a82 100644
--- a/filter/source/graphicfilter/idxf/dxfvec.hxx
+++ b/filter/source/graphicfilter/idxf/dxfvec.hxx
@@ -63,7 +63,7 @@ class DXFVector {
 
 public:
 
-    double fx,fy,fz; // public ! - Warum nicht ?
+    double fx,fy,fz; // public ! - why not?
 
     inline DXFVector(double fX=0.0, double fY=0.0, double fZ=0.0);
     inline DXFVector(const DXFVector & rV);
@@ -84,7 +84,7 @@ public:
     DXFVector & operator *= (double fs);
     DXFVector   operator *  (double fs) const;
 
-    // Laenge:
+    // length:
     double Abs() const;
 
     // Vektor gleicher Richtung und der Laenge 1:
diff --git a/filter/source/graphicfilter/ios2met/ios2met.cxx b/filter/source/graphicfilter/ios2met/ios2met.cxx
index c5f2402eb34b..ef0caea7b6da 100644
--- a/filter/source/graphicfilter/ios2met/ios2met.cxx
+++ b/filter/source/graphicfilter/ios2met/ios2met.cxx
@@ -258,8 +258,8 @@ struct OSBitmap {
     sal_uLong nID;
     Bitmap aBitmap;
 
-    // Waehrend des Lesens der Bitmap benoetigt:
-    SvStream * pBMP; // Zeiger auf temporaere Windows-BMP-Datei oder NULL
+    // required during reading of the bitmap:
+    SvStream * pBMP; // pointer to temporary Windows-BMP file or NULL
     sal_uInt32 nWidth, nHeight;
     sal_uInt16 nBitsPerPixel;
     sal_uLong nMapPos;
@@ -269,7 +269,7 @@ struct OSBitmap {
 struct OSAttr {
     OSAttr * pSucc;
     sal_uInt16 nPushOrder;
-    sal_uInt8 nIvAttrA, nIvAttrP; // Spezialvariablen fuer den Order "GOrdPIvAtr"
+    sal_uInt8 nIvAttrA, nIvAttrP; // special variables for the Order "GOrdPIvAtr"
 
     Color    aLinCol;
     Color    aLinBgCol;
@@ -330,14 +330,14 @@ private:
     long ErrorCode;
 
     SvStream    * pOS2MET;             // Die einzulesende OS2MET-Datei
-    VirtualDevice * pVirDev;         // Hier werden die Drawing-Methoden aufgerufen.
+    VirtualDevice * pVirDev;         // here the drawing methods are being called
                                      // Dabei findet ein Recording in das GDIMetaFile
                                      // statt.
     sal_uLong         nOrigPos;          // Anfaengliche Position in pOS2MET
     sal_uInt16        nOrigNumberFormat; // Anfaengliches Nummern-Format von pOS2MET
     Rectangle aBoundingRect; // Boundingrectangle wie in Datei angegeben
     Rectangle aCalcBndRect;  // selbst ermitteltes Boundingrectangle
-    MapMode aGlobMapMode;    // Aufloesung des Bildes
+    MapMode aGlobMapMode;    // resolution of the picture
     sal_Bool bCoord32;
 
     OSPalette  * pPaletteStack;
@@ -373,8 +373,8 @@ private:
 
     void SetPalette0RGB(sal_uInt16 nIndex, sal_uLong nCol);
     sal_uInt32 GetPalette0RGB(sal_uInt32 nIndex);
-        // Holt Farbe aus der Palette, oder, wenn nicht vorhanden,
-        // interpretiert nIndex als direkten RGB-Wert.
+        // gets color from palette, or, if it doesn't exist,
+        // interprets nIndex as immediate RGB value.
     Color GetPaletteColor(sal_uInt32 nIndex);
 
 
@@ -417,7 +417,7 @@ public:
 
 };
 
-//=================== Methoden von OS2METReader ==============================
+//=================== Methoda of OS2METReader ==============================
 
 sal_Bool OS2METReader::Callback(sal_uInt16 /*nPercent*/)
 {
@@ -1039,7 +1039,7 @@ void OS2METReader::ReadArc(sal_Bool bGivenPos)
     cy=( q*q*((x3*x3-x1*x1)*(x2-x1)+(x2*x2-x1*x1)*(x1-x3)) +
          p*p*((y3*y3-y1*y1)*(x2-x1)+(y2*y2-y1*y1)*(x1-x3)) ) / ncy;
     cx=( q*q*(x2*x2-x1*x1)+p*p*(y2*y2-y1*y1)+cy*2*p*p*(y1-y2) ) / ncx;
-    // Nun brauchen wir noch den Radius in x und y Richtung:
+    // now we still need the radius in x and y direction:
     r=sqrt(q*q*(x1-cx)*(x1-cx)+p*p*(y1-cy)*(y1-cy));
     rx=r/q; ry=r/p;
     // Jetzt stellt sich "nur noch" die Frage, wie Start- und Endpunkt
@@ -2148,7 +2148,7 @@ void OS2METReader::ReadDsc(sal_uInt16 nDscID, sal_uInt16 /*nDscLen*/)
 
 void OS2METReader::ReadImageData(sal_uInt16 nDataID, sal_uInt16 nDataLen)
 {
-    OSBitmap * p=pBitmapList; if (p==NULL) return; // Nanu ?
+    OSBitmap * p=pBitmapList; if (p==NULL) return;
 
     switch (nDataID) {
 
@@ -2190,12 +2190,12 @@ void OS2METReader::ReadImageData(sal_uInt16 nDataID, sal_uInt16 nDataLen)
                     ErrorCode=3;
                     return;
                 }
-                // Schreibe (Windows-)BITMAPINFOHEADER:
+                // write (Windows-)BITMAPINFOHEADER:
                 *(p->pBMP) << ((sal_uInt32)40) << p->nWidth << p->nHeight;
                 *(p->pBMP) << ((sal_uInt16)1) << p->nBitsPerPixel;
                 *(p->pBMP) << ((sal_uInt32)0) << ((sal_uInt32)0) << ((sal_uInt32)0) << ((sal_uInt32)0);
                 *(p->pBMP) << ((sal_uInt32)0) << ((sal_uInt32)0);
-                // Schreibe Farbtabelle:
+                // write color table:
                 if (p->nBitsPerPixel<=8) {
                     sal_uInt16 i, nColTabSize=1<<(p->nBitsPerPixel);
                     for (i=0; i<nColTabSize; i++) *(p->pBMP) << GetPalette0RGB(i);
@@ -2361,7 +2361,7 @@ void OS2METReader::ReadField(sal_uInt16 nFieldType, sal_uInt16 nFieldSize)
             pB->pSucc=pBitmapList; pBitmapList=pB;
             pB->pBMP=NULL; pB->nWidth=0; pB->nHeight=0; pB->nBitsPerPixel=0;
             pB->nMapPos=0;
-            // ID der Bitmap ermitteln:
+            // determine ID of the bitmap:
             sal_uInt8 i,nbyte,nbyte2;
             pB->nID=0;
             for (i=0; i<4; i++) {
@@ -2392,7 +2392,7 @@ void OS2METReader::ReadField(sal_uInt16 nFieldType, sal_uInt16 nFieldSize)
                 ErrorCode=6;
             }
             delete pBitmapList->pBMP; pBitmapList->pBMP=NULL;
-            // Palette vom Stack killen:
+            // kill palette from stack:
             OSPalette * pP=pPaletteStack;
             if (pP!=NULL) {
                 pPaletteStack=pP->pSucc;
@@ -2453,14 +2453,14 @@ void OS2METReader::ReadField(sal_uInt16 nFieldType, sal_uInt16 nFieldSize)
             nMaxPos=pOS2MET->Tell();
             pOS2MET->Seek(0);
 
-            // "Segmentheader":
+            // "Segment header":
             *pOS2MET >> nbyte;
-            if (nbyte==0x70) { // Header vorhanden
-                pOS2MET->SeekRel(15); // brauchen wir aber nicht
+            if (nbyte==0x70) { // header exists
+                pOS2MET->SeekRel(15); // but we don't need it
             }
-            else pOS2MET->SeekRel(-1); // Kein Header, Byte zurueck
+            else pOS2MET->SeekRel(-1); // no header, go back one byte
 
-            // Schleife ueber Order:
+            // loop through Order:
             while (pOS2MET->Tell()<nMaxPos && pOS2MET->GetError()==0) {
                 *pOS2MET >> nbyte; nOrderID=((sal_uInt16)nbyte) & 0x00ff;
                 if (nOrderID==0x00fe) {
@@ -2483,7 +2483,7 @@ void OS2METReader::ReadField(sal_uInt16 nFieldType, sal_uInt16 nFieldSize)
                 nPos=pOS2MET->Tell();
                 ReadOrder(nOrderID, nOrderLen);
                 if (nPos+nOrderLen < pOS2MET->Tell()) {
-                    OOODEBUG("Order kuerzer als er denkt! OrderID:",nOrderID);
+                    OOODEBUG("Order shorter than he assumes! OrderID:",nOrderID);
                     OOODEBUG("...und zwar bei Position (Parameteranfang):",nPos);
                 }
                 else if (nPos+nOrderLen != pOS2MET->Tell()) {
diff --git a/filter/source/graphicfilter/ipcd/ipcd.cxx b/filter/source/graphicfilter/ipcd/ipcd.cxx
index 3a0388e55c05..211ad6009e4e 100644
--- a/filter/source/graphicfilter/ipcd/ipcd.cxx
+++ b/filter/source/graphicfilter/ipcd/ipcd.cxx
@@ -37,13 +37,13 @@
 
 //============================ PCDReader ==================================
 
-// Diese Aufloesungen sind in einer PCD-Datei enthalten:
+// these resolutions are contained in a PCD file:
 enum PCDResolution {
     PCDRES_BASE16,  //  192 x  128
     PCDRES_BASE4,   //  384 x  256
     PCDRES_BASE,    //  768 x  512
-    // Die folgenden sind komprimiert und koennen
-    // von uns NICHT gelesen werden:
+    // the following ones are compressed 
+    // and CANNOT be read by us
     PCDRES_4BASE,   // 1536 x 1024
     PCDRES_16BASE   // 3072 x 3072
 };
@@ -59,29 +59,29 @@ private:
     SvStream &m_rPCD;
     BitmapWriteAccess*  mpAcc;
 
-    sal_uInt8               nOrientation;   // Ausrichtung des Bildes in der PCD-Datei:
-                                        // 0 - Turmspitze zeigt nach oben
-                                        // 1 - Turmspitze zeigt nach rechts
-                                        // 2 - Turmspitze zeigt nach unten
-                                        // 3 - Turmspitze zeigt nach links
+    sal_uInt8               nOrientation;   // orientation of the picture withinthe PCD file:
+                                        // 0 - spire point up
+                                        // 1 - spire points to the right
+                                        // 2 - spire points down
+                                        // 3 - spire points to the left
 
-    PCDResolution       eResolution;    // Welche Aufloesung wir haben wollen
+    PCDResolution       eResolution;    // which resolution we want
 
-    sal_uLong               nWidth;         // Breite des PCD-Bildes
-    sal_uLong               nHeight;        // Hoehe des PCD-Bildes
-    sal_uLong               nImagePos;      // Position des Bildes in der PCD-Datei
+    sal_uLong               nWidth;         // width of the PCD picture
+    sal_uLong               nHeight;        // heigth of the PCD picture
+    sal_uLong               nImagePos;      // position of the picture within the PCD file
 
-    // Temporare BLue-Green-Red-Bitmap
+    // temporary lLue-Green-Red-Bitmap
     sal_uLong               nBMPWidth;
     sal_uLong               nBMPHeight;
 
     void    MayCallback(sal_uLong nPercent);
 
     void    CheckPCDImagePacFile();
-        // Prueft, ob es eine Photo-CD-Datei mit 'Image Pac' ist.
+        // checks whether it's a Photo-CD file with 'Image Pac'
 
     void    ReadOrientation();
-        // Liest die Ausrichtung und setzt nOrientation
+        // reads the orientation and sets nOrientation
 
     void    ReadImage(sal_uLong nMinPercent, sal_uLong nMaxPercent);
 
@@ -96,7 +96,7 @@ public:
     sal_Bool ReadPCD( Graphic & rGraphic, FilterConfigItem* pConfigItem );
 };
 
-//=================== Methoden von PCDReader ==============================
+//=================== Methods of PCDReader ==============================
 
 sal_Bool PCDReader::ReadPCD( Graphic & rGraphic, FilterConfigItem* pConfigItem )
 {
@@ -107,13 +107,13 @@ sal_Bool PCDReader::ReadPCD( Graphic & rGraphic, FilterConfigItem* pConfigItem )
 
     MayCallback( 0 );
 
-    // Ist es eine PCD-Datei mit Bild ? ( setzt bStatus == sal_False, wenn nicht ):
+    // is it a PCD file with a picture? ( sets bStatus == sal_False, if that's not the case):
     CheckPCDImagePacFile();
 
-    // Orientierung des Bildes einlesen:
+    // read orientation of the picture:
     ReadOrientation();
 
-    // Welche Aufloesung wollen wir ?:
+    // which resolution do we want?:
     eResolution = PCDRES_BASE;
     if ( pConfigItem )
     {
@@ -123,7 +123,7 @@ sal_Bool PCDReader::ReadPCD( Graphic & rGraphic, FilterConfigItem* pConfigItem )
         else if ( nResolution == 0 )
             eResolution = PCDRES_BASE16;
     }
-    // Groesse und Position (Position in PCD-Datei) des Bildes bestimmen:
+    // determine size and position (position within the PCD file) of the picture:
     switch (eResolution)
     {
         case PCDRES_BASE16 :
@@ -208,11 +208,11 @@ void PCDReader::ReadImage(sal_uLong nMinPercent, sal_uLong nMaxPercent)
     sal_uLong  nx,ny,nW2,nH2,nYPair,ndy,nXPair;
     long   nL,nCb,nCr,nRed,nGreen,nBlue;
     sal_uInt8 * pt;
-    sal_uInt8 * pL0; // Luminanz fuer jeden Pixel der 1. Zeile des aktuellen Zeilen-Paars
-    sal_uInt8 * pL1; // Luminanz fuer jeden Pixel der 2. Zeile des aktuellen Zeilen-Paars
-    sal_uInt8 * pCb; // Blau-Chrominanz fuer je 2x2 Pixel des aktuellen Zeilen-Paars
-    sal_uInt8 * pCr; // Rot-Chrominanz fuer je 2x2 Pixel des aktuellen Zeilen-Paars
-    sal_uInt8 * pL0N, * pL1N, * pCbN, * pCrN; // wie oben, nur fuer das naechste Zeilen-Paar
+    sal_uInt8 * pL0; // luminance for each pixel of the 1st row of the current pair of rows
+    sal_uInt8 * pL1; // luminance for each pixel of the 2nd row of the current pair of rows
+    sal_uInt8 * pCb; // blue chrominance for each 2x2 pixel of the current pair of rows
+    sal_uInt8 * pCr; // red chrominance fuer je 2x2 pixel of the current pair of rows
+    sal_uInt8 * pL0N, * pL1N, * pCbN, * pCrN; // like above, but for the next pair of rows
 
     if ( bStatus == sal_False )
         return;
@@ -246,7 +246,7 @@ void PCDReader::ReadImage(sal_uLong nMinPercent, sal_uLong nMaxPercent)
 
     m_rPCD.Seek( nImagePos );
 
-    // naechstes Zeilen-Paar := erstes Zeile-Paar:
+    // next pair of rows := first pair of rows:
     m_rPCD.Read( pL0N, nWidth );
     m_rPCD.Read( pL1N, nWidth );
     m_rPCD.Read( pCbN, nW2 );
@@ -256,13 +256,13 @@ void PCDReader::ReadImage(sal_uLong nMinPercent, sal_uLong nMaxPercent)
 
     for ( nYPair = 0; nYPair < nH2; nYPair++ )
     {
-        // aktuelles Zeilen-Paar := naechstes Zeilen-Paar
+        // current pair of rows := next pair of rows:
         pt=pL0; pL0=pL0N; pL0N=pt;
         pt=pL1; pL1=pL1N; pL1N=pt;
         pt=pCb; pCb=pCbN; pCbN=pt;
         pt=pCr; pCr=pCrN; pCrN=pt;
 
-        // naechstes Zeilen-Paar holen:
+        // get the next pair of rows:
         if ( nYPair < nH2 - 1 )
         {
             m_rPCD.Read( pL0N, nWidth );
@@ -281,15 +281,15 @@ void PCDReader::ReadImage(sal_uLong nMinPercent, sal_uLong nMaxPercent)
             }
         }
 
-        // Schleife uber die beiden Zeilen des Zeilen-Paars:
+        // loop trough both rows of the pair of rows:
         for ( ndy = 0; ndy < 2; ndy++ )
         {
             ny = ( nYPair << 1 ) + ndy;
 
-            // Schleife ueber X:
+            // loop trough X:
             for ( nx = 0; nx < nWidth; nx++ )
             {
-                // nL,nCb,nCr fuer den Pixel nx,ny holen/berechenen:
+                // get/calculate nL,nCb,nCr for the pixel nx,ny:
                 nXPair = nx >> 1;
                 if ( ndy == 0 )
                 {
@@ -340,7 +340,7 @@ void PCDReader::ReadImage(sal_uLong nMinPercent, sal_uLong nMaxPercent)
                 if ( nBlue > 255 )
                     nBlue = 255;
 
-                // Farbwert in pBMPMap eintragen:
+                // register color value in pBMPMap:
                 if ( nOrientation < 2 )
                 {
                     if ( nOrientation == 0 )
@@ -374,7 +374,7 @@ void PCDReader::ReadImage(sal_uLong nMinPercent, sal_uLong nMaxPercent)
     rtl_freeMemory((void*)pCrN);
 }
 
-//================== GraphicImport - die exportierte Funktion ================
+//================== GraphicImport - the exported Function ================
 
 extern "C" SAL_DLLPUBLIC_EXPORT sal_Bool __LOADONCALLAPI
 GraphicImport(SvStream & rStream, Graphic & rGraphic, FilterConfigItem* pConfigItem, sal_Bool)
diff --git a/filter/source/graphicfilter/ipsd/ipsd.cxx b/filter/source/graphicfilter/ipsd/ipsd.cxx
index 0d3a8b0d3411..d0acce65ee8f 100644
--- a/filter/source/graphicfilter/ipsd/ipsd.cxx
+++ b/filter/source/graphicfilter/ipsd/ipsd.cxx
@@ -87,7 +87,7 @@ public:
     sal_Bool ReadPSD(Graphic & rGraphic);
 };
 
-//=================== Methoden von PSDReader ==============================
+//=================== Methods of PSDReader ==============================
 
 PSDReader::PSDReader(SvStream &rStream)
     : m_rPSD(rStream)
@@ -143,7 +143,7 @@ sal_Bool PSDReader::ReadPSD(Graphic & rGraphic )
             mpWriteAcc->SetPaletteColor( i, Color( mpPalette[ i ], mpPalette[ i + 256 ], mpPalette[ i + 512 ] ) );
         }
     }
-    // Bitmap-Daten einlesen
+    // read Bitmap-Daten
     if ( mbStatus && ImplReadBody() )
     {
         if ( mbTransparent )
@@ -253,7 +253,7 @@ sal_Bool PSDReader::ImplReadHeader()
         }
         break;
 
-        case PSD_DUOTONE :                  // we'll handle the doutone color like a normal grayscale picture
+        case PSD_DUOTONE :                  // we'll handle the duotone color like a normal grayscale picture
             m_rPSD.SeekRel( nColorLength );
             nColorLength = 0;
         case PSD_GRAYSCALE :
diff --git a/filter/source/graphicfilter/itiff/ccidecom.cxx b/filter/source/graphicfilter/itiff/ccidecom.cxx
index c55ebe4fe821..80880dad8acc 100644
--- a/filter/source/graphicfilter/itiff/ccidecom.cxx
+++ b/filter/source/graphicfilter/itiff/ccidecom.cxx
@@ -29,7 +29,7 @@
 
 #include "ccidecom.hxx"
 
-//=============================== Huffman-Tabellen ========================
+//=============================== Huffman tables ========================
 
 //---------------------------- White-Run ------------------------------
 
@@ -316,18 +316,15 @@ const CCIHuffmanTableEntry CCIUncompTable[CCIUncompTableSize]={
 };
 
 
-//================== Sicherheitskopie der Huffman-Tabellen ================
-// Um sicher zugehen, dass die Huffman-Tabellen keine Fehler enthalten,
-// wurden sie zweimal von unterschiedlichen Quellen eingegeben (Uff) und
-// verglichen.
-// Da sich aber im Laufe der Pflege des Source-Codes mal ein Fehler
-// einschleichen koennte (z.B. versehentlicher druck einer Taste im Editor)
-// werden die Tablellen hier weiterhin zweimal aufgefuehrt und zur Laufzeit
-// verglichen. (Wenn der Vergleich fehlschlaegt, liefert CCIDecompressor
-// immer einen Fehler). Das Ganze mag etwas wahnsinnig erscheinen, aber ein Fehler
-// in den Tabellen waere sonst sehr sehr schwer zu erkennen, zumal es
-// unwahrscheinlich ist, dass eine oder mehere Beispieldateien alle Codes
-// durchlaufen.
+//================== backup of the Huffman tables ============================
+// To make sure that the Huffman tables do not contain errors they were entered
+// from two different sources (Phew) and compared.
+// Since an error could creep in to the source code while maintaining it
+// (e.g. an accidentaly key press in the editor) the tables are listed twice
+// and are compared during runtime. (If the comparison fails CCIDcompressor
+// throws an error) The whole thing may appear insane, but an error within the
+// tables would otherwise be really hard to discover and it's very unlikely that 
+// one or more sample files run through all codes.
 
 const CCIHuffmanTableEntry CCIWhiteTableSave[CCIWhiteTableSize]={
     {    0, 0x0035,  8 },
@@ -638,7 +635,7 @@ sal_Bool CCIDecompressor::DecompressScanline( sal_uInt8 * pTarget, sal_uLong nTa
     sal_uInt8 * pSrc,* pDst;
     sal_Bool b2D;
 
-    if ( nEOLCount >= 5 )   // RTC( Return To Controller )
+    if ( nEOLCount >= 5 )   // RTC (Return To Controller)
         return sal_True;
 
     if ( bStatus == sal_False )
@@ -672,10 +669,10 @@ sal_Bool CCIDecompressor::DecompressScanline( sal_uInt8 * pTarget, sal_uLong nTa
         }
     }
 
-    if ( nEOLCount >= 5 )   // RTC( Return To Controller )
+    if ( nEOLCount >= 5 )   // RTC (Return To Controller)
         return sal_True;
 
-    // ggf. eine weisse vorherige Zeile herstellen fuer 2D:
+    // should the situation arise, generate a white previous line for 2D:
     if ( nOptions & CCI_OPTION_2D )
     {
         if ( pLastLine == NULL || nLastLineSize != ( ( nTargetBits + 7 ) >> 3 ) )
@@ -692,7 +689,7 @@ sal_Bool CCIDecompressor::DecompressScanline( sal_uInt8 * pTarget, sal_uLong nTa
     if ( nOptions & CCI_OPTION_BYTEALIGNROW )
         nInputBitsBufSize &= 0xfff8;
 
-    // Ist es eine 2D-Zeile ?:
+    // is it a 2D row?
     if ( nOptions & CCI_OPTION_2D )
     {
         if ( nOptions & CCI_OPTION_EOL )
@@ -703,13 +700,13 @@ sal_Bool CCIDecompressor::DecompressScanline( sal_uInt8 * pTarget, sal_uLong nTa
     else
         b2D = sal_False;
 
-    // Zeile einlesen:
+    // read scanline:
     if ( b2D )
         Read2DScanlineData( pTarget, (sal_uInt16)nTargetBits );
     else
         Read1DScanlineData( pTarget, (sal_uInt16)nTargetBits );
 
-    // Wenn wir im 2D-Modus sind, muessen wir uns die Zeile merken:
+    // if we're in 2D mode we have to remember the line:
     if ( nOptions & CCI_OPTION_2D && bStatus == sal_True )
     {
         pSrc = pTarget;
@@ -775,7 +772,7 @@ sal_Bool CCIDecompressor::ReadEOL( sal_uInt32 /*nMaxFillBits*/ )
     // oder es gibt tatsaechlich gemeine Export-Filter, die immer ein Align machen.
     // Ausserdem wurden Dateien gefunden, in denen mehr als die maximal 7 noetigen
     // Fuellbits vor dem EOL-Code stehen. Daher akzeptieren wir nun grundsaetzlich
-    // bis zu 32-Bloedsinn-Bits vor dem EOL-Code:
+    // bis zu 32-nonsense-Bits vor dem EOL-Code:
     // und ich habe eine Datei gefunden in der bis zu ??? Bloedsinn Bits stehen, zudem ist dort die Bit Reihenfolge verdreht (SJ);
 
     sal_uInt32 nMaxPos = pIStream->Tell();
@@ -814,7 +811,7 @@ sal_Bool CCIDecompressor::Read2DTag()
 {
     sal_uInt8 nByte;
 
-    // Ein Bit einlesen und sal_True liefern, wenn es 0 ist, sonst sal_False
+    // read abit and return sal_True if it's 0, otherwise return sal_False
     if (nInputBitsBufSize==0) {
         *pIStream >> nByte;
         if ( nOptions & CCI_OPTION_INVERSEBITORDER )
@@ -832,7 +829,7 @@ sal_uInt8 CCIDecompressor::ReadBlackOrWhite()
 {
     sal_uInt8 nByte;
 
-    // Ein Bit einlesen und 0x00 liefern, wenn es 0 ist, sonst 0xff
+    // read a bit and deliver 0x00 if it's 0, otherwise 0xff
     if (nInputBitsBufSize==0) {
         *pIStream >> nByte;
         if ( nOptions & CCI_OPTION_INVERSEBITORDER )
@@ -849,7 +846,7 @@ sal_uInt8 CCIDecompressor::ReadBlackOrWhite()
 sal_uInt16 CCIDecompressor::ReadCodeAndDecode(const CCILookUpTableEntry * pLookUp,
                                           sal_uInt16 nMaxCodeBits)
 {
-    // Einen Huffman-Code einlesen und dekodieren:
+    // read a Huffman code and decode it:
     while (nInputBitsBufSize<nMaxCodeBits)
     {
         sal_uInt8 nByte(0);
@@ -899,9 +896,9 @@ sal_uInt16 CCIDecompressor::CountBits(const sal_uInt8 * pData, sal_uInt16 nDataS
     sal_uInt16 nPos,nLo;
     sal_uInt8 nData;
 
-    // Hier wird die Anzahl der zusammenhaengenden Bits gezaehlt, die
-    // ab Position nBitPos in pTarget alle die Farbe nBlackOrWhite
-    // (0xff oder 0x00) haben.
+    // here the number of bits belonging together is being counted
+    // which all have the color nBlackOrWhite (0xff oder 0x00)
+    // from the position nBitPos on
 
     nPos=nBitPos;
     for (;;) {
@@ -926,16 +923,16 @@ void CCIDecompressor::Read1DScanlineData(sal_uInt8 * pTarget, sal_uInt16 nTarget
 {
     sal_uInt16 nCode,nCodeBits,nDataBits,nTgtFreeByteBits;
     sal_uInt8 nByte;
-    sal_uInt8 nBlackOrWhite; // ist 0xff fuer Black oder 0x00 fuer White
+    sal_uInt8 nBlackOrWhite; // is 0xff for black or 0x00 for white
     sal_Bool bTerminatingCode;
 
-    // Der erste Code ist immer eine "White-Code":
+    // the first code is always a "white-code":
     nBlackOrWhite=0x00;
 
-    // Anzahl der Bits, die im Byte *pTarget noch nicht geschrieben sind:
+    // number of bits that aren't written in the byte *pTarget yet:
     nTgtFreeByteBits=8;
 
-    // Schleife ueber Codes aus dem Eingabe-Stream:
+    // loop through codes from the input stream:
     do {
 
         // die naechsten 13 Bits nach nCode holen, aber noch nicht
@@ -949,7 +946,7 @@ void CCIDecompressor::Read1DScanlineData(sal_uInt8 * pTarget, sal_uInt16 nTarget
         }
         nCode=(sal_uInt16)((nInputBitsBuf>>(nInputBitsBufSize-13))&0x1fff);
 
-        // Anzahl der DatenBits und Anzahl der CodeBits ermitteln:
+        // determine the number of DataBits CodeBits:
         if (nBlackOrWhite) {
             nCodeBits=pBlackLookUp[nCode].nCodeBits;
             nDataBits=pBlackLookUp[nCode].nValue;
@@ -958,7 +955,7 @@ void CCIDecompressor::Read1DScanlineData(sal_uInt8 * pTarget, sal_uInt16 nTarget
             nCodeBits=pWhiteLookUp[nCode].nCodeBits;
             nDataBits=pWhiteLookUp[nCode].nValue;
         }
-        // Ist es ein Ungueltiger Code ?
+        // is that an invalid code?
         if ( nDataBits == 9999 )
         {
             return;
@@ -968,20 +965,20 @@ void CCIDecompressor::Read1DScanlineData(sal_uInt8 * pTarget, sal_uInt16 nTarget
             return;             // das koennen sich jetzt um FuellBits handeln
         }
         nEOLCount = 0;
-        // Zuviele Daten ?
+        // too much data?
         if (nDataBits>nTargetBits) {
             // Ja, koennte ein Folge-Fehler durch ungueltigen Code sein,
             // daher irdenwie weitermachen:
             nDataBits=nTargetBits;
         }
 
-        // Ist es ein 'Terminating-Code' ?
+        // is that a 'Terminating-Code'?
         if (nDataBits<64) bTerminatingCode=sal_True; else bTerminatingCode=sal_False;
 
-        // Die gelesenen Bits aus dem Eingabe-Buffer entfernen:
+        // remove the read bits from the input buffer:
         nInputBitsBufSize = nInputBitsBufSize - nCodeBits;
 
-        // Die Anzahl Daten-Bits in die Scanline schreiben:
+        // write the number of data bits into the scanline:
         if (nDataBits>0) {
             nTargetBits = nTargetBits - nDataBits;
             if (nBlackOrWhite==0x00) *pTarget &= 0xff << nTgtFreeByteBits;
@@ -1008,7 +1005,7 @@ void CCIDecompressor::Read1DScanlineData(sal_uInt8 * pTarget, sal_uInt16 nTarget
             }
         }
 
-        // ggf. Umschaltung Black <-> White:
+        // should the situation arise, switch Black <-> White:
         if (bTerminatingCode==sal_True) nBlackOrWhite=~nBlackOrWhite;
 
     } while (nTargetBits>0 || bTerminatingCode==sal_False);
@@ -1095,7 +1092,7 @@ void CCIDecompressor::Read2DScanlineData(sal_uInt8 * pTarget, sal_uInt16 nTarget
             nBitPos = nBitPos + nRun2;
         }
 
-        else { // Es ist einer der Modi CCI2DMODE_VERT_...
+        else { // it's one of the modes CCI2DMODE_VERT_...
             if (nBitPos==0 && nBlackOrWhite==0x00 && CountBits(pLastLine,nTargetBits,0,0xff)!=0) nRun=0;
             else {
                 nRun=CountBits(pLastLine,nTargetBits,nBitPos,~nBlackOrWhite);
diff --git a/filter/source/graphicfilter/itiff/itiff.cxx b/filter/source/graphicfilter/itiff/itiff.cxx
index bcfc757493d3..76b1156fc404 100644
--- a/filter/source/graphicfilter/itiff/itiff.cxx
+++ b/filter/source/graphicfilter/itiff/itiff.cxx
@@ -53,60 +53,60 @@ class TIFFReader
 
 private:
 
-    sal_Bool                bStatus;                    // Ob bisher kein Fehler auftrat
+    sal_Bool                bStatus;                    // Whether until now no error occurred
     Animation           aAnimation;
     sal_uLong               nLastPercent;
 
-    SvStream*           pTIFF;                      // Die einzulesende TIFF-Datei
+    SvStream*           pTIFF;                      // the TIFF file that should be read
     Bitmap              aBitmap;
     BitmapWriteAccess*  pAcc;
     sal_uInt16              nDstBitsPerPixel;
     AlphaMask*          pAlphaMask;
     BitmapWriteAccess*  pMaskAcc;
 
-    sal_uLong               nOrigPos;                   // Anfaengliche Position in pTIFF
-    sal_uInt16              nOrigNumberFormat;          // Anfaengliches Nummern-Format von pTIFF
+    sal_uLong               nOrigPos;                   // start position in pTIFF
+    sal_uInt16              nOrigNumberFormat;          // number format of pTIFF at the beginning
 
 
     sal_uInt16              nDataType;
     // Daten, die aus dem TIFF-Tags entnommen werden:
-    sal_Bool                bByteSwap;                  // sal_True wenn bits 0..7 -> 7..0 invertiert werden sollen ( FILLORDER = 2 );
-    sal_uInt8               nByte1;                     // 'I', wenn Format LittleEndian
+    sal_Bool                bByteSwap;                  // sal_True if bits 0..7 -> 7..0 should get converted ( FILLORDER = 2 );
+    sal_uInt8               nByte1;                     // 'I', if the format is LittleEndian
 
     sal_uLong               nNewSubFile;                //
     sal_uLong               nSubFile;                   //
-    sal_uLong               nImageWidth;                // Bildbreite in Pixel
-    sal_uLong               nImageLength;               // Bildhoehe in Pixel
-    sal_uLong               nBitsPerSample;             // Bits pro Pixel pro Ebene
-    sal_uLong               nCompression;               // Art der Kompriemierung
+    sal_uLong               nImageWidth;                // picture width in pixels
+    sal_uLong               nImageLength;               // picture heigth in pixels
+    sal_uLong               nBitsPerSample;             // bits per pixel per layer
+    sal_uLong               nCompression;               // kind of compression
     sal_uLong               nPhotometricInterpretation; //
     sal_uLong               nThresholding;              //
     sal_uLong               nCellWidth;                 //
     sal_uLong               nCellLength;                //
     sal_uLong               nFillOrder;                 //
     sal_uLong*              pStripOffsets;              // Feld von Offsets zu den Bitmap-Daten-"Strips"
-    sal_uLong               nNumStripOffsets;           // Groesse obigen Feldes
+    sal_uLong               nNumStripOffsets;           // size of the field above
     sal_uLong               nOrientation;               //
-    sal_uLong               nSamplesPerPixel;           // Anzahl der Ebenen
-    sal_uLong               nRowsPerStrip;              // Wenn nicht komprimiert: Zahl der Zeilen pro Strip
-    sal_uLong*              pStripByteCounts;           // Wenn komprimiert (bestimmte Art): Groesse der Strips
-    sal_uLong               nNumStripByteCounts;        // Anzahl der Eintraege in obiges Feld
+    sal_uLong               nSamplesPerPixel;           // number of layers
+    sal_uLong               nRowsPerStrip;              // if it's not compressed: number of rows per Strip
+    sal_uLong*              pStripByteCounts;           // if compressed (in a certain way): size of the strips
+    sal_uLong               nNumStripByteCounts;        // number of entries in the field above
     sal_uLong               nMinSampleValue;            //
     sal_uLong               nMaxSampleValue;            //
-    double              fXResolution;               // X-Aufloesung oder 0.0
-    double              fYResolution;               // Y-Aufloesung oder 0.0
+    double              fXResolution;                  // X-resolution or 0.0
+    double              fYResolution;                  // Y-resolution or 0.0
     sal_uLong               nPlanarConfiguration;       //
     sal_uLong               nGroup3Options;             //
     sal_uLong               nGroup4Options;             //
-    sal_uLong               nResolutionUnit;            // Einheit von fX/YResolution: 1=unbekannt, 2(default)=Zoll, 3=cm
+    sal_uLong               nResolutionUnit;            // unit of fX/YResolution: 1=unknown, 2(default)=inch, 3=cm
     sal_uLong               nPredictor;                 //
-    sal_uLong*              pColorMap;                  // Farb-Palette
-    sal_uLong               nNumColors;                 // Anzahl Farben in der Farbpalette
+    sal_uLong*              pColorMap;                  // color palette
+    sal_uLong               nNumColors;                 // number of colors within the color palette
 
-    sal_uLong               nPlanes;                    // Anzahl der Ebenen in der Tiff-Datei
-    sal_uLong               nStripsPerPlane;            // Anzahl der Strips pro Ebene
+    sal_uLong               nPlanes;                    // number of layers within the Tiff file
+    sal_uLong               nStripsPerPlane;            // number of Strips per layer
     sal_uLong               nBytesPerRow;               // Bytes pro Zeile pro Ebene in der Tiff-Datei ( unkomprimiert )
-    sal_uInt8*              pMap[ 4 ];                  // Temporaere Scanline
+    sal_uInt8*              pMap[ 4 ];                  // temporary Scanline
 
 
     void    MayCallback( sal_uLong nPercent );
@@ -128,7 +128,7 @@ private:
         // Erzeugt die Bitmap aus der temporaeren Bitmap pMap
         // und loescht dabei pMap teilweise
     sal_Bool    ConvertScanline( sal_uLong nY );
-        // Konvertiert eine Scanline in das Windows-BMP-Format
+        // converts a Scanline to the Windows-BMP format
 
     bool HasAlphaChannel() const;
 public:
@@ -147,7 +147,7 @@ public:
     sal_Bool ReadTIFF( SvStream & rTIFF, Graphic & rGraphic );
 };
 
-//=================== Methoden von TIFFReader ==============================
+//=================== Methods of TIFFReader ==============================
 
 void TIFFReader::MayCallback( sal_uLong /*nPercent*/ )
 {
@@ -746,7 +746,7 @@ sal_Bool TIFFReader::ConvertScanline( sal_uLong nY )
         {
             sal_uInt8*  pt = pMap[ 0 ];
 
-            // sind die Werte als Differenz abgelegt?
+            // are the values being saved as difference?
             if ( 2 == nPredictor )
             {
                 sal_uInt8  nLRed = 0;
@@ -838,7 +838,7 @@ sal_Bool TIFFReader::ConvertScanline( sal_uLong nY )
 
                 for( nx = 0; nx < nImageWidth; nx++ )
                 {
-                    // sind die Werte als Differenz abgelegt?
+                    // are the values being saved as difference?
                     if( 2 == nPredictor )
                     {
                         for( ns = 0; ns < 4; ns++ )
@@ -1140,10 +1140,10 @@ sal_Bool TIFFReader::ReadTIFF(SvStream & rTIFF, Graphic & rGraphic )
 
     MayCallback( 0 );
 
-    // Kopf einlesen:
+    // read header:
     ReadHeader();
 
-    // Ersten IFD einlesen:
+    // read first IFD:
     *pTIFF >> nFirstIfd;
 
     if( !nFirstIfd || pTIFF->GetError() )
@@ -1167,7 +1167,7 @@ sal_Bool TIFFReader::ReadTIFF(SvStream & rTIFF, Graphic & rGraphic )
 
             *pTIFF >> nNumTags;
 
-            // Schleife ueber Tags:
+            // loop through tags:
             for( i = 0; i < nNumTags; i++ )
             {
                 *pTIFF >> nTagType >> nDataType >> nDataLen >> nOffset;
@@ -1195,26 +1195,26 @@ sal_Bool TIFFReader::ReadTIFF(SvStream & rTIFF, Graphic & rGraphic )
                 nSubFile = 0;
                 nImageWidth = 0;
                 nImageLength = 0;
-                nBitsPerSample = 1;                         // Defaultwert laut Doku
+                nBitsPerSample = 1;                         // default value according to the documentation
                 nCompression = 1;
                 nPhotometricInterpretation = 0;
-                nThresholding = 1;                          // Defaultwert laut Doku
+                nThresholding = 1;                          // default value according to the documentation
                 nCellWidth = 1;
                 nCellLength = 1;
-                nFillOrder = 1;                             // Defaultwert laut Doku
+                nFillOrder = 1;                             // default value according to the documentation
                 nNumStripOffsets = 0;
                 nOrientation = 1;
-                nSamplesPerPixel = 1;                       // Defaultwert laut Doku
-                nRowsPerStrip = 0xffffffff;                 // Defaultwert laut Doku
+                nSamplesPerPixel = 1;                       // default value according to the documentation
+                nRowsPerStrip = 0xffffffff;                 // default value according to the documentation
                 nNumStripByteCounts = 0;
-                nMinSampleValue = 0;                        // Defaultwert laut Doku
+                nMinSampleValue = 0;                        // default value according to the documentation
                 nMaxSampleValue = 0;
                 fXResolution = 0.0;
                 fYResolution = 0.0;
                 nPlanarConfiguration = 1;
-                nGroup3Options = 0;                         // Defaultwert laut Doku
-                nGroup4Options = 0;                         // Defaultwert laut Doku
-                nResolutionUnit = 2;                        // Defaultwert laut Doku
+                nGroup3Options = 0;                         // default value according to the documentation
+                nGroup4Options = 0;                         // default value according to the documentation
+                nResolutionUnit = 2;                        // default value according to the documentation
                 nPredictor = 1;
                 nNumColors = 0;
 
@@ -1280,7 +1280,7 @@ sal_Bool TIFFReader::ReadTIFF(SvStream & rTIFF, Graphic & rGraphic )
                     else
                         nPlanes = nSamplesPerPixel;
 
-                    if ( ( nFillOrder == 2 ) && ( nCompression != 5 ) )     // im LZW Mode werden die bits schon invertiert
+                    if ( ( nFillOrder == 2 ) && ( nCompression != 5 ) )     // in the LZW mode bits are already being inverted
                         bByteSwap = sal_True;
 
                     nStripsPerPlane = ( nImageLength - 1 ) / nRowsPerStrip + 1;
@@ -1371,7 +1371,7 @@ sal_Bool TIFFReader::ReadTIFF(SvStream & rTIFF, Graphic & rGraphic )
 }
 
 
-//================== GraphicImport - die exportierte Funktion ================
+//================== GraphicImport - the exported Function ================
 
 extern "C" SAL_DLLPUBLIC_EXPORT sal_Bool __LOADONCALLAPI
 GraphicImport(SvStream & rStream, Graphic & rGraphic, FilterConfigItem*, sal_Bool)
diff --git a/filter/source/msfilter/escherex.cxx b/filter/source/msfilter/escherex.cxx
index 9c76138d3fd4..fd2ef5288f6b 100644
--- a/filter/source/msfilter/escherex.cxx
+++ b/filter/source/msfilter/escherex.cxx
@@ -213,7 +213,7 @@ void EscherPropertyContainer::AddOpt( sal_uInt16 nPropID, sal_Bool bBlib, sal_uI
     sal_uInt32 i;
     for( i = 0; i < nSortCount; i++ )
     {
-        if ( ( pSortStruct[ i ].nPropId &~0xc000 ) == ( nPropID &~0xc000 ) )    // pruefen, ob Property nur ersetzt wird
+        if ( ( pSortStruct[ i ].nPropId &~0xc000 ) == ( nPropID &~0xc000 ) )    // check, whether the Property only gets replaced
         {
             pSortStruct[ i ].nPropId = nPropID;
             if ( pSortStruct[ i ].pBuf )
@@ -231,7 +231,7 @@ void EscherPropertyContainer::AddOpt( sal_uInt16 nPropID, sal_Bool bBlib, sal_uI
     }
     nCountCount++;
     nCountSize += 6;
-    if ( nSortCount == nSortBufSize )                                           // buffer vergroessern
+    if ( nSortCount == nSortBufSize )                                           // increase buffer
     {
         nSortBufSize <<= 1;
         EscherPropSortStruct* pTemp = new EscherPropSortStruct[ nSortBufSize ];
@@ -242,7 +242,7 @@ void EscherPropertyContainer::AddOpt( sal_uInt16 nPropID, sal_Bool bBlib, sal_uI
         delete pSortStruct;
         pSortStruct = pTemp;
     }
-    pSortStruct[ nSortCount ].nPropId = nPropID;                                // property einfuegen
+    pSortStruct[ nSortCount ].nPropId = nPropID;                                // insert property
     pSortStruct[ nSortCount ].pBuf = pProp;
     pSortStruct[ nSortCount ].nPropSize = nPropSize;
     pSortStruct[ nSortCount++ ].nPropValue = nPropValue;
@@ -343,9 +343,9 @@ sal_uInt32 EscherPropertyContainer::ImplGetColor( const sal_uInt32 nSOColor, sal
 {
     if ( bSwap )
     {
-        sal_uInt32 nColor = nSOColor & 0xff00;      // GRUEN
-        nColor |= (sal_uInt8)( nSOColor ) << 16;    // ROT
-        nColor |= (sal_uInt8)( nSOColor >> 16 );    // BLAU
+        sal_uInt32 nColor = nSOColor & 0xff00;      // green
+        nColor |= (sal_uInt8)( nSOColor ) << 16;    // red
+        nColor |= (sal_uInt8)( nSOColor >> 16 );    // blue
         return nColor;
     }
     else
@@ -873,7 +873,7 @@ void EscherPropertyContainer::CreateLineProperties(
                         {
                             case ::com::sun::star::drawing::DashStyle_ROUND :
                             case ::com::sun::star::drawing::DashStyle_ROUNDRELATIVE :
-                                AddOpt( ESCHER_Prop_lineEndCapStyle, 0 ); // Style Round setzen
+                                AddOpt( ESCHER_Prop_lineEndCapStyle, 0 ); // set Style Round
                             break;
                             default : break;
                         }
@@ -1743,7 +1743,7 @@ sal_Bool EscherPropertyContainer::CreatePolygonProperties(
             {
                 aPolygon = aPolyPolygon[ j ];
                 nPoints = aPolygon.GetSize();
-                for ( i = 0; i < nPoints; i++ )             // Punkte aus Polygon in Buffer schreiben
+                for ( i = 0; i < nPoints; i++ )             // write points from polygon to buffer
                 {
                     Point aPoint = aPolygon[ i ];
                     aPoint.X() -= rGeoRect.X;
@@ -1770,7 +1770,7 @@ sal_Bool EscherPropertyContainer::CreatePolygonProperties(
                 *pPtr++ = 0x40;
                 aPolygon = aPolyPolygon[ j ];
                 nPoints = aPolygon.GetSize();
-                for ( i = 0; i < nPoints; i++ )         // Polyflags in Buffer schreiben
+                for ( i = 0; i < nPoints; i++ )         // write Polyflags to Buffer
                 {
                     *pPtr++ = 0;
                     if ( bBezier )
@@ -2962,7 +2962,7 @@ void EscherPropertyContainer::CreateCustomShapeProperties( const MSO_SPT eShapeT
                             if ( xText.is() )
                                 aText = xText->getString();
                             if ( aText.isEmpty() )
-                                aText = ::rtl::OUString( "your text" );   // todo: moving into a resource
+                                aText = ::rtl::OUString( "your text" );   // TODO: moving into a resource
                             AddOpt( DFF_Prop_gtextUNICODE, aText );
 
                             // FontWork Font
@@ -3503,7 +3503,7 @@ void EscherBlibEntry::WriteBlibEntry( SvStream& rSt, sal_Bool bWritePictureOffse
     switch ( meBlibType )
     {
         case EMF :
-        case WMF :  // EMF/WMF auf OS2 zu Pict Konvertieren
+        case WMF :  // converting EMF/WMF on OS2 to Pict
             rSt << (sal_uInt8)PICT;
         break;
         default:
@@ -3854,8 +3854,8 @@ sal_uInt32 EscherGraphicProvider::GetBlibID( SvStream& rPicOutStrm, const rtl::O
                         nHeight = aPrefSize.Height() * 360;
                     }
                     rPicOutStrm << nUncompressedSize // WMFSize without FileHeader
-                    << (sal_Int32)0     // da die Originalgroesse des WMF's (ohne FileHeader)
-                    << (sal_Int32)0     // nicht mehr feststellbar ist, schreiben wir 10cm / x
+                    << (sal_Int32)0     // since we can't find out anymore what the original size of
+                    << (sal_Int32)0     // the WMF (without Fileheader) was we write 10cm / x
                     << nPrefWidth
                     << nPrefHeight
                     << nWidth
@@ -3919,7 +3919,7 @@ sal_uInt32 EscherConnectorListEntry::GetClosestPoint( const Polygon& rPoly, cons
 };
 
 // ---------------------------------------------------------------------------------------------
-// bei Rechtecken           bei Ellipsen    bei Polygonen
+// for rectangles          for ellipses     for polygons
 //
 // nRule =  0 ->Top         0 ->Top         nRule = Index auf ein (Poly)Polygon Punkt
 //          1 ->Left        2 ->Left
@@ -4147,7 +4147,7 @@ sal_uInt32 EscherConnectorListEntry::GetConnectorRule( sal_Bool bFirst )
             nRule = GetClosestPoint( aPoly, aRefPoint );
 
             if (aType.equalsL(RTL_CONSTASCII_STRINGPARAM("drawing.Ellipse")))
-                nRule <<= 1;    // In PPT hat eine Ellipse 8 M?glichkeiten sich zu connecten
+                nRule <<= 1;    // In PPT an ellipse has 8 ways to connect
         }
     }
     return nRule;
@@ -4459,7 +4459,7 @@ void EscherEx::InsertAtCurrentPos( sal_uInt32 nBytes, bool bExpandEndOfAtom )
         }
     }
 
-    // container und atom sizes anpassen
+    // adapt container and atom sizes
     mpOutStrm->Seek( mnStrmStartOfs );
     while ( mpOutStrm->Tell() < nCurPos )
     {
@@ -4489,7 +4489,7 @@ void EscherEx::InsertAtCurrentPos( sal_uInt32 nBytes, bool bExpandEndOfAtom )
     }
     mpOutStrm->Seek( STREAM_SEEK_TO_END );
     nSource = mpOutStrm->Tell();
-    nToCopy = nSource - nCurPos;                        // Stream um nBytes vergroessern
+    nToCopy = nSource - nCurPos;                        // increase the size of the tream by nBytes
     pBuf = new sal_uInt8[ 0x40000 ];                            // 256KB Buffer
     while ( nToCopy )
     {
@@ -4718,7 +4718,7 @@ sal_uInt32 EscherEx::EnterGroup( const String& rShapeName, const Rectangle* pBou
     AddAtom( 16, ESCHER_Spgr, 1 );
     PtReplaceOrInsert( ESCHER_Persist_Grouping_Snap | mnGroupLevel,
                         mpOutStrm->Tell() );
-    *mpOutStrm  << (sal_Int32)aRect.Left()  // Bounding box fuer die Gruppierten shapes an die sie attached werden
+    *mpOutStrm  << (sal_Int32)aRect.Left()  // Bounding box for the grouped shapes the wich they will be attached
                 << (sal_Int32)aRect.Top()
                 << (sal_Int32)aRect.Right()
                 << (sal_Int32)aRect.Bottom();
@@ -4768,7 +4768,7 @@ sal_Bool EscherEx::SetGroupSnapRect( sal_uInt32 nGroupLevel, const Rectangle& rR
         sal_uInt32 nCurrentPos = mpOutStrm->Tell();
         if ( DoSeek( ESCHER_Persist_Grouping_Snap | ( nGroupLevel - 1 ) ) )
         {
-            *mpOutStrm  << (sal_Int32)rRect.Left()  // Bounding box fuer die Gruppierten shapes an die sie attached werden
+            *mpOutStrm  << (sal_Int32)rRect.Left()  // Bounding box for the grouped shapes the wich they will be attached
                         << (sal_Int32)rRect.Top()
                         << (sal_Int32)rRect.Right()
                         << (sal_Int32)rRect.Bottom();
@@ -4825,9 +4825,9 @@ sal_uInt32 EscherEx::GetColor( const sal_uInt32 nSOColor, sal_Bool bSwap )
 {
     if ( bSwap )
     {
-        sal_uInt32 nColor = nSOColor & 0xff00;      // GRUEN
-        nColor |= (sal_uInt8)( nSOColor ) << 16;        // ROT
-        nColor |= (sal_uInt8)( nSOColor >> 16 );        // BLAU
+        sal_uInt32 nColor = nSOColor & 0xff00;          // Green
+        nColor |= (sal_uInt8)( nSOColor ) << 16;        // Red
+        nColor |= (sal_uInt8)( nSOColor >> 16 );        // Blue
         return nColor;
     }
     else
diff --git a/filter/source/msfilter/eschesdo.cxx b/filter/source/msfilter/eschesdo.cxx
index 32d5680442b2..123bb36e7f8c 100644
--- a/filter/source/msfilter/eschesdo.cxx
+++ b/filter/source/msfilter/eschesdo.cxx
@@ -438,7 +438,7 @@ sal_uInt32 ImplEESdrWriter::ImplWriteShape( ImplEESdrObject& rObj,
             //i27942: Poly/Lines/Bezier do not support text.
 
             mpEscherEx->OpenContainer( ESCHER_SpContainer );
-            sal_uInt32 nFlags = 0xa00;          // Flags: Connector | HasSpt
+            sal_uInt32 nFlags = 0xa00;      // Flags: Connector | HasSpt
             if( aNewRect.Height < 0 )
                 nFlags |= 0x80;             // Flags: VertMirror
             if( aNewRect.Width < 0 )
@@ -507,7 +507,7 @@ sal_uInt32 ImplEESdrWriter::ImplWriteShape( ImplEESdrObject& rObj,
         {
             mpEscherEx->OpenContainer( ESCHER_SpContainer );
 
-            // ein GraphicObject kann auch ein ClickMe Element sein
+            // a GraphicObject can also be a ClickMe element
             if( rObj.IsEmptyPresObj() && ( ePageType == NORMAL ) )
             {
                 ADD_SHAPE( ESCHER_ShpInst_Rectangle, 0x220 );               // Flags: HaveAnchor | HaveMaster
@@ -1114,7 +1114,7 @@ const SdrObject* ImplEESdrObject::GetSdrObject() const
     return EscherEx::GetSdrObject( mXShape );
 }
 
-//  laedt und konvertiert text aus shape, ergebnis ist mnTextSize gespeichert
+//  loads and  converts text from shape, result is being saved in mnTextSize respeichert
 sal_uInt32 ImplEESdrObject::ImplGetText()
 {
     Reference< XText > xXText( mXShape, UNO_QUERY );
diff --git a/filter/source/msfilter/msdffimp.cxx b/filter/source/msfilter/msdffimp.cxx
index c3c413919c4d..4f7ebcbd789c 100644
--- a/filter/source/msfilter/msdffimp.cxx
+++ b/filter/source/msfilter/msdffimp.cxx
@@ -46,7 +46,7 @@
 #include <vcl/cvtgrf.hxx>
 #include "viscache.hxx"
 
-// SvxItem-Mapping. Wird benoetigt um die SvxItem-Header erfolgreich zu includen
+// SvxItem-Mapping. Is needed to successfully include the SvxItem-Header
 #include <editeng/eeitem.hxx>
 #include <editeng/editdata.hxx>
 #include <svl/urihelper.hxx>
@@ -113,7 +113,7 @@
 #include "svx/svditer.hxx"
 #include <svx/xpoly.hxx>
 #include "svx/xattr.hxx"
-#include <filter/msfilter/msdffimp.hxx> // extern sichtbare Header-Datei
+#include <filter/msfilter/msdffimp.hxx> // externally visible header file
 #include <editeng/outliner.hxx>
 #include <editeng/outlobj.hxx>
 #include <editeng/editobj.hxx>
@@ -162,11 +162,11 @@ static sal_uInt32 nMSOleObjCntr = 0;
 void Impl_OlePres::Write( SvStream & rStm )
 {
     WriteClipboardFormat( rStm, FORMAT_GDIMETAFILE );
-    rStm << (sal_Int32)(nJobLen +4);       // immer leeres TargetDevice
+    rStm << (sal_Int32)(nJobLen +4);       // a TargetDevice that's always empty
     if( nJobLen )
         rStm.Write( pJob, nJobLen );
     rStm << (sal_uInt32)nAspect;
-    rStm << (sal_Int32)-1;      //L-Index immer -1
+    rStm << (sal_Int32)-1;      //L-Index always -1
     rStm << (sal_Int32)nAdvFlags;
     rStm << (sal_Int32)0;       //Compression
     rStm << (sal_Int32)aSize.Width();
@@ -225,7 +225,7 @@ SvStream& operator>>( SvStream& rIn, DffRecordHeader& rRec )
     return rIn;
 }
 
-// Masse fuer dashed lines
+// measurements  dashed lines
 #define LLEN_MIDDLE         (450)
 #define LLEN_SPACE_MIDDLE   (360)
 #define LLEN_LONG           (LLEN_MIDDLE * 2)
@@ -241,7 +241,7 @@ SvStream& operator>>( SvStream& rIn, DffPropSet& rRec )
     rIn >> aHd;
     sal_uInt32 nPropCount = aHd.nRecInstance;
 
-    // FilePos der ComplexData merken
+    // remember FilePos of the ComplexData
     sal_uInt32 nComplexDataFilePos = rIn.Tell() + ( nPropCount * 6 );
 
     for( sal_uInt32 nPropNum = 0; nPropNum < nPropCount; nPropNum++ )
@@ -275,7 +275,7 @@ SvStream& operator>>( SvStream& rIn, DffPropSet& rRec )
                 // normally nContent is the complete size of the complex property,
                 // but this is not always true for IMsoArrays ( what the hell is a IMsoArray ? )
 
-                // I love special threatments :-(
+                // I love special treatments :-(
                 if ( ( nRecType == DFF_Prop_pVertices ) || ( nRecType == DFF_Prop_pSegmentInfo )
                     || ( nRecType == DFF_Prop_fillShadeColors ) || ( nRecType == DFF_Prop_lineDashStyle )
                         || ( nRecType == DFF_Prop_pWrapPolygonVertices ) || ( nRecType == DFF_Prop_connectorPoints )
@@ -1636,7 +1636,7 @@ void DffPropertyReader::ApplyFillAttributes( SvStream& rIn, SfxItemSet& rSet, co
         {
             sal_Int32 nAngle = 3600 - ( ( Fix16ToAngle( GetPropertyValue( DFF_Prop_fillAngle, 0 ) ) + 5 ) / 10 );
 
-            // Rotationswinkel in Bereich zwingen
+            // force rotation angle to be within a certain range
             while ( nAngle >= 3600 )
                 nAngle -= 3600;
             while ( nAngle < 0 )
@@ -1646,14 +1646,14 @@ void DffPropertyReader::ApplyFillAttributes( SvStream& rIn, SfxItemSet& rSet, co
             XGradientStyle eGrad = XGRAD_LINEAR;
             sal_Int32 nChgColors = 0;
 
-            if ( nFocus < 0 )       // Bei negativem Focus sind die Farben zu tauschen
+            if ( nFocus < 0 )       // If the focus is negative the colors need to be swapped
             {
                 nFocus = -nFocus;
                 nChgColors ^= 1;
             }
             if( nFocus > 40 && nFocus < 60 )
             {
-                eGrad = XGRAD_AXIAL;    // Besser gehts leider nicht
+                eGrad = XGRAD_AXIAL;    // Unfortunately there's no better solution
             }
 
             sal_uInt16 nFocusX = (sal_uInt16)nFocus;
@@ -1794,7 +1794,7 @@ void DffPropertyReader::ApplyCustomShapeTextAttributes( SfxItemSet& rSet ) const
         eTVA = SDRTEXTVERTADJUST_BLOCK;
         eTHA = SDRTEXTHORZADJUST_CENTER;
 
-        // Textverankerung lesen
+        // read text anchor
         MSO_Anchor eTextAnchor = (MSO_Anchor)GetPropertyValue( DFF_Prop_anchorText, mso_anchorTop );
 
         switch( eTextAnchor )
@@ -1839,7 +1839,7 @@ void DffPropertyReader::ApplyCustomShapeTextAttributes( SfxItemSet& rSet ) const
         eTVA = SDRTEXTVERTADJUST_CENTER;
         eTHA = SDRTEXTHORZADJUST_BLOCK;
 
-        // Textverankerung lesen
+        // read text anchor
         MSO_Anchor eTextAnchor = (MSO_Anchor)GetPropertyValue( DFF_Prop_anchorText, mso_anchorTop );
 
         switch( eTextAnchor )
@@ -1946,7 +1946,7 @@ void DffPropertyReader::ApplyCustomShapeGeometryAttributes( SvStream& rIn, SfxIt
         sal_Int32 nTextRotateAngle = 0;
         MSO_TextFlow eTextFlow = (MSO_TextFlow)( GetPropertyValue( DFF_Prop_txflTextFlow ) & 0xFFFF );
 
-        if ( eTextFlow == mso_txflBtoT )    // Bottom to Top non-@, unten -> oben
+        if ( eTextFlow == mso_txflBtoT )    // Bottom to Top non-@
             nTextRotateAngle += 90;
         switch( GetPropertyValue( DFF_Prop_cdirFont, mso_cdir0 ) )  // SJ: mso_cdir90 and mso_cdir270 will be simulated by
         {                                                           // activating vertical writing for the text objects
@@ -2943,9 +2943,8 @@ void DffPropertyReader::ApplyAttributes( SvStream& rIn, SfxItemSet& rSet, const
                     //   mso_shadowDouble
                     //   mso_shadowRich
                     //   mso_shadowEmbossOrEngrave
-                    // koennen wir nicht, kreiere Default-Schatten mit default-
-                    // Abstand
-                    rSet.Put( SdrShadowXDistItem( 35 ) ); // 0,35 mm Schattendistanz
+                    // not possible in LibreOffice, create default shadow with default distance
+                    rSet.Put( SdrShadowXDistItem( 35 ) ); // 0,35 mm shadow distance
                     rSet.Put( SdrShadowYDistItem( 35 ) );
                 }
             }
@@ -3231,7 +3230,7 @@ DffRecordHeader* DffRecordManager::GetRecordHeader( sal_uInt16 nRecId, DffSeekTo
 }
 
 //---------------------------------------------------------------------------
-//  private Methoden
+//  private methods
 //---------------------------------------------------------------------------
 
 bool CompareSvxMSDffShapeInfoById::operator() (
@@ -3285,7 +3284,7 @@ sal_uInt32 SvxMSDffManager::ScalePt( sal_uInt32 nVal ) const
     Fraction aFact( GetMapFactor( MAP_POINT, eMap ).X() );
     long aMul = aFact.GetNumerator();
     long aDiv = aFact.GetDenominator() * 65536;
-    aFact = Fraction( aMul, aDiv ); // nochmal versuchen zu kuerzen
+    aFact = Fraction( aMul, aDiv ); // try again to shorten it
     return BigMulDiv( nVal, aFact.GetNumerator(), aFact.GetDenominator() );
 }
 
@@ -3300,30 +3299,30 @@ void SvxMSDffManager::SetModel(SdrModel* pModel, long nApplicationScale)
     if( pModel && (0 < nApplicationScale) )
     {
         // PPT arbeitet nur mit Einheiten zu 576DPI
-        // WW hingegen verwendet twips, dh. 1440DPI.
+        // WW hingegen verwendet twips, i.e. 1440DPI.
         MapUnit eMap = pSdrModel->GetScaleUnit();
         Fraction aFact( GetMapFactor(MAP_INCH, eMap).X() );
         long nMul=aFact.GetNumerator();
         long nDiv=aFact.GetDenominator()*nApplicationScale;
-        aFact=Fraction(nMul,nDiv); // nochmal versuchen zu kuerzen
-        // Bei 100TH_MM -> 2540/576=635/144
-        // Bei Twip     -> 1440/576=5/2
+        aFact=Fraction(nMul,nDiv); // try again to shorten it
+        // For 100TH_MM -> 2540/576=635/144
+        // For Twip     -> 1440/576=5/2
         nMapMul  = aFact.GetNumerator();
         nMapDiv  = aFact.GetDenominator();
         bNeedMap = nMapMul!=nMapDiv;
 
-        // MS-DFF-Properties sind grossteils in EMU (English Metric Units) angegeben
+        // MS-DFF-Properties are mostly given in EMU (English Metric Units)
         // 1mm=36000emu, 1twip=635emu
         aFact=GetMapFactor(MAP_100TH_MM,eMap).X();
         nMul=aFact.GetNumerator();
         nDiv=aFact.GetDenominator()*360;
-        aFact=Fraction(nMul,nDiv); // nochmal versuchen zu kuerzen
-        // Bei 100TH_MM ->                            1/360
-        // Bei Twip     -> 14,40/(25,4*360)=144/91440=1/635
+        aFact=Fraction(nMul,nDiv); // try again to shorten it
+        // For 100TH_MM ->                            1/360
+        // For Twip     -> 14,40/(25,4*360)=144/91440=1/635
         nEmuMul=aFact.GetNumerator();
         nEmuDiv=aFact.GetDenominator();
 
-        // Und noch was fuer typografische Points
+        // And something for typographic Points
         aFact=GetMapFactor(MAP_POINT,eMap).X();
         nPntMul=aFact.GetNumerator();
         nPntDiv=aFact.GetDenominator();
@@ -3417,7 +3416,7 @@ bool SvxMSDffManager::SeekToRec( SvStream& rSt, sal_uInt16 nRecId, sal_uLong nMa
     }
     while ( rSt.good() && rSt.Tell() < nMaxFilePos && !bRet );
     if ( !bRet )
-        rSt.Seek( nFPosMerk );  // FilePos restaurieren
+        rSt.Seek( nFPosMerk );  // restore FilePos
     return bRet;
 }
 
@@ -3447,7 +3446,7 @@ bool SvxMSDffManager::SeekToRec2( sal_uInt16 nRecId1, sal_uInt16 nRecId2, sal_uL
     }
     while ( rStCtrl.GetError() == 0 && rStCtrl.Tell() < nMaxFilePos && !bRet );
     if ( !bRet )
-        rStCtrl.Seek( nFPosMerk ); // FilePos restaurieren
+        rStCtrl.Seek( nFPosMerk ); // restore FilePos
     return bRet;
 }
 
@@ -3469,7 +3468,7 @@ bool SvxMSDffManager::GetColorFromPalette( sal_uInt16 /* nNum */, Color& rColor
 // fill and line color
 Color SvxMSDffManager::MSO_TEXT_CLR_ToColor( sal_uInt32 nColorCode ) const
 {
-    // Fuer Textfarben: Header ist 0xfeRRGGBB
+    // for text colors: Header is 0xfeRRGGBB
     if ( ( nColorCode & 0xfe000000 ) == 0xfe000000 )
         nColorCode &= 0x00ffffff;
     else
@@ -3488,7 +3487,7 @@ Color SvxMSDffManager::MSO_CLR_ToColor( sal_uInt32 nColorCode, sal_uInt16 nConte
 {
     Color aColor( mnDefaultColor );
 
-    // Fuer Textfarben: Header ist 0xfeRRGGBB
+    // for text colors: Header is 0xfeRRGGBB
     if ( ( nColorCode & 0xfe000000 ) == 0xfe000000 )    // sj: it needs to be checked if 0xfe is used in
         nColorCode &= 0x00ffffff;                       // other cases than ppt text -> if not this code can be removed
 
@@ -3671,7 +3670,7 @@ Color SvxMSDffManager::MSO_CLR_ToColor( sal_uInt32 nColorCode, sal_uInt16 nConte
                     aColor = Color( (sal_uInt8)nR, (sal_uInt8)nG, (sal_uInt8)nB );
                 }
                 break;
-                case 0x05 :     // substract from grey level RGB(p,p,p)
+                case 0x05 :     // substract from gray level RGB(p,p,p)
                 {
                     sal_Int16 nR = (sal_Int16)nParameter - (sal_Int16)aColor.GetRed();
                     sal_Int16 nG = (sal_Int16)nParameter - (sal_Int16)aColor.GetGreen();
@@ -3817,8 +3816,8 @@ bool SvxMSDffManager::ReadObjText(SvStream& rSt, SdrObject* pObj)
             SdrOutliner& rOutliner=pText->ImpGetDrawOutliner();
             sal_uInt16 nOutlMode = rOutliner.GetMode();
 
-            { // Wohl 'nen kleiner Bug der EditEngine, das die
-              // Absastzattribute bei Clear() nicht entfernt werden.
+            {   // apparently a small bug in the EditEngine which causes
+                // the paragraph attributes not to be delted on Clear()
                 bool bClearParaAttribs = true;
                 rOutliner.SetStyleSheet( 0, NULL );
                 SfxItemSet aSet(rOutliner.GetEmptyItemSet());
@@ -3829,16 +3828,16 @@ bool SvxMSDffManager::ReadObjText(SvStream& rSt, SdrObject* pObj)
                 bClearParaAttribs = sal_False;
                 if( bClearParaAttribs )
                 {
-                    // Wohl 'nen kleiner Bug der EditEngine, dass die
-                    // Absastzattribute bei Clear() nicht entfernt werden.
+                    // apparently a small bug in the EditEngine which causes
+                    // the paragraph attributes not to be delted on Clear()
                     rOutliner.SetParaAttribs(0,rOutliner.GetEmptyItemSet());
                 }
             }
             rOutliner.Init( OUTLINERMODE_TEXTOBJECT );
 
-            ////////////////////////////////////
-            // TextString und MetaChars lesen //
-            ////////////////////////////////////
+            ///////////////////////////////////
+            // read TextString and MetaChars //
+            ///////////////////////////////////
             do
             {
                 if( !ReadCommonRecordHeader(aHd, rSt) )
@@ -3939,7 +3938,7 @@ bool SvxMSDffManager::ReadObjText(SvStream& rSt, SdrObject* pObj)
             while ( rSt.GetError() == 0 && rSt.Tell() < nRecEnd );
 
             ////////////////////////
-            // SHIFT-Ret ersetzen //
+            // replace SHIFT-Ret  //
             ////////////////////////
             if ( aText.Len() )
             {
@@ -3947,7 +3946,7 @@ bool SvxMSDffManager::ReadObjText(SvStream& rSt, SdrObject* pObj)
                 aText.SetChar( aText.Len()-1, 0x0D );
                 rOutliner.SetText( aText, rOutliner.GetParagraph( 0 ) );
 
-                // SHIFT-Ret ersetzen im Outliner
+                // replace SHIFT-Ret in the Outliner
                 if (comphelper::string::getTokenCount(aText, 0x0B) > 1)
                 {
                     sal_uInt32 nParaCount = rOutliner.GetParagraphCount();
@@ -4078,15 +4077,15 @@ SdrObject* SvxMSDffManager::ImportGraphic( SvStream& rSt, SfxItemSet& rSet, cons
     sal_uInt32 nBlipId = GetPropertyValue( DFF_Prop_pib, 0 );
     sal_Bool bGrfRead = sal_False,
 
-    // Grafik verlinkt
+    // Graphic linked
     bLinkGrf = 0 != ( eFlags & mso_blipflagLinkToFile );
     {
         Graphic aGraf;  // be sure this graphic is deleted before swapping out
         if( SeekToContent( DFF_Prop_pibName, rSt ) )
             aFileName = MSDFFReadZString( rSt, GetPropertyValue( DFF_Prop_pibName ), sal_True );
 
-        //   UND, ODER folgendes:
-        if( !( eFlags & mso_blipflagDoNotSave ) ) // Grafik embedded
+        //   AND, OR the following:
+        if( !( eFlags & mso_blipflagDoNotSave ) ) // Graphic embedded
         {
             bGrfRead = GetBLIP( nBlipId, aGraf, &aVisArea );
             if ( !bGrfRead )
@@ -4242,7 +4241,7 @@ SdrObject* SvxMSDffManager::ImportGraphic( SvStream& rSt, SfxItemSet& rSet, cons
             }
         }
 
-        // sollte es ein OLE-Object sein?
+        // should it be an OLE object?
         if( bGrfRead && !bLinkGrf && IsProperty( DFF_Prop_pictureId ) )
         {
             // TODO/LATER: in future probably the correct aspect should be provided here
@@ -4282,7 +4281,7 @@ SdrObject* SvxMSDffManager::ImportGraphic( SvStream& rSt, SfxItemSet& rSet, cons
             pRet->SetBLIPSizeRectangle( aVisArea );
 
         if (pRet->GetName().isEmpty())                   // SJ 22.02.00 : PPT OLE IMPORT:
-        {                                               // name is already set in ImportOLE !!
+        {                                                // name is already set in ImportOLE !!
             // JP 01.12.99: SetName before SetModel - because in the other order the Bug 70098 is active
             if ( ( eFlags & mso_blipflagType ) != mso_blipflagComment )
             {
@@ -4294,7 +4293,7 @@ SdrObject* SvxMSDffManager::ImportGraphic( SvStream& rSt, SfxItemSet& rSet, cons
                 pRet->SetName( aFileName );
         }
     }
-    pRet->SetModel( pSdrModel ); // fuer GraphicLink erforderlich
+    pRet->SetModel( pSdrModel ); // required for GraphicLink
     pRet->SetLogicRect( rObjData.aBoundRect );
 
     if ( pRet->ISA( SdrGrafObj ) )
@@ -4329,7 +4328,7 @@ SdrObject* SvxMSDffManager::ImportObj( SvStream& rSt, void* pClientData,
     {
         pRet = ImportShape( aObjHd, rSt, pClientData, rClientRect, rGlobalChildRect, nCalledByGroup, pShapeId );
     }
-    aObjHd.SeekToBegOfRecord( rSt );    // FilePos restaurieren
+    aObjHd.SeekToBegOfRecord( rSt );    // restore FilePos
     return pRet;
 }
 
@@ -4527,7 +4526,7 @@ SdrObject* SvxMSDffManager::ImportShape( const DffRecordHeader& rHd, SvStream& r
 
     Rectangle aTextRect;
     if ( !aObjData.aBoundRect.IsEmpty() )
-    {   // Rotation auf BoundingBox anwenden, BEVOR ien Objekt generiert wurde
+    {   // apply rotation to the BoundingBox BEFORE an object has been generated
         if( mnFix16Angle )
         {
             long nAngle = mnFix16Angle;
@@ -4894,7 +4893,7 @@ SdrObject* SvxMSDffManager::ImportShape( const DffRecordHeader& rHd, SvStream& r
                             double a = nObjectRotation * nPi180;
                             pRet->NbcRotate( aObjData.aBoundRect.Center(), nObjectRotation, sin( a ), cos( a ) );
                         }
-                        // Horizontal gespiegelt?
+                        // mirrored horizontally?
                         if ( nSpFlags & SP_FFLIPH )
                         {
                             Rectangle aBndRect( pRet->GetSnapRect() );
@@ -4902,7 +4901,7 @@ SdrObject* SvxMSDffManager::ImportShape( const DffRecordHeader& rHd, SvStream& r
                             Point aBottom( aTop.X(), aTop.Y() + 1000 );
                             pRet->NbcMirror( aTop, aBottom );
                         }
-                        // Vertikal gespiegelt?
+                        // mirrored vertically?
                         if ( nSpFlags & SP_FFLIPV )
                         {
                             Rectangle aBndRect( pRet->GetSnapRect() );
@@ -4918,7 +4917,7 @@ SdrObject* SvxMSDffManager::ImportShape( const DffRecordHeader& rHd, SvStream& r
                         pRet->SetLogicRect( aObjData.aBoundRect );
                         pRet->SetMergedItemSet(aSet);
 
-                        // Konnektoren
+                        // connectors
                         MSO_ConnectorStyle eConnectorStyle = (MSO_ConnectorStyle)GetPropertyValue( DFF_Prop_cxstyle, mso_cxstyleStraight );
 
                         ((SdrEdgeObj*)pRet)->ConnectToNode(sal_True, NULL);
@@ -4927,7 +4926,7 @@ SdrObject* SvxMSDffManager::ImportShape( const DffRecordHeader& rHd, SvStream& r
                         Point aPoint1( aObjData.aBoundRect.TopLeft() );
                         Point aPoint2( aObjData.aBoundRect.BottomRight() );
 
-                        // Rotationen beachten
+                        // pay attention to the rotations
                         if ( nObjectRotation )
                         {
                             double a = nObjectRotation * nPi180;
@@ -4939,7 +4938,7 @@ SdrObject* SvxMSDffManager::ImportShape( const DffRecordHeader& rHd, SvStream& r
                             RotatePoint(aPoint2, aCenter, ss, cc);
                         }
 
-                        // Linie innerhalb des Bereiches zurechtdrehen/spiegeln
+                        // rotate/mirror line within the area as we need it
                         if ( nSpFlags & SP_FFLIPH )
                         {
                             sal_Int32 n = aPoint1.X();
@@ -4954,8 +4953,8 @@ SdrObject* SvxMSDffManager::ImportShape( const DffRecordHeader& rHd, SvStream& r
                         }
                         nSpFlags &= ~( SP_FFLIPV | SP_FFLIPH );
 
-                        pRet->NbcSetPoint(aPoint1, 0L); // Startpunkt
-                        pRet->NbcSetPoint(aPoint2, 1L); // Endpunkt
+                        pRet->NbcSetPoint(aPoint1, 0L); // start point
+                        pRet->NbcSetPoint(aPoint2, 1L); // endpoint
 
                         sal_Int32 n1HorzDist, n1VertDist, n2HorzDist, n2VertDist;
                         n1HorzDist = n1VertDist = n2HorzDist = n2VertDist = 0;
@@ -4992,7 +4991,7 @@ SdrObject* SvxMSDffManager::ImportShape( const DffRecordHeader& rHd, SvStream& r
                     double a = nObjectRotation * nPi180;
                     pRet->NbcRotate( aObjData.aBoundRect.Center(), nObjectRotation, sin( a ), cos( a ) );
                 }
-                // Horizontal gespiegelt?
+                // mirrored horizontally?
                 if ( nSpFlags & SP_FFLIPH )
                 {
                     Rectangle aBndRect( pRet->GetSnapRect() );
@@ -5000,7 +4999,7 @@ SdrObject* SvxMSDffManager::ImportShape( const DffRecordHeader& rHd, SvStream& r
                     Point aBottom( aTop.X(), aTop.Y() + 1000 );
                     pRet->NbcMirror( aTop, aBottom );
                 }
-                // Vertikal gespiegelt?
+                // mirrored vertically?
                 if ( nSpFlags & SP_FFLIPV )
                 {
                     Rectangle aBndRect( pRet->GetSnapRect() );
@@ -5066,7 +5065,7 @@ Rectangle SvxMSDffManager::GetGlobalChildAnchor( const DffRecordHeader& rHd, SvS
                         else
                         {
                             sal_Int16 ls, ts, rs, bs;
-                            rSt >> ts >> ls >> rs >> bs; // etwas seltsame Koordinatenreihenfolge ...
+                            rSt >> ts >> ls >> rs >> bs; // the order of coordinates is a bit strange...
                             l = ls, t = ts, r = rs, b = bs;
                         }
                         Scale( l );
@@ -5251,7 +5250,7 @@ SdrObject* SvxMSDffManager::ProcessObj(SvStream& rSt,
             }
         }
 
-        //  Textrahmen, auch Title oder Outline
+        //  text frame, also Title or Outline
         SdrObject*  pOrgObj  = pObj;
         SdrRectObj* pTextObj = 0;
         sal_uInt32 nTextId = GetPropertyValue( DFF_Prop_lTxid, 0 );
@@ -5372,14 +5371,14 @@ SdrObject* SvxMSDffManager::ProcessObj(SvStream& rSt,
             pTextObj = new SdrRectObj(OBJ_TEXT, rTextRect);
             pTextImpRec = new SvxMSDffImportRec(*pImpRec);
 
-            // Die vertikalen Absatzeinrueckungen sind im BoundRect mit drin,
-            // hier rausrechnen
+            // the vertical paragraph indents are part of the BoundRect,
+            // here we 'remove' them by calculating
             Rectangle aNewRect(rTextRect);
             aNewRect.Bottom() -= nTextTop + nTextBottom;
             aNewRect.Right() -= nTextLeft + nTextRight;
 
-            // Nur falls es eine einfache Textbox ist, darf der Writer
-            // das Objekt durch einen Rahmen ersetzen, ansonsten
+            // Only if it's a simple textbox may Writer replace
+            // the object with a frame, otherwise
             if( bTextFrame )
             {
                 ::boost::shared_ptr<SvxMSDffShapeInfo> const pTmpRec(
@@ -5431,7 +5430,7 @@ SdrObject* SvxMSDffManager::ProcessObj(SvStream& rSt,
                 default: break;
             }
 
-            // Abstaende an den Raendern der Textbox setzen
+            // set margins at the border of the textbox
             aSet.Put( SdrTextLeftDistItem( nTextLeft ) );
             aSet.Put( SdrTextRightDistItem( nTextRight ) );
             aSet.Put( SdrTextUpperDistItem( nTextTop ) );
@@ -5441,7 +5440,7 @@ SdrObject* SvxMSDffManager::ProcessObj(SvStream& rSt,
             pTextImpRec->nDxTextRight   = nTextRight;
             pTextImpRec->nDyTextBottom  = nTextBottom;
 
-            // Textverankerung lesen
+            // read text anchor
             if ( IsProperty( DFF_Prop_anchorText ) )
             {
                 MSO_Anchor eTextAnchor =
@@ -5492,7 +5491,7 @@ SdrObject* SvxMSDffManager::ProcessObj(SvStream& rSt,
                     break;
                     default : break;
                 }
-                // Einsetzen
+                // insert
                 if ( bTVASet )
                     aSet.Put( SdrTextVertAdjustItem( eTVA ) );
                 if ( bTHASet )
@@ -5517,7 +5516,7 @@ SdrObject* SvxMSDffManager::ProcessObj(SvStream& rSt,
                 pTextObj->NbcRotate(aPivot, nTextRotationAngle, sin(a), cos(a));
             }
 
-            // rotate text with shape ?
+            // rotate text with shape?
             if ( mnFix16Angle )
             {
                 double a = mnFix16Angle * nPi180;
@@ -5659,7 +5658,7 @@ SdrObject* SvxMSDffManager::ProcessObj(SvStream& rSt,
                 rImportData.aRecords.insert( pTextImpRec );
             }
 
-            // Eintrag in Z-Order-Liste um Zeiger auf dieses Objekt ergaenzen
+            // entry in the z-order-list in order to complement the pointer to this object
             /*Only store objects which are not deep inside the tree*/
             if( ( rObjData.nCalledByGroup == 0 )
                 ||
@@ -5760,8 +5759,8 @@ SvxMSDffManager::SvxMSDffManager(SvStream& rStCtrl_,
      nOffsDgg( nOffsDgg_ ),
      nBLIPCount(  USHRT_MAX ),              // initialize with error, since we fist check if the
      nShapeCount( USHRT_MAX ),              // control stream has correct data
-     nGroupShapeFlags(0),                   //ensure initialization here, as some corrupted
-                                            //files may yield to this being unitialized
+     nGroupShapeFlags(0),                   // ensure initialization here, as some corrupted
+                                            // files may yield to this being unitialized
      maBaseURL( rBaseURL ),
      rStCtrl(  rStCtrl_  ),
      pStData(  pStData_  ),
@@ -5773,24 +5772,24 @@ SvxMSDffManager::SvxMSDffManager(SvStream& rStCtrl_,
 {
     SetModel( pSdrModel_, nApplicationScale );
 
-    // FilePos des/der Stream(s) merken
+    // remember FilePos of the stream(s)
     sal_uLong nOldPosCtrl = rStCtrl.Tell();
     sal_uLong nOldPosData = pStData ? pStData->Tell() : nOldPosCtrl;
 
-    // Falls kein Datenstream angegeben, gehen wir davon aus,
-    // dass die BLIPs im Steuerstream stehen.
+    // if no data stream is given we assume that the BLIPs
+    // are in the control stream
     if( !pStData )
         pStData = &rStCtrl;
 
     SetDefaultPropSet( rStCtrl, nOffsDgg );
 
-    // Steuer Stream auslesen, im Erfolgsfall nBLIPCount setzen
+    // read control stream, if successful set nBLIPCount
     GetCtrlData( nOffsDgg );
 
-    // Text-Box-Story-Ketten-Infos ueberpruefen
+    // check Text-Box-Story-Chain-Infos
     CheckTxBxStoryChain();
 
-    // alte FilePos des/der Stream(s) restaurieren
+    // restore old FilePos of the stream(s)
     rStCtrl.Seek( nOldPosCtrl );
     if( &rStCtrl != pStData )
         pStData->Seek( nOldPosData );
@@ -5804,8 +5803,8 @@ SvxMSDffManager::SvxMSDffManager( SvStream& rStCtrl_, const String& rBaseURL )
      pShapeOrders( new SvxMSDffShapeOrders ),
      nDefaultFontHeight( 24 ),
      nOffsDgg( 0 ),
-     nBLIPCount(  USHRT_MAX ),              // mit Error initialisieren, da wir erst pruefen,
-     nShapeCount( USHRT_MAX ),              // ob Kontroll-Stream korrekte Daten enthaellt
+     nBLIPCount(  USHRT_MAX ),              // initialize with error, since we first have to check
+     nShapeCount( USHRT_MAX ),              // whether the control stream contains the correct data
      maBaseURL( rBaseURL ),
      rStCtrl(  rStCtrl_  ),
      pStData( 0 ),
@@ -5831,7 +5830,7 @@ void SvxMSDffManager::InitSvxMSDffManager( sal_uInt32 nOffsDgg_, SvStream* pStDa
     pStData = pStData_;
     nSvxMSDffOLEConvFlags = nOleConvFlags;
 
-    // FilePos des/der Stream(s) merken
+    // remember FilePos of the stream(s)
     sal_uLong nOldPosCtrl = rStCtrl.Tell();
 
     SetDefaultPropSet( rStCtrl, nOffsDgg );
@@ -5839,13 +5838,13 @@ void SvxMSDffManager::InitSvxMSDffManager( sal_uInt32 nOffsDgg_, SvStream* pStDa
     // insert fidcl cluster table
     GetFidclData( nOffsDgg );
 
-    // Steuer Stream auslesen, im Erfolgsfall nBLIPCount setzen
+    // read control stream, if successful, set nBLIPCount
     GetCtrlData( nOffsDgg );
 
-    // Text-Box-Story-Ketten-Infos ueberpruefen
+    // check Text-Box-Story-Chain-Infos
     CheckTxBxStoryChain();
 
-    // alte FilePos des/der Stream(s) restaurieren
+    // restore old FilePos of the stream(s)
     rStCtrl.Seek( nOldPosCtrl );
 }
 
@@ -5977,19 +5976,19 @@ void SvxMSDffManager::CheckTxBxStoryChain()
 
 /*****************************************************************************
 
-    Einlesen der Shape-Infos im Ctor:
+    Reading the Shape-Infos in the Ctor:
     ---------------------------------
-    merken der Shape-Ids und zugehoerigen Blip-Nummern und TextBox-Infos
-               =========                  ============     =============
-    und merken des File-Offsets fuer jedes Blip
-                   ============
+    remembering the Shape-Ids and the associated Blip-Numbers und TextBox-Infos
+                    =========                    ============     =============
+    and remebering the File-Offsets for each Blip
+                       ============
 ******************************************************************************/
 void SvxMSDffManager::GetCtrlData( sal_uInt32 nOffsDgg_ )
 {
-    // Start Offset unbedingt merken, falls wir nochmal aufsetzen muessen
+    // absolutely remember Start Offset, in case we have to position again
     sal_uInt32 nOffsDggL = nOffsDgg_;
 
-    // Kontroll Stream positionieren
+    // position control stream
     if (nOffsDggL != rStCtrl.Seek(nOffsDggL))
         return;
 
@@ -6002,7 +6001,7 @@ void SvxMSDffManager::GetCtrlData( sal_uInt32 nOffsDgg_ )
     sal_Bool bOk;
     sal_uLong nPos = nOffsDggL + DFF_COMMON_RECORD_HEADER_SIZE;
 
-    // Fall A: erst Drawing Group Container, dann n Mal Drawing Container
+    // case A: first Drawing Group Container, then n times Drawing Container
     if( DFF_msofbtDggContainer == nFbt )
     {
         GetDrawingGroupContainerData( rStCtrl, nLength );
@@ -6039,7 +6038,7 @@ void SvxMSDffManager::GetCtrlData( sal_uInt32 nOffsDgg_ )
 }
 
 
-// ab hier: Drawing Group Container  d.h. Dokument - weit gueltige Daten
+// from here on: Drawing Group Container  i.e. Ddocument-wide valid data
 //                      =======================           ========
 //
 void SvxMSDffManager::GetDrawingGroupContainerData( SvStream& rSt, sal_uLong nLenDgg )
@@ -6051,7 +6050,7 @@ void SvxMSDffManager::GetDrawingGroupContainerData( SvStream& rSt, sal_uLong nLe
 
     sal_uLong nLenBStoreCont = 0, nLenFBSE = 0, nRead = 0;
 
-    // Nach einem BStore Container suchen
+    // search for a  BStore Container
     do
     {
         if(!this->ReadCommonRecordHeader( rSt, nVer, nInst, nFbt, nLength)) return;
@@ -6083,7 +6082,7 @@ void SvxMSDffManager::GetDrawingGroupContainerData( SvStream& rSt, sal_uLong nLe
         if( DFF_msofbtBSE == nFbt )
         {
             nLenFBSE = nLength;
-            // ist FBSE gross genug fuer unsere Daten
+            // is FBSE big enough for our data
             sal_Bool bOk = ( nSkipBLIPLen + 4 + nSkipBLIPPos + 4 <= nLenFBSE );
 
             if( bOk )
@@ -6105,7 +6104,7 @@ void SvxMSDffManager::GetDrawingGroupContainerData( SvStream& rSt, sal_uLong nLe
                 if( (!nBLIPPos) && (nBLIPLen < nLenFBSE) )
                     nBLIPPos = rSt.Tell() + 4;
 
-                // Das hat ja fein geklappt!
+                // That worked great!
                 // Wir merken uns, dass wir einen FBSE mehr im Pointer Array haben.
                 nBLIPPos = Calc_nBLIPPos(nBLIPPos, rSt.Tell());
 
@@ -6114,7 +6113,7 @@ void SvxMSDffManager::GetDrawingGroupContainerData( SvStream& rSt, sal_uLong nLe
                 else
                     nBLIPCount++;
 
-                // Jetzt die Infos fuer spaetere Zugriffe speichern
+                // now save the info for later access
                 pBLIPInfos->push_back( new SvxMSDffBLIPInfo( nInst, nBLIPPos, nBLIPLen ) );
             }
         }
@@ -6176,7 +6175,7 @@ sal_Bool SvxMSDffManager::GetShapeGroupContainerData( SvStream& rSt,
         if( !this->ReadCommonRecordHeader( rSt, nVer, nInst, nFbt, nLength ) )
             return sal_False;
         nReadSpGrCont += DFF_COMMON_RECORD_HEADER_SIZE;
-        // Shape Container ?
+        // Shape Container?
         if( DFF_msofbtSpContainer == nFbt )
         {
             sal_uLong nGroupOffs = bFirst ? nStartShapeGroupCont - DFF_COMMON_RECORD_HEADER_SIZE : ULONG_MAX;
@@ -6226,10 +6225,10 @@ sal_Bool SvxMSDffManager::GetShapeContainerData( SvStream& rSt,
     //  und der Text nicht gedreht ist)
     sal_Bool bCanBeReplaced = (ULONG_MAX > nPosGroup) ? sal_False : sal_True;
 
-    // wir wissen noch nicht, ob es eine TextBox ist
+    // we don't knwo yet whether it's a TextBox
     MSO_SPT         eShapeType      = mso_sptNil;
 
-    // Shape analysieren
+    // analyze Shape
     //
     do
     {
@@ -6238,7 +6237,7 @@ sal_Bool SvxMSDffManager::GetShapeContainerData( SvStream& rSt,
         // FSP ?
         if( ( DFF_msofbtSp == nFbt ) && ( 4 <= nLength ) )
         {
-            // Wir haben den FSP gefunden: Shape Typ und Id vermerken!
+            // we've found the FSP gefunden: note Shape Type and Id!
             eShapeType = (MSO_SPT)nInst;
             rSt >> aInfo.nShapeId;
             rSt.SeekRel( nLength - 4 );
@@ -6246,8 +6245,8 @@ sal_Bool SvxMSDffManager::GetShapeContainerData( SvStream& rSt,
         }
         else if( DFF_msofbtOPT == nFbt ) // Shape Property Table ?
         {
-            // Wir haben die Property Table gefunden:
-            // nach der Blip Property suchen!
+            // We've found the Property Table:
+            // search for the Blip Property!
             sal_uLong  nPropRead = 0;
             sal_uInt16 nPropId;
             sal_uInt32  nPropVal;
@@ -6310,20 +6309,20 @@ sal_Bool SvxMSDffManager::GetShapeContainerData( SvStream& rSt,
                     break;
 
                     case DFF_Prop_WrapText :
-                        //TO-DO: eWrapMode = (MSO_WrapMode)nPropVal;
+                        //TODO: eWrapMode = (MSO_WrapMode)nPropVal;
                     break;
 
                     default:
                     {
-                        // Bit gesetzt und gueltig?
+                        // is the Bit set and valid?
                         if( 0x4000 == ( nPropId & 0xC000 ) )
                         {
-                            // Blip Property gefunden: BStore Idx vermerken!
+                            // Blip Property found: remember BStore Idx!
                             nPropRead = nLenShapePropTbl;
                         }
                         else if( 0x8000 & nPropId )
                         {
-                            // komplexe Prop gefunden:
+                            // complex Prop found:
                             // Laenge ist immer 6, nur die Laenge der nach der
                             // eigentlichen Prop-Table anhaengenden Extra-Daten
                             // ist unterschiedlich
@@ -6337,7 +6336,7 @@ sal_Bool SvxMSDffManager::GetShapeContainerData( SvStream& rSt,
             rSt.Seek( nStartShapePropTbl + nLenShapePropTbl );
             nReadSpCont += nLenShapePropTbl;
         }
-        else if( ( DFF_msofbtClientTextbox == nFbt ) && ( 4 == nLength ) )  // Text-Box-Story-Eintrag gefunden
+        else if( ( DFF_msofbtClientTextbox == nFbt ) && ( 4 == nLength ) )  // Text-Box-Story-Entry found
         {
             rSt >> aInfo.nTxBxComp;
             // Add internal drawing container id to text id.
@@ -6379,7 +6378,7 @@ sal_Bool SvxMSDffManager::GetShapeContainerData( SvStream& rSt,
         pShapeOrders->push_back( new SvxMSDffShapeOrder( aInfo.nShapeId ) );
     }
 
-    // und den Stream wieder korrekt positionieren
+    // and position the Stream correctly again
     rSt.Seek( nStartShapeCont + nLenShapeCont );
     return sal_True;
 }
@@ -6388,8 +6387,8 @@ sal_Bool SvxMSDffManager::GetShapeContainerData( SvStream& rSt,
 
 /*****************************************************************************
 
-    Zugriff auf ein Shape zur Laufzeit (ueber die Shape-Id)
-    ----------------------------------
+    Access to a shape at runtime (via the Shape-Id)
+    ----------------------------
 ******************************************************************************/
 sal_Bool SvxMSDffManager::GetShape(sal_uLong nId, SdrObject*&         rpShape,
                                           SvxMSDffImportData& rData)
@@ -6411,13 +6410,13 @@ sal_Bool SvxMSDffManager::GetShape(sal_uLong nId, SdrObject*&         rpShape,
         sal_uLong const nFilePos((*it)->nFilePos);
         bool bSeeked = (nFilePos == rStCtrl.Seek(nFilePos));
 
-        // Falls missglueckt, den Fehlerstatus zuruecksetzen und Pech gehabt!
+        // if it failed, reset error statusF
         if (!bSeeked || rStCtrl.GetError())
             rStCtrl.ResetError();
         else
             rpShape = ImportObj( rStCtrl, &rData, rData.aParentRect, rData.aParentRect );
 
-        // alte FilePos des/der Stream(s) restaurieren
+        // restore old alte FilePos of the stream(s)
         rStCtrl.Seek( nOldPosCtrl );
         if( &rStCtrl != pStData )
             pStData->Seek( nOldPosData );
@@ -6428,12 +6427,12 @@ sal_Bool SvxMSDffManager::GetShape(sal_uLong nId, SdrObject*&         rpShape,
 
 
 
-/*      Zugriff auf ein BLIP zur Laufzeit (bei bereits bekannter Blip-Nr)
-    ---------------------------------
+/*      access to a BLIP at runtime (if the Blip-Number is already known)
+        ---------------------------
 ******************************************************************************/
 sal_Bool SvxMSDffManager::GetBLIP( sal_uLong nIdx_, Graphic& rData, Rectangle* pVisArea )
 {
-    sal_Bool bOk = sal_False;       // Ergebnisvariable initialisieren
+    sal_Bool bOk = sal_False;       // initialize result variable
     if ( pStData )
     {
         // check if a graphic for this blipId is already imported
@@ -6465,14 +6464,13 @@ sal_Bool SvxMSDffManager::GetBLIP( sal_uLong nIdx_, Graphic& rData, Rectangle* p
                 && pStData->GetError() )
                 pStData->ResetError();
 
-            // FilePos des/der Stream(s) merken
+            // remember FilePos of the stream(s)
             sal_uLong nOldPosCtrl = rStCtrl.Tell();
             sal_uLong nOldPosData = pStData ? pStData->Tell() : nOldPosCtrl;
 
             // passende Info-Struct aus unserem Pointer Array nehmen
             SvxMSDffBLIPInfo& rInfo = (*pBLIPInfos)[ nIdx-1 ];
-
-            // das BLIP Atom im Daten Stream anspringen
+in the data streamim Daten Stream anspringen
             pStData->Seek( rInfo.nFilePos );
             // ggfs. Fehlerstatus zuruecksetzen
             if( pStData->GetError() )
@@ -6493,7 +6491,7 @@ sal_Bool SvxMSDffManager::GetBLIP( sal_uLong nIdx_, Graphic& rData, Rectangle* p
                     pStData2->ResetError();
                 else
                     bOk = GetBLIPDirect( *pStData2, rData, pVisArea );
-                // alte FilePos des zweiten Daten-Stream restaurieren
+                // restore olf FilePos of the second data stream
                 pStData2->Seek( nOldPosData2 );
             }
             // alte FilePos des/der Stream(s) restaurieren
@@ -6512,16 +6510,16 @@ sal_Bool SvxMSDffManager::GetBLIP( sal_uLong nIdx_, Graphic& rData, Rectangle* p
     return bOk;
 }
 
-/*      Zugriff auf ein BLIP zur Laufzeit (mit korrekt positioniertem Stream)
+/*      access to a BLIP at runtime (with correctly positioned stream)
     ---------------------------------
 ******************************************************************************/
 sal_Bool SvxMSDffManager::GetBLIPDirect( SvStream& rBLIPStream, Graphic& rData, Rectangle* pVisArea ) const
 {
     sal_uLong nOldPos = rBLIPStream.Tell();
 
-    int nRes = GRFILTER_OPENERROR;  // Fehlervariable initialisieren
+    int nRes = GRFILTER_OPENERROR;  // initialize error variable
 
-    // nachschauen, ob es sich auch wirklich um ein BLIP handelt
+    // check whether it's really a BLIP
     sal_uInt32 nLength;
     sal_uInt16 nInst, nFbt( 0 );
     sal_uInt8   nVer;
@@ -6530,7 +6528,7 @@ sal_Bool SvxMSDffManager::GetBLIPDirect( SvStream& rBLIPStream, Graphic& rData,
         Size        aMtfSize100;
         sal_Bool        bMtfBLIP = sal_False;
         sal_Bool        bZCodecCompression = sal_False;
-        // Nun exakt auf den Beginn der eingebetteten Grafik positionieren
+        // now position it exactly at the beinning of the embedded graphic
         sal_uLong nSkip = ( nInst & 0x0001 ) ? 32 : 16;
 
         switch( nInst & 0xFFFE )
@@ -6639,7 +6637,7 @@ sal_Bool SvxMSDffManager::GetBLIPDirect( SvStream& rBLIPStream, Graphic& rData,
 #endif
 
         if( ( nInst & 0xFFFE ) == 0x7A8 )
-        {   // DIBs direkt holen
+        {   // getting the DIBs immediately
             Bitmap aNew;
             if( aNew.Read( *pGrStream, sal_False ) )
             {
@@ -6648,7 +6646,7 @@ sal_Bool SvxMSDffManager::GetBLIPDirect( SvStream& rBLIPStream, Graphic& rData,
             }
         }
         else
-        {   // und unsere feinen Filter darauf loslassen
+        {   // and unleash our filter
             GraphicFilter& rGF = GraphicFilter::GetGraphicFilter();
             String aEmptyStr;
             nRes = rGF.ImportGraphic( rData, aEmptyStr, *pGrStream, GRFILTER_FORMAT_DONTKNOW );
@@ -6683,7 +6681,7 @@ sal_Bool SvxMSDffManager::GetBLIPDirect( SvStream& rBLIPStream, Graphic& rData,
           pGrStream->ResetError();
         delete pOut;
     }
-    rBLIPStream.Seek( nOldPos );    // alte FilePos des Streams restaurieren
+    rBLIPStream.Seek( nOldPos );    // restore old FilePos of the strem
 
     return ( GRFILTER_OK == nRes ); // Ergebniss melden
 }
@@ -6983,7 +6981,7 @@ sal_Bool SvxMSDffManager::ConvertToOle2( SvStream& rStm, sal_uInt32 nReadLen,
                 String aShort, aFull;
                 if( pIds->nId )
                 {
-                    // gefunden!
+                    // found!
                     sal_uLong nCbFmt = SotExchange::RegisterFormatName( aSvrName );
                     rDest->SetClass( SvGlobalName( pIds->nId, 0, 0, 0xc0,0,0,0,0,0,0,0x46 ), nCbFmt,
                                     String( pIds->pDspName, RTL_TEXTENCODING_ASCII_US ) );
@@ -7296,9 +7294,9 @@ SdrOle2Obj* SvxMSDffManager::CreateSdrOLEFromStorage(
     if( rSrcStorage.Is() && xDestStorage.is() && rStorageName.Len() )
     {
         comphelper::EmbeddedObjectContainer aCnt( xDestStorage );
-        // Ist der 01Ole-Stream ueberhaupt vorhanden ?
-        // ( ist er z.B. bei FontWork nicht )
-        // Wenn nicht -> Einbindung als Grafik
+        // does the 01Ole-Stream exist at all?
+        // (that's not the case for e.g. Fontwork )
+        // If that's not the case -> include it as graphic
         sal_Bool bValidStorage = sal_False;
         rtl::OUString aDstStgName(MSO_OLE_Obj);
 
diff --git a/filter/source/msfilter/svdfppt.cxx b/filter/source/msfilter/svdfppt.cxx
index a13c361f5975..e483b3e9a845 100644
--- a/filter/source/msfilter/svdfppt.cxx
+++ b/filter/source/msfilter/svdfppt.cxx
@@ -246,7 +246,7 @@ Size PptDocumentAtom::GetPageSize(const Size& rSiz) const
 
 SvStream& operator>>(SvStream& rIn, PptDocumentAtom& rAtom)
 {
-// Tatsaechliches Format:
+// Actual format:
 //  00 aSlidePageSizeXY  8
 //  08 aNotesPageSizeXY  8
 //  16 aZoomRatio (OLE)  8
@@ -267,7 +267,7 @@ SvStream& operator>>(SvStream& rIn, PptDocumentAtom& rAtom)
     rIn >> aHd
         >> nSlideX >> nSlideY
         >> nNoticeX >> nNoticeY
-        >> nDummy >> nDummy             // ZoomRation ueberspringen
+        >> nDummy >> nDummy             // skip ZoomRation
         >> rAtom.nNotesMasterPersist
         >> rAtom.nHandoutMasterPersist
         >> rAtom.n1stPageNumber
@@ -591,8 +591,7 @@ void SdrEscherImport::ProcessClientAnchor2( SvStream& rSt, DffRecordHeader& rHd,
     else
     {
         sal_Int16 ls, ts, rs, bs;
-        rSt >> ts >> ls >> rs >> bs; // etwas seltsame Koordinatenreihenfolge ...
-        l = ls, t = ts, r = rs, b = bs;
+        rSt >> ts >> ls >> rs >> bs; // the order of coordinates is a bit strange...
     }
     Scale( l );
     Scale( t );
@@ -850,7 +849,7 @@ SdrObject* SdrEscherImport::ProcessObj( SvStream& rSt, DffObjData& rObjData, voi
                     eTVA = SDRTEXTVERTADJUST_BLOCK;
                     eTHA = SDRTEXTHORZADJUST_CENTER;
 
-                    // Textverankerung lesen
+                    // read text anchor
                     MSO_Anchor eTextAnchor = (MSO_Anchor)GetPropertyValue( DFF_Prop_anchorText, mso_anchorTop );
 
                     switch( eTextAnchor )
@@ -906,7 +905,7 @@ SdrObject* SdrEscherImport::ProcessObj( SvStream& rSt, DffObjData& rObjData, voi
                     eTVA = SDRTEXTVERTADJUST_CENTER;
                     eTHA = SDRTEXTHORZADJUST_BLOCK;
 
-                    // Textverankerung lesen
+                    // read text anchor
                     MSO_Anchor eTextAnchor = (MSO_Anchor)GetPropertyValue( DFF_Prop_anchorText, mso_anchorTop );
 
                     switch( eTextAnchor )
@@ -1090,7 +1089,7 @@ SdrObject* SdrEscherImport::ProcessObj( SvStream& rSt, DffObjData& rObjData, voi
             if ( !pTObj->ISA( SdrObjCustomShape ) )
                 pTObj->SetMergedItem( SdrTextMinFrameWidthItem( nMinFrameWidth ) );
 
-                // Abstaende an den Raendern der Textbox setzen
+                // set margins at the borders of the textbox
                 pTObj->SetMergedItem( SdrTextLeftDistItem( nTextLeft ) );
                 pTObj->SetMergedItem( SdrTextRightDistItem( nTextRight ) );
                 pTObj->SetMergedItem( SdrTextUpperDistItem( nTextTop ) );
@@ -1137,7 +1136,7 @@ SdrObject* SdrEscherImport::ProcessObj( SvStream& rSt, DffObjData& rObjData, voi
                             }
                         }
                     }
-                    // rotate text with shape ?
+                    // rotate text with shape?
                     sal_Int32 nAngle = ( rObjData.nSpFlags & SP_FFLIPV ) ? -mnFix16Angle : mnFix16Angle;    // #72116# vertical flip -> rotate by using the other way
                     nAngle += nTextRotationAngle;
 
@@ -1200,7 +1199,7 @@ SdrObject* SdrEscherImport::ProcessObj( SvStream& rSt, DffObjData& rObjData, voi
     {
         if ( rObjData.nSpFlags & SP_FBACKGROUND )
         {
-            pRet->NbcSetSnapRect( Rectangle( Point(), ((SdrPage*)rData.pPage)->GetSize() ) );   // Groesse setzen
+            pRet->NbcSetSnapRect( Rectangle( Point(), ((SdrPage*)rData.pPage)->GetSize() ) );   // set size
         }
         if ( rPersistEntry.pSolverContainer )
         {
@@ -1382,7 +1381,7 @@ SdrPowerPointImport::SdrPowerPointImport( PowerPointImportParam& rParam, const S
     if ( rStCtrl.GetError() != 0 )
         bOk = sal_False;
     if ( bOk )
-    {   // Document PersistEntry checken
+    {   // check Document PersistEntry
         nDocStreamPos = aUserEditAtom.nDocumentRef;
         if ( nDocStreamPos > nPersistPtrAnz )
         {
@@ -1391,7 +1390,7 @@ SdrPowerPointImport::SdrPowerPointImport( PowerPointImportParam& rParam, const S
         }
     }
     if ( bOk )
-    {   // Document FilePos checken
+    {   // check Document FilePos
         nDocStreamPos = pPersistPtr[ nDocStreamPos ];
         if ( nDocStreamPos >= nStreamLen )
         {
@@ -1406,7 +1405,7 @@ SdrPowerPointImport::SdrPowerPointImport( PowerPointImportParam& rParam, const S
 
         DffRecordHeader aDocHd;
         rStCtrl >> aDocHd;
-        // DocumentAtom lesen
+        // read DocumentAtom
         DffRecordHeader aDocAtomHd;
         rStCtrl >> aDocAtomHd;
         if ( aDocHd.nRecType == PPT_PST_Document && aDocAtomHd.nRecType == PPT_PST_DocumentAtom )
@@ -1423,7 +1422,7 @@ SdrPowerPointImport::SdrPowerPointImport( PowerPointImportParam& rParam, const S
                 ReadFontCollection();
 
             // reading TxPF, TxSI
-            PPTTextCharacterStyleAtomInterpreter    aTxCFStyle; // SJ: ToDo, this atom needs to be interpreted, it contains character default styles for standard objects (instance4)
+            PPTTextCharacterStyleAtomInterpreter    aTxCFStyle; // SJ: TODO, this atom needs to be interpreted, it contains character default styles for standard objects (instance4)
             PPTTextParagraphStyleAtomInterpreter    aTxPFStyle;
             PPTTextSpecInfoAtomInterpreter          aTxSIStyle; // styles (default language setting ... )
 
@@ -1452,9 +1451,9 @@ SdrPowerPointImport::SdrPowerPointImport( PowerPointImportParam& rParam, const S
                 }
             }
 
-            // todo:: PPT_PST_TxPFStyleAtom
+            // TODO:: PPT_PST_TxPFStyleAtom
 
-            // SlidePersists Lesen
+            // read SlidePersists
             pMasterPages=new PptSlidePersistList;
             pSlidePages =new PptSlidePersistList;
             pNotePages  =new PptSlidePersistList;
@@ -1516,7 +1515,7 @@ SdrPowerPointImport::SdrPowerPointImport( PowerPointImportParam& rParam, const S
                 pMasterPages->insert( pMasterPages->begin() + (( nMasterPage + 1 ) << 1), pE2 );
             }
 
-            // Zu jeder Page noch das SlideAtom bzw. NotesAtom lesen, soweit vorhanden
+            // read for each page the SlideAtom respectively the NotesAtom if it exists
             nPageListNum = 0;
             for ( nPageListNum = 0; nPageListNum < 3; nPageListNum++ )
             {
@@ -1675,7 +1674,7 @@ sal_Bool PPTConvertOCXControls::InsertControl(
                 if ( xShape.is() )
                 {
                     xShape->setSize(rSize);
-                    // Das Control-Model am Control-Shape setzen
+                    // set the Control-Model at the Control-Shape
                     ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XControlShape >  xControlShape( xShape,
                         ::com::sun::star::uno::UNO_QUERY );
                     ::com::sun::star::uno::Reference< ::com::sun::star::awt::XControlModel >  xControlModel( rFComp,
@@ -1883,7 +1882,7 @@ SdrObject* SdrPowerPointImport::ImportOLE( long nOLEId,
                                         if ( pOe->nAspect != embed::Aspects::MSOLE_ICON )
                                         {
                                             //TODO/LATER: keep on hacking?!
-                                            // modifiziert wollen wir nicht werden
+                                            // we don't want to be modified
                                             //xInplaceObj->EnableSetModified( sal_False );
                                             if ( rVisArea.IsEmpty() )
                                             {
@@ -1998,7 +1997,7 @@ void SdrPowerPointImport::SeekOle( SfxObjectShell* pShell, sal_uInt32 nFilterOpt
                                         sal_uInt32 i;
 
                                         sal_Bool bCopied = sal_True;
-                                        for ( i = 0; i < aList.size(); i++ )    // copy all entrys
+                                        for ( i = 0; i < aList.size(); i++ )    // copy all entries
                                         {
                                             const SvStorageInfo& rInfo = aList[ i ];
                                             if ( !xSource->CopyTo( rInfo.GetName(), xMacros, rInfo.GetName() ) )
@@ -2112,7 +2111,7 @@ sal_Bool SdrPowerPointImport::ReadFontCollection()
     DffRecordHeader* pEnvHd = aDocRecManager.GetRecordHeader( PPT_PST_Environment );
     if ( pEnvHd )
     {
-        sal_uLong nFPosMerk = rStCtrl.Tell(); // FilePos merken fuer spaetere Restauration
+        sal_uLong nFPosMerk = rStCtrl.Tell(); // remember FilePos for restoring it later
         pEnvHd->SeekToContent( rStCtrl );
         DffRecordHeader aListHd;
         if ( SeekToRec( rStCtrl, PPT_PST_FontCollection, pEnvHd->GetRecEndFilePos(), &aListHd ) )
@@ -2152,7 +2151,7 @@ sal_Bool SdrPowerPointImport::ReadFontCollection()
             }
             delete pVDev;
         }
-        rStCtrl.Seek( nFPosMerk ); // FilePos restaurieren
+        rStCtrl.Seek( nFPosMerk ); // restore FilePos
     }
     return bRet;
 }
@@ -2197,7 +2196,7 @@ SdrObject* SdrPowerPointImport::ApplyTextObj( PPTTextObj* pTextObj, SdrTextObj*
     {
         sal_uInt32 nDestinationInstance = pTextObj->GetDestinationInstance() ;
         SdrOutliner& rOutliner = pText->ImpGetDrawOutliner();
-        if ( ( pText->GetObjInventor() == SdrInventor ) && ( pText->GetObjIdentifier() == OBJ_TITLETEXT ) ) // Outliner-Style fuer Titel-Textobjekt?!? (->von DL)
+        if ( ( pText->GetObjInventor() == SdrInventor ) && ( pText->GetObjIdentifier() == OBJ_TITLETEXT ) ) // Outliner-Style for Title-Text object?!? (->of DL)
             rOutliner.Init( OUTLINERMODE_TITLEOBJECT );             // Outliner reset
 
         sal_Bool bOldUpdateMode = rOutliner.GetUpdateMode();
@@ -2339,7 +2338,7 @@ SdrObject* SdrPowerPointImport::ApplyTextObj( PPTTextObj* pTextObj, SdrTextObj*
 sal_Bool SdrPowerPointImport::SeekToDocument( DffRecordHeader* pRecHd ) const
 {
     sal_Bool bRet;
-    sal_uLong nFPosMerk = rStCtrl.Tell(); // FilePos merken fuer ggf. spaetere Restauration
+    sal_uLong nFPosMerk = rStCtrl.Tell(); // remember FilePos for restoring it should the situation arise
     rStCtrl.Seek( nDocStreamPos );
     DffRecordHeader aDocHd;
     rStCtrl >> aDocHd;
@@ -2352,7 +2351,7 @@ sal_Bool SdrPowerPointImport::SeekToDocument( DffRecordHeader* pRecHd ) const
             aDocHd.SeekToBegOfRecord( rStCtrl );
     }
     if ( !bRet )
-        rStCtrl.Seek( nFPosMerk ); // FilePos restaurieren
+        rStCtrl.Seek( nFPosMerk ); // restore FilePos
     return bRet;
 }
 
@@ -2491,7 +2490,7 @@ Size SdrPowerPointImport::GetPageSize() const
         bool bInch = IsInch( eMap );
         long nInchMul = 1, nInchDiv = 1;
         if ( bInch )
-        {   // Size temporaer (zum runden) in nach metric konvertieren
+        {   // temporarily convert size (for rounding it) from inch to metric units
             Fraction aFact(GetMapFactor(eMap,MAP_100TH_MM).X());
             nInchMul = aFact.GetNumerator();
             nInchDiv = aFact.GetDenominator();
@@ -2523,7 +2522,7 @@ bool SdrPowerPointImport::GetColorFromPalette( sal_uInt16 nNum, Color& rColor )
             if ( ! ( nSlideFlags & 2 ) )
                 ((SdrPowerPointImport*)this)->aPageColors = pE->aColorScheme;
         }
-        if ( nSlideFlags & 2 )      // follow master colorscheme ?
+        if ( nSlideFlags & 2 )      // follow master colorscheme?
         {
             PptSlidePersistList* pPageList2 = GetPageList( PPT_MASTERPAGE );
             if ( pPageList2 )
@@ -2543,7 +2542,7 @@ bool SdrPowerPointImport::GetColorFromPalette( sal_uInt16 nNum, Color& rColor )
                 if ( pMasterPersist )
                 {
                     while( ( pMasterPersist && pMasterPersist->aSlideAtom.nFlags & 2 )  // it is possible that a masterpage
-                        && pMasterPersist->aSlideAtom.nMasterId )                       // itself is following a master colorscheme
+                        && pMasterPersist->aSlideAtom.nMasterId )                        // itself is following a master colorscheme
                     {
                         sal_uInt16 nNextMaster = pMasterPages->FindPage( pMasterPersist->aSlideAtom.nMasterId );
                         if ( nNextMaster == PPTSLIDEPERSIST_ENTRY_NOTFOUND )
@@ -2555,7 +2554,7 @@ bool SdrPowerPointImport::GetColorFromPalette( sal_uInt16 nNum, Color& rColor )
                 }
             }
         }
-        // momentanes Farbschema eintragen
+        // resgister current color scheme
         ((SdrPowerPointImport*)this)->nPageColorsNum = nAktPageNum;
         ((SdrPowerPointImport*)this)->ePageColorsKind = eAktPageKind;
     }
@@ -2765,7 +2764,7 @@ void SdrPowerPointImport::ImportPage( SdrPage* pRet, const PptSlidePersistEntry*
                                 case DFF_msofbtSpContainer :
                                 {
                                     Rectangle aPageSize( Point(), pRet->GetSize() );
-                                    if ( rSlidePersist.aSlideAtom.nFlags & 4 )          // follow master background ?
+                                    if ( rSlidePersist.aSlideAtom.nFlags & 4 )          // follow master background?
                                     {
                                         if ( HasMasterPage( nAktPageNum, eAktPageKind ) )
                                         {
@@ -2782,7 +2781,7 @@ void SdrPowerPointImport::ImportPage( SdrPage* pRet, const PptSlidePersistEntry*
                                             }
                                             if ( pE->nBackgroundOffset )
                                             {
-                                                // do not follow master colorscheme ?
+                                                // do not follow master colorscheme?
                                                 sal_Bool bTemporary = ( rSlidePersist.aSlideAtom.nFlags & 2 ) != 0;
                                                 sal_uInt32 nPos = rStCtrl.Tell();
                                                 rStCtrl.Seek( pE->nBackgroundOffset );
@@ -2862,7 +2861,7 @@ void SdrPowerPointImport::ImportPage( SdrPage* pRet, const PptSlidePersistEntry*
                             aEscherObjListHd.SeekToEndOfRecord( rStCtrl );
                         }
 
-                        /* There are a lot of Shapes who are dependent to
+                        /* There are a lot of Shapes which are dependent to
                            the current background color */
                         if ( rSlidePersist.ePageKind == PPT_SLIDEPAGE )
                         {
@@ -2977,10 +2976,10 @@ SdrObject* SdrPowerPointImport::ImportPageBackgroundObject( const SdrPage& rPage
     SdrObject* pRet = NULL;
     sal_Bool bCreateObj = bForce;
     SfxItemSet* pSet = NULL;
-    sal_uLong nFPosMerk = rStCtrl.Tell(); // FilePos merken fuer spaetere Restauration
+    sal_uLong nFPosMerk = rStCtrl.Tell(); // remember FilePos for restoring it later
     DffRecordHeader aPageHd;
     if ( SeekToAktPage( &aPageHd ) )
-    {   // und nun die Hintergrundattribute der Page suchen
+    {   // and now search for the background attributes of the Page
         sal_uLong nPageRecEnd = aPageHd.GetRecEndFilePos();
         DffRecordHeader aPPDrawHd;
         if ( SeekToRec( rStCtrl, PPT_PST_PPDrawing, nPageRecEnd, &aPPDrawHd ) )
@@ -3011,7 +3010,7 @@ SdrObject* SdrPowerPointImport::ImportPageBackgroundObject( const SdrPage& rPage
             }
         }
     }
-    rStCtrl.Seek( nFPosMerk ); // FilePos restaurieren
+    rStCtrl.Seek( nFPosMerk ); // restore FilePos
     if ( bCreateObj )
     {
         if ( !pSet )
@@ -3404,7 +3403,7 @@ sal_Bool PPTNumberFormatCreator::ImplGetExtNumberFormat( SdrPowerPointImport& rM
                     if ( (!( nBuFlags & 0x00800000)) && ( nMaBuFlags & 0x00800000 ) )
                     {
                         if (!( nBuFlags & 0x02000000))          // if there is a BuStart without BuInstance,
-                            nBuBlip = rLev.mnBuBlip;        // then there is no graphical Bullet possible
+                            nBuBlip = rLev.mnBuBlip;            // then there is no graphical Bullet possible
                     }
                     if ( (!( nBuFlags & 0x01000000)) && ( nMaBuFlags & 0x01000000 ) )
                         nAnmScheme = rLev.mnAnmScheme;
@@ -3735,7 +3734,7 @@ void PPTCharSheet::Read( SvStream& rIn, sal_Bool /*bMasterStyle*/, sal_uInt32 nL
     {
         sal_uInt16 nBitAttr;
         maCharLevel[ nLevel ].mnFlags &= ~( (sal_uInt16)nCMask );
-        rIn >> nBitAttr; // Bit-Attribute (Fett, Unterstrichen, ...)
+        rIn >> nBitAttr; // Bit attributes (bold, underlined, ...)
         maCharLevel[ nLevel ].mnFlags |= nBitAttr;
     }
     if ( nCMask & ( 1 << PPT_CharAttr_Font ) )                  // 0x00010000
@@ -4097,7 +4096,7 @@ PPTStyleSheet::PPTStyleSheet( const DffRecordHeader& rSlideHd, SvStream& rIn, Sd
                     mpCharSheet[ nInstance ]->maCharLevel[ nLev ] = mpCharSheet[ nInstance ]->maCharLevel[ nLev - 1 ];
                 }
 
-                // Ausnahme: Vorlage 5, 6 (MasterTitle Titel und SubTitel)
+                // Exception: Template 5, 6 (MasterTitle Title und SubTitle)
                 if ( nInstance >= TSS_TYPE_SUBTITLE )
                 {
                     bFirst = sal_False;
@@ -4778,7 +4777,7 @@ void PPTStyleTextPropReader::ReadParaProps( SvStream& rIn, SdrPowerPointImport&
         if ( bTextPropAtom )
         {
             rIn >> nCharCount
-                >> aParaPropSet.pParaSet->mnDepth;  // Einruecktiefe
+                >> aParaPropSet.pParaSet->mnDepth;  // indent depth
 
             aParaPropSet.pParaSet->mnDepth =        // taking care of about using not more than 9 outliner levels
                 std::min(sal_uInt16(8),
@@ -6580,7 +6579,7 @@ PPTTextObj::PPTTextObj( SvStream& rIn, SdrPowerPointImport& rSdrPowerPointImport
                                             rIn >> pEntry->nPos
                                                 >> nVal;
 
-                                            // ID auswerten
+                                            // evaluate ID
                                             //SvxFieldItem* pFieldItem = NULL;
                                             switch( aTextHd.nRecType )
                                             {