Translated German comments vcl/source

Change-Id: I1143996ef86e35caa72cf2e60ae586940a10ce81
Reviewed-on: https://gerrit.libreoffice.org/7527
Reviewed-by: Michael Meeks <michael.meeks@collabora.com>
Tested-by: Michael Meeks <michael.meeks@collabora.com>

7 files changed, 92 insertions, 92 deletions

diff --git a/vcl/source/control/edit.cxx b/vcl/source/control/edit.cxx
index 3a5e5791b47d..2a17a04c5efd 100644
--- a/vcl/source/control/edit.cxx
+++ b/vcl/source/control/edit.cxx
@@ -2107,7 +2107,7 @@ void Edit::Command( const CommandEvent& rCEvt )
         }
         else
         {
-            // Paste nur, wenn Text im Clipboard
+            // only paste if text available in clipboard
             sal_Bool bData = sal_False;
             uno::Reference< datatransfer::clipboard::XClipboard > xClipboard = GetClipboard();
             if ( xClipboard.is() )
diff --git a/vcl/source/filter/igif/decode.cxx b/vcl/source/filter/igif/decode.cxx
index bf29328e5109..fd92fba99856 100644
--- a/vcl/source/filter/igif/decode.cxx
+++ b/vcl/source/filter/igif/decode.cxx
@@ -153,7 +153,7 @@ bool GIFLZWDecompressor::ProcessOneCode()
 
     if ( !bEndOfBlock )
     {
-        // Einen Code aus dem Eingabe-Buffer holen:
+        // fetch code from input buffer
         nCode = sal::static_int_cast< sal_uInt16 >(
             ( (sal_uInt16) nInputBitsBuf ) & ( ~( 0xffff << nCodeSize ) ));
         nInputBitsBuf >>= nCodeSize;
@@ -188,7 +188,7 @@ bool GIFLZWDecompressor::ProcessOneCode()
 
         nOldCode = nCode;
 
-        // Zeichen(/-folge) des Codes nCode in den Ausgabe-Buffer schreiben:
+        // write character(/-sequence) of code nCode in the output buffer:
         pE = pTable + nCode;
         do
         {
diff --git a/vcl/source/filter/ixbm/xbmread.cxx b/vcl/source/filter/ixbm/xbmread.cxx
index 7dfc3334143a..e7c1ed1ef23c 100644
--- a/vcl/source/filter/ixbm/xbmread.cxx
+++ b/vcl/source/filter/ixbm/xbmread.cxx
@@ -80,7 +80,7 @@ void XBMReader::InitTable()
     pHexTable[(int)'e'] = 14;
     pHexTable[(int)'f'] = 15;
     pHexTable[(int)'x'] = 0;
-    pHexTable[(int)' '] =     -1;
+    pHexTable[(int)' '] = -1;
     pHexTable[(int)','] = -1;
     pHexTable[(int)'}'] = -1;
     pHexTable[(int)'\n'] = -1;
@@ -143,22 +143,22 @@ long XBMReader::ParseDefine( const sal_Char* pDefine )
     char*   pTmp = (char*) pDefine;
     unsigned char   cTmp;
 
-    // bis zum Ende gehen
+    // move to end
     pTmp += ( strlen( pDefine ) - 1 );
     cTmp = *pTmp--;
 
-    // letzte Ziffer suchen
+    // search last digit
     while( pHexTable[ cTmp ] == -1 )
         cTmp = *pTmp--;
 
-    // bis vor die Zahl laufen
+    // move before number
     while( pHexTable[ cTmp ] != -1 )
         cTmp = *pTmp--;
 
-    // auf Anfang der Zahl gehen
+    // move to start of number
     pTmp += 2;
 
-    // Hex lesen
+    // read Hex
     if( ( pTmp[0] == '0' ) && ( ( pTmp[1] == 'X' ) || ( pTmp[1] == 'x' ) ) )
     {
         pTmp += 2;
@@ -170,7 +170,7 @@ long XBMReader::ParseDefine( const sal_Char* pDefine )
             cTmp = *pTmp++;
         }
     }
-    // Dezimal lesen
+    // read decimal
     else
     {
         cTmp = *pTmp++;
@@ -203,7 +203,7 @@ bool XBMReader::ParseData( SvStream* pInStm, const OString& aLastLine, XBMFormat
         {
             sal_Int32 nPos;
 
-            // einfuehrende geschweifte Klammer loeschen
+            // delete opening curly bracket
             if( (nPos = ( aLine = aLastLine ).indexOf('{') ) != -1 )
                 aLine = aLine.copy(nPos + 1);
 
@@ -264,12 +264,12 @@ ReadState XBMReader::ReadXBM( Graphic& rGraphic )
     ReadState   eReadState;
     sal_uInt8       cDummy;
 
-    // sehen, ob wir _alles_ lesen koennen
+    // check if we can read ALL
     rIStm.Seek( STREAM_SEEK_TO_END );
     rIStm >> cDummy;
 
-    // falls wir nicht alles lesen koennen
-    // kehren wir zurueck und warten auf neue Daten
+    // if we cannot read all
+    // we returnn and wait for new data
     if ( rIStm.GetError() != ERRCODE_IO_PENDING )
     {
         rIStm.Seek( nLastPos );
@@ -284,8 +284,8 @@ ReadState XBMReader::ReadXBM( Graphic& rGraphic )
                 nWidth = nValue;
                 aLine = FindTokenLine( &rIStm, "#define", "_height" );
 
-                // Falls die Hoehe nicht folgt, suchen wir noch
-                // einmal vom Anfang der Datei an
+                // if height was not received, we search again
+                // from start of the file
                 if ( !bStatus )
                 {
                     rIStm.Seek( nLastPos );
diff --git a/vcl/source/filter/ixpm/xpmread.cxx b/vcl/source/filter/ixpm/xpmread.cxx
index 3a8597840f2b..88ad230cea38 100644
--- a/vcl/source/filter/ixpm/xpmread.cxx
+++ b/vcl/source/filter/ixpm/xpmread.cxx
@@ -64,12 +64,12 @@ ReadState XPMReader::ReadXPM( Graphic& rGraphic )
     ReadState   eReadState;
     sal_uInt8       cDummy;
 
-    // sehen, ob wir _alles_ lesen koennen
+    // check if we can real ALL
     mrIStm.Seek( STREAM_SEEK_TO_END );
     mrIStm >> cDummy;
 
-    // falls wir nicht alles lesen koennen
-    // kehren wir zurueck und warten auf neue Daten
+    // if we could not read all
+    // return and wait for new data
     if ( mrIStm.GetError() != ERRCODE_IO_PENDING )
     {
         mrIStm.Seek( mnLastPos );
@@ -82,7 +82,7 @@ ReadState XPMReader::ReadXPM( Graphic& rGraphic )
 
             if ( ( mbStatus = ImplGetString() ) )
             {
-                mnIdentifier = XPMVALUES;           // Bitmap informationen einholen
+                mnIdentifier = XPMVALUES;           // fetch Bitmap information
                 mnWidth = ImplGetULONG( 0 );
                 mnHeight = ImplGetULONG( 1 );
                 mnColors = ImplGetULONG( 2 );
@@ -96,10 +96,10 @@ ReadState XPMReader::ReadXPM( Graphic& rGraphic )
             {
                 mnIdentifier = XPMCOLORS;
 
-                // mpColMap beinhaltet fuer jede vorhandene
-                // Farbe:   ( mnCpp )Byte(s)-> ASCII Eintrag der der Farbe zugeordnet ist
-                //              1    Byte   -> 0xff wenn Farbe transparent ist
-                //              3    Bytes  -> RGB Wert der Farbe
+                // mpColMap constitutes for all available
+                // colour:   ( mnCpp )Byte(s)-> ASCII entry assigned to the colour
+                //              1    Byte   -> 0xFF if colour is transparent
+                //              3    Bytes  -> RGB value of the colour
                 mpColMap = new sal_uInt8[ mnColors * ( 4 + mnCpp ) ];
                 if ( mpColMap )
                 {
@@ -117,7 +117,7 @@ ReadState XPMReader::ReadXPM( Graphic& rGraphic )
 
                 if ( mbStatus )
                 {
-                    // bei mehr als 256 Farben wird eine 24 Bit Grafik erstellt
+                    // create a 24bit graphic when more as 256 colours present
                     sal_uInt16  nBits = 1;
                     if ( mnColors > 256 )
                         nBits = 24;
@@ -131,7 +131,7 @@ ReadState XPMReader::ReadXPM( Graphic& rGraphic )
                     maBmp = Bitmap( Size( mnWidth, mnHeight ), nBits );
                     mpAcc = maBmp.AcquireWriteAccess();
 
-                    // mbTransparent ist true wenn mindestens eine Farbe Transparent ist
+                    // mbTransparent is TRUE if at least one colour is transparent
                     if ( mbTransparent )
                     {
                         maMaskBmp = Bitmap( Size( mnWidth, mnHeight ), 1 );
@@ -215,8 +215,8 @@ ReadState XPMReader::ReadXPM( Graphic& rGraphic )
 }
 
 // ------------------------------------------------------------------------
-// ImplGetColor ermittelt saemtliche Farbwerte,
-// die Rueckgabe ist true wenn saemtliche Farben zugeordnet werden konnten
+// ImplGetColor returns variouls colour values,
+// returns TRUE if various colours could be assigned
 
 bool XPMReader::ImplGetColor( sal_uLong nNumb )
 {
@@ -234,8 +234,8 @@ bool XPMReader::ImplGetColor( sal_uLong nNumb )
 }
 
 // ------------------------------------------------------------------------
-// ImpGetScanLine liest den String mpBufSize aus und schreibt die Pixel in die
-// Bitmap. Der Parameter nY gibt die horizontale Position an.
+// ImpGetScanLine reads the string mpBufSize and writes the pixel in the
+// Bitmap. Parameter nY is the horizontal position.
 
 bool XPMReader::ImplGetScanLine( sal_uLong nY )
 {
@@ -300,9 +300,9 @@ bool XPMReader::ImplGetScanLine( sal_uLong nY )
 }
 
 // ------------------------------------------------------------------------
-// versucht aus mpStringBuf einen Farbwert zu uebermitteln
-// wurde eine Farbe gefunden wird an pDest[1]..pDest[2] der RGB wert geschrieben
-// pDest[0] enthaelt 0xff wenn die Farbe transparent ist sonst 0
+// tries to determine a colour value from mpStringBuf
+// if a colour was found the RGB value is written a pDest[1]..pDest[2]
+// pDest[0] contains 0xFF if the colour is transparent otherwise 0
 
 bool XPMReader::ImplGetColSub( sal_uInt8* pDest )
 {
@@ -368,8 +368,8 @@ bool XPMReader::ImplGetColSub( sal_uInt8* pDest )
 }
 
 // ------------------------------------------------------------------------
-// ImplGetColKey durchsuch den String mpStringBuf nach einem Parameter 'nKey'
-// und gibt einen bool zurueck. ( wenn true werden mpPara und mnParaSize gesetzt )
+// ImplGetColKey searches string mpStringBuf for a parameter 'nKey'
+// and returns a boolean. (if TRUE mpPara and mnParaSize will be set)
 
 bool XPMReader::ImplGetColKey( sal_uInt8 nKey )
 {
@@ -412,12 +412,12 @@ bool XPMReader::ImplGetColKey( sal_uInt8 nKey )
 }
 
 // ------------------------------------------------------------------------
-// ImplGetRGBHex uebersetzt den ASCII-Hexadezimalwert der sich bei mpPara befindet
-// in einen RGB wert und schreibt diesen nach pDest
-// folgende Formate muessen sich bei mpPara befinden:
-// wenn nAdd = 0 : '#12ab12'                    -> RGB = 0x12, 0xab, 0x12
-//             2 : '#1234abcd1234'                  "      "     "     "
-//             6 : '#12345678abcdefab12345678'      "      "     "     "
+// ImplGetRGBHex translates the ASCII-Hexadecimalvalue belonging to mpPara
+// in a RGB value and writes this to pDest
+// below formats should be contained in mpPara:
+// if nAdd = 0 : '#12ab12'                    -> RGB = 0x12, 0xab, 0x12
+//           2 : '#1234abcd1234'                  "      "     "     "
+//           6 : '#12345678abcdefab12345678'      "      "     "     "
 
 
 void XPMReader::ImplGetRGBHex( sal_uInt8* pDest,sal_uLong  nAdd )
@@ -442,7 +442,7 @@ void XPMReader::ImplGetRGBHex( sal_uInt8* pDest,sal_uLong  nAdd )
 }
 
 // ------------------------------------------------------------------------
-// ImplGetUlong gibt den wert einer bis zu 6stelligen ASCII-Dezimalzahl zurueck.
+// ImplGetUlong returns the value of a up to 6-digit long ASCII-decimal number.
 
 sal_uLong XPMReader::ImplGetULONG( sal_uLong nPara )
 {
@@ -496,10 +496,10 @@ bool XPMReader::ImplCompare( sal_uInt8* pSource, sal_uInt8* pDest, sal_uLong nSi
 }
 
 // ------------------------------------------------------------------------
-// ImplGetPara versucht den nNumb  ( 0...x ) Parameter aus mpStringBuf zu ermitteln.
-// Ein Parameter ist durch Spaces oder Tabs von den anderen getrennt.
-// Konnte der Parameter gefunden werden ist der Rueckgabewert true und mpPara + mnParaSize
-// werden gesetzt.
+// ImplGetPara tries to retrieve nNumb (0...x) parameters from mpStringBuf.
+// Parameters are separated by spaces or tabs.
+// If a parameter was found then the return value is TRUE and mpPara + mnParaSize
+// are set.
 
 bool XPMReader::ImplGetPara ( sal_uLong nNumb )
 {
@@ -552,9 +552,9 @@ bool XPMReader::ImplGetPara ( sal_uLong nNumb )
 }
 
 // ------------------------------------------------------------------------
-// Der naechste String wird ausgelesen und in mpStringBuf (mit 0 abgeschlossen) abgelegt;
-// mnStringSize enthaelt die Groesse des gelesenen Strings.
-// Bemerkungen wie '//' und '/*.....*/' werden uebersprungen.
+// The next string is read and stored in mpStringBuf (terminated with 0);
+// mnStringSize contains the size of the string read.
+// Comments like '//' and '/*....*/' are skipped.
 
 bool XPMReader::ImplGetString( void )
 {
diff --git a/vcl/source/filter/jpeg/JpegReader.cxx b/vcl/source/filter/jpeg/JpegReader.cxx
index 1a2416a8ddd6..1cc48482ca8d 100644
--- a/vcl/source/filter/jpeg/JpegReader.cxx
+++ b/vcl/source/filter/jpeg/JpegReader.cxx
@@ -86,8 +86,8 @@ long StreamRead( SvStream* pStream, void* pBuffer, long nBufferSize )
 
         if( pStream->GetError() == ERRCODE_IO_PENDING )
         {
-            // Damit wir wieder an die alte Position
-            // seeken koennen, setzen wir den Error temp.zurueck
+            // in order to search from the old position
+            // we temporarily reset the error
             pStream->ResetError();
             pStream->Seek( nInitialPosition );
             pStream->SetError( ERRCODE_IO_PENDING );
diff --git a/vcl/source/filter/sgfbram.hxx b/vcl/source/filter/sgfbram.hxx
index 268405e65a4e..0bc8614e1d79 100644
--- a/vcl/source/filter/sgfbram.hxx
+++ b/vcl/source/filter/sgfbram.hxx
@@ -22,22 +22,22 @@
 
 #include <tools/solar.h>
 
-#define SgfBitImag0   1 /* Bitmap                      */
-#define SgfBitImag1   4 /* Bitmap                      */
-#define SgfBitImag2   5 /* Bitmap                      */
-#define SgfBitImgMo   6 /* Monochrome Bitmap           */
-#define SgfSimpVect   2 /* Einfaches Vectorformat      */
-#define SgfPostScrp   3 /* Postscript file             */
-#define SgfStarDraw   7 /* StarDraw SGV-Datei          */
-#define SgfDontKnow 255 /* Unbekannt oder kein SGF/SGV */
-
-// Konstanten f�r SgfHeader.SwGrCol
-#define SgfBlckWhit 1 /* Schwarz/Wei?Bild                  Ŀ SimpVector,  */
-#define SgfGrayscal 2 /* Bild mit Graustufen                 ?StarDraw und */
-#define Sgf16Colors 3 /* Farbbild (16 Farben)               �� Bit Image    */
-#define SgfVectFarb 4 /* Farben f�r Linien verwenden        Ŀ              */
-#define SgfVectGray 5 /* Graustufen f�r Linien verwenden     ?Nur f�r      */
-#define SgfVectWdth 6 /* Strichst�rken f�r Linien verwenden �� SimpVector   */
+#define SgfBitImag0   1 /* Bitmap                  */
+#define SgfBitImag1   4 /* Bitmap                  */
+#define SgfBitImag2   5 /* Bitmap                  */
+#define SgfBitImgMo   6 /* Monochrome bitmap       */
+#define SgfSimpVect   2 /* Simple vectorformat     */
+#define SgfPostScrp   3 /* Postscript file         */
+#define SgfStarDraw   7 /* StarDraw SGV-file       */
+#define SgfDontKnow 255 /* Unknown or no SGF/SGV   */
+
+// constants for SgfHeader.SwGrCol
+#define SgfBlckWhit 1 /* black/white image                  SimpVector,  */
+#define SgfGrayscal 2 /* image with greyscale               StarDraw and */
+#define Sgf16Colors 3 /* colour image  (16 colours)         Bit Image    */
+#define SgfVectFarb 4 /* use colours in lines                            */
+#define SgfVectGray 5 /* use greyscale for lines only for                */
+#define SgfVectWdth 6 /* use line widths for lines          SimpVector   */
 
 
 #define SgfHeaderSize 42
@@ -55,7 +55,7 @@ public:
     sal_uInt16 SwGrCol;
     char   Autor[10];
     char   Programm[10];
-    sal_uInt16 OfsLo,OfsHi; // DWord-Allignment ist notwendig (38 mod 4 =2) !
+    sal_uInt16 OfsLo,OfsHi; // DWord allignment is necessary (38 mod 4 =2) !
 
     sal_uInt32 GetOffset();
     friend SvStream& operator>>(SvStream& rIStream, SgfHeader& rHead);
@@ -70,7 +70,7 @@ public:
     sal_uInt16 iFrei;
     sal_uInt16 lFreiLo,lFreiHi;
     char   cFrei[10];
-    sal_uInt16 OfsLo,OfsHi; // DWord-Allignment ist notwendig (18 mod 4 =2) !
+    sal_uInt16 OfsLo,OfsHi; // DWord allignment is necessary (18 mod 4 =2) !
 
     sal_uInt32 GetOffset();
     friend SvStream& operator>>(SvStream& rIStream, SgfEntry& rEntr);
@@ -83,7 +83,7 @@ public:
     sal_uInt16 Flag;
     sal_Int16 x;
     sal_Int16 y;
-    sal_uInt16 OfsLo,OfsHi; // DWord-Allignment ist notwendig (6 mod 4 =2) !
+    sal_uInt16 OfsLo,OfsHi; // DWord allignment is necessary (6 mod 4 =2) !
 
     friend SvStream& operator>>(SvStream& rIStream, SgfVector& rEntr);
 };
@@ -105,9 +105,9 @@ class BmpFileHeader
 {
 public:
     sal_uInt16 Typ;            // = "BM"
-    sal_uInt16 SizeLo,SizeHi;  // Filesize in Bytes
-    sal_uInt16 Reserve1;       // Reserviert
-    sal_uInt16 Reserve2;       // Reserviert
+    sal_uInt16 SizeLo,SizeHi;  // filesize in bytes
+    sal_uInt16 Reserve1;       // reserved
+    sal_uInt16 Reserve2;       // reserved
     sal_uInt16 OfsLo,OfsHi;    // Offset?
 
     void   SetSize(sal_uInt32 Size);
@@ -120,17 +120,17 @@ public:
 class BmpInfoHeader
 {
 public:
-    sal_uInt32 Size;       // Gr��e des BmpInfoHeaders
-    sal_Int32  Width;      // Breite in Pixel
-    sal_Int32  Hight;      // H�he in Pixel
-    sal_uInt16 Planes;     // Anzahl der Planes (immer 1)
-    sal_uInt16 PixBits;    // Anzahl der Bit je Pixel (1,4,8,oder 24)
-    sal_uInt32 Compress;   // Datenkompression
-    sal_uInt32 ImgSize;    // Gr��e der Images in Bytes. Ohne Kompression ist auch 0 erlaubt.
-    sal_Int32  xDpmm;      // Dot per Meter (0 ist erlaubt)
-    sal_Int32  yDpmm;      // Dot per Meter (0 ist erlaubt)
-    sal_uInt32 ColUsed;    // Anzahl der verwendeten Farben (0=alle)
-    sal_uInt32 ColMust;    // Anzahl der wichtigen Farben (0=alle)
+    sal_uInt32 Size;       // size of BmpInfoHeaders
+    sal_Int32  Width;      // width in Pixel
+    sal_Int32  Hight;      // height in Pixel
+    sal_uInt16 Planes;     // number of planes (always 1)
+    sal_uInt16 PixBits;    // number of bits per pixel (1,4,8 or 24)
+    sal_uInt32 Compress;   // datakompression
+    sal_uInt32 ImgSize;    // size of  image in bytes. Without compression also 0 is allowed.
+    sal_Int32  xDpmm;      // Dot per Meter (0 is allowed)
+    sal_Int32  yDpmm;      // Dot per Meter (0 is allowed)
+    sal_uInt32 ColUsed;    // number of colours used (0=all
+    sal_uInt32 ColMust;    // number of important colours (0=all)
 
     friend SvStream& WriteBmpInfoHeader(SvStream& rOStream, BmpInfoHeader& rHead);
 };
diff --git a/vcl/source/filter/sgffilt.hxx b/vcl/source/filter/sgffilt.hxx
index 2eef485f9c50..5269e1c78510 100644
--- a/vcl/source/filter/sgffilt.hxx
+++ b/vcl/source/filter/sgffilt.hxx
@@ -26,15 +26,15 @@ bool SgfBMapFilter(SvStream& rInp, SvStream& rOut);
 bool SgfVectFilter(SvStream& rInp, GDIMetaFile& rMtf);
 bool SgfSDrwFilter(SvStream& rInp, GDIMetaFile& rMtf, INetURLObject aIniPath );
 
-// Konstanten f�r CheckSgfTyp()
-#define SGF_BITIMAGE   1     /* Bitmap                      */
-#define SGF_SIMPVECT   2     /* Einfaches Vectorformat      */
-#define SGF_POSTSCRP   3     /* Postscript file             */
-#define SGF_STARDRAW   7     /* StarDraw SGV-Datei          */
-#define SGF_DONTKNOW 255     /* Unbekannt oder kein SGF/SGV */
+// constants for CheckSgfTyp()
+#define SGF_BITIMAGE   1     /* Bitmap                 */
+#define SGF_SIMPVECT   2     /* simple vectorformat    */
+#define SGF_POSTSCRP   3     /* Postscript file        */
+#define SGF_STARDRAW   7     /* StarDraw SGV file      */
+#define SGF_DONTKNOW 255     /* unknown or no SGF/SGV  */
 
-#define SGV_VERSION    3     /* SGV mit anderer Version wird abgewiesen */
-                             /* 3 entspricht StarDraw 2.00/2.01 M�rz'93 */
+#define SGV_VERSION    3     /* reject SGV with other version         */
+                             /* 3 matches StarDraw 2.00/2.01 march'93 */
 #endif // INCLUDED_VCL_SOURCE_FILTER_SGFFILT_HXX
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */