Remove dead code and translate German comments

42 files changed, 676 insertions, 2260 deletions

diff --git a/svx/source/dialog/_bmpmask.cxx b/svx/source/dialog/_bmpmask.cxx
index aee42601a278..2854eed67681 100644
--- a/svx/source/dialog/_bmpmask.cxx
+++ b/svx/source/dialog/_bmpmask.cxx
@@ -241,7 +241,7 @@ IMPL_LINK( MaskData, CbxHdl, CheckBox*, pCbx )
     else
         pMask->aBtnExec.Disable();
 
-    // Wenn eine Checkbox gecheckt wurde, wird die Pipette enabled
+    // When a checkbox is checked, the pipette is enabled
     if ( pCbx->IsChecked() )
     {
         MaskSet* pSet = NULL;
@@ -479,28 +479,24 @@ SvxBmpMask::SvxBmpMask( SfxBindings *pBindinx,
     pQSet1->SetStyle( pQSet1->GetStyle() | WB_DOUBLEBORDER | WB_ITEMBORDER );
     pQSet1->SetColCount( 1 );
     pQSet1->SetLineCount( 1 );
-//  pQSet1->SetExtraSpacing( 1 );
     pQSet1->InsertItem( 1, aPipetteColor );
     pQSet1->SelectItem( 1 );
 
     pQSet2->SetStyle( pQSet2->GetStyle() | WB_DOUBLEBORDER | WB_ITEMBORDER );
     pQSet2->SetColCount( 1 );
     pQSet2->SetLineCount( 1 );
-//  pQSet2->SetExtraSpacing( 1 );
     pQSet2->InsertItem( 1, aPipetteColor );
     pQSet2->SelectItem( 0 );
 
     pQSet3->SetStyle( pQSet3->GetStyle() | WB_DOUBLEBORDER | WB_ITEMBORDER );
     pQSet3->SetColCount( 1 );
     pQSet3->SetLineCount( 1 );
-//  pQSet3->SetExtraSpacing( 1 );
     pQSet3->InsertItem( 1, aPipetteColor );
     pQSet3->SelectItem( 0 );
 
     pQSet4->SetStyle( pQSet4->GetStyle() | WB_DOUBLEBORDER | WB_ITEMBORDER );
     pQSet4->SetColCount( 1 );
     pQSet4->SetLineCount( 1 );
-//  pQSet4->SetExtraSpacing( 1 );
     pQSet4->InsertItem( 1, aPipetteColor );
     pQSet4->SelectItem( 0 );
 
@@ -527,18 +523,6 @@ SvxBmpMask::~SvxBmpMask()
 /** is called by a MaskSet when it is selected */
 void SvxBmpMask::onSelect( MaskSet* pSet )
 {
-    // automaticaly set focus to the corresponding listbox
-/*
-    if( pSet == pQSet1 )
-        aLbColor1.GrabFocus();
-    else if( pSet == pQSet2 )
-        aLbColor2.GrabFocus();
-    else if( pSet == pQSet2 )
-        aLbColor3.GrabFocus();
-    else if( pSet == pQSet2 )
-        aLbColor4.GrabFocus();
-*/
-
     // now deselect all other value sets
     if( pSet != pQSet1 )
         pQSet1->SelectItem( 0 );
@@ -765,7 +749,7 @@ GDIMetaFile SvxBmpMask::ImpMask( const GDIMetaFile& rMtf )
     USHORT      nCount = InitColorArrays( pSrcCols, pDstCols, pTols );
     BOOL        pTrans[4];
 
-    // Falls keine Farben ausgewaehlt, kopieren wir nur das Mtf
+    // If no color is selected, we copy only the Mtf
     if( !nCount )
         aMtf = rMtf;
     else
@@ -788,7 +772,7 @@ GDIMetaFile SvxBmpMask::ImpMask( const GDIMetaFile& rMtf )
         aMtf.SetPrefSize( rMtf.GetPrefSize() );
         aMtf.SetPrefMapMode( rMtf.GetPrefMapMode() );
 
-        // Farbvergleichsarrays vorbereiten
+        // Prepare Color comparison array
         for( i = 0; i < nCount; i++ )
         {
             nTol = ( pTols[i] * 255L ) / 100L;
@@ -808,7 +792,7 @@ GDIMetaFile SvxBmpMask::ImpMask( const GDIMetaFile& rMtf )
             pTrans[ i ] = ( pDstCols[ i ] == TRANSP_COL );
         }
 
-        // Actions untersuchen und Farben ggf. ersetzen
+        // Investigate actions and if necessary replace colors
         for( ULONG nAct = 0UL, nActCount = rMtf.GetActionCount(); nAct < nActCount; nAct++ )
         {
             MetaAction* pAction = rMtf.GetAction( nAct );
@@ -1069,8 +1053,8 @@ GDIMetaFile SvxBmpMask::ImpReplaceTransparency( const GDIMetaFile& rMtf, const C
     aVDev.SetLineColor( rColor );
     aVDev.SetFillColor( rColor );
 
-    // Actions nacheinander abspielen; zuerst
-    // den gesamten Bereich auf die Ersatzfarbe setzen
+    // retrieve one action at the time; first
+    // set the whole area to the replacement color.
     aVDev.DrawRect( Rectangle( rPrefMap.GetOrigin(), rPrefSize ) );
     for ( ULONG i = 0; i < nActionCount; i++ )
     {
@@ -1099,7 +1083,7 @@ Graphic SvxBmpMask::Mask( const Graphic& rGraphic )
         {
             if( rGraphic.IsAnimated() )
             {
-                // Transparenz ersetzen?
+                // Replace transparency?
                 if ( aCbxTrans.IsChecked() )
                     aGraphic = ImpReplaceTransparency( rGraphic.GetAnimation(), aReplColor );
                 else
@@ -1107,7 +1091,7 @@ Graphic SvxBmpMask::Mask( const Graphic& rGraphic )
             }
             else
             {
-                // Transparenz ersetzen?
+                // Replace transparency?
                 if( aCbxTrans.IsChecked() )
                 {
                     if( aGraphic.IsTransparent() )
@@ -1128,10 +1112,10 @@ Graphic SvxBmpMask::Mask( const Graphic& rGraphic )
 
                     if( nCount )
                     {
-                        // erstmal alle Transparent-Farben setzen
+                        // first set all transparent colors
                         for( USHORT i = 0; i < nCount; i++ )
                         {
-                            // Haben wir eine Transparenzfarbe?
+                            // Do we have a transparent color?
                             if( pDstCols[i] == TRANSP_COL )
                             {
                                 BitmapEx    aBmpEx( ImpMaskTransparent( aGraphic.GetBitmapEx(),
@@ -1143,7 +1127,7 @@ Graphic SvxBmpMask::Mask( const Graphic& rGraphic )
                             }
                         }
 
-                        // jetzt noch einmal mit den normalen Farben ersetzen
+                        // now replace it again with the normal colors
                         Bitmap  aBitmap( ImpMask( aGraphic.GetBitmap() ) );
                         Size    aSize( aBitmap.GetSizePixel() );
 
@@ -1164,7 +1148,7 @@ Graphic SvxBmpMask::Mask( const Graphic& rGraphic )
         {
             GDIMetaFile aMtf( aGraphic.GetGDIMetaFile() );
 
-            // Transparenz ersetzen?
+            // Replace transparency?
             if( aCbxTrans.IsChecked() )
                 aMtf = ImpReplaceTransparency( aMtf, aReplColor );
             else
diff --git a/svx/source/dialog/_contdlg.cxx b/svx/source/dialog/_contdlg.cxx
index bb4a7277c7bc..0d5778101824 100644
--- a/svx/source/dialog/_contdlg.cxx
+++ b/svx/source/dialog/_contdlg.cxx
@@ -88,33 +88,19 @@ SFX_IMPL_FLOATINGWINDOW( SvxContourDlgChildWindow, SID_CONTOUR_DLG );
 
 /******************************************************************************/
 
-
-/*************************************************************************
-|*
-|* ControllerItem
-|*
-\************************************************************************/
-
 SvxContourDlgItem::SvxContourDlgItem( USHORT _nId, SvxSuperContourDlg& rContourDlg, SfxBindings& rBindings ) :
             SfxControllerItem   ( _nId, rBindings ),
             rDlg                ( rContourDlg )
 {
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void SvxContourDlgItem::StateChanged( USHORT nSID, SfxItemState /*eState*/, const SfxPoolItem* pItem )
 {
     if ( pItem && ( SID_CONTOUR_EXEC == nSID ) )
     {
         const SfxBoolItem* pStateItem = PTR_CAST( SfxBoolItem, pItem );
 
-        DBG_ASSERT( pStateItem || pItem == 0, "SfxBoolItem erwartet");
+        DBG_ASSERT( pStateItem || pItem == 0, "SfxBoolItem expected ");
 
         rDlg.SetExecState( !pStateItem->GetValue() );
     }
@@ -123,13 +109,6 @@ void SvxContourDlgItem::StateChanged( USHORT nSID, SfxItemState /*eState*/, cons
 
 /******************************************************************************/
 
-
-/*************************************************************************
-|*
-|* Contour-Float
-|*
-\************************************************************************/
-
 SvxContourDlgChildWindow::SvxContourDlgChildWindow( Window* _pParent, USHORT nId,
                                                     SfxBindings* pBindings, SfxChildWinInfo* pInfo ) :
             SfxChildWindow( _pParent, nId )
@@ -145,12 +124,6 @@ SvxContourDlgChildWindow::SvxContourDlgChildWindow( Window* _pParent, USHORT nId
     pDlg->Initialize( pInfo );
 }
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void SvxContourDlgChildWindow::UpdateContourDlg( const Graphic& rGraphic, BOOL bGraphicLinked,
                                                  const PolyPolygon* pPolyPoly, void* pEditingObj )
 {
@@ -159,12 +132,6 @@ void SvxContourDlgChildWindow::UpdateContourDlg( const Graphic& rGraphic, BOOL b
         SVXCONTOURDLG()->Update( rGraphic, bGraphicLinked, pPolyPoly, pEditingObj );
 }
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 SvxContourDlg::SvxContourDlg( SfxBindings* _pBindings, SfxChildWindow* pCW,
                               Window* _pParent, const ResId& rResId ) :
 
@@ -173,22 +140,10 @@ SvxContourDlg::SvxContourDlg( SfxBindings* _pBindings, SfxChildWindow* pCW,
 {
 }
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 SvxContourDlg::~SvxContourDlg()
 {
 }
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 PolyPolygon SvxContourDlg::CreateAutoContour( const Graphic& rGraphic,
                                               const Rectangle* pRect,
                                               const ULONG nFlags )
@@ -216,9 +171,8 @@ PolyPolygon SvxContourDlg::CreateAutoContour( const Graphic& rGraphic,
                 {
                     const AnimationBitmap& rStepBmp = aAnim.Get( i );
 
-                    // Polygonausgabe an die richtige Stelle schieben;
-                    // dies ist der Offset des Teilbildes innerhalb
-                    // der Gesamtanimation
+                    // Push Polygon output to the right place; this is the
+                    // offset of the sub-image within the total animation
                     aTransMap.SetOrigin( Point( rStepBmp.aPosPix.X(), rStepBmp.aPosPix.Y() ) );
                     aVDev.SetMapMode( aTransMap );
                     aVDev.DrawPolyPolygon( CreateAutoContour( rStepBmp.aBmpEx, pRect, nFlags ) );
@@ -270,13 +224,6 @@ PolyPolygon SvxContourDlg::CreateAutoContour( const Graphic& rGraphic,
     return PolyPolygon( XOutBitmap::GetCountour( aBmp, nContourFlags, 128, pRect ) );
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void SvxContourDlg::ScaleContour( PolyPolygon& rContour, const Graphic& rGraphic,
                                   const MapUnit eUnit, const Size& rDisplaySize )
 {
@@ -317,13 +264,8 @@ void SvxContourDlg::ScaleContour( PolyPolygon& rContour, const Graphic& rGraphic
     }
 }
 
-
-/*************************************************************************
-|*
-|* Durchschleifen an SuperClass; keine virt. Methoden, um
-|* bei IF-Aenderungen nicht inkompatibel zu werden
-|*
-\************************************************************************/
+// Loop through to super class, no virtual Methods to not become incompatible
+// due to IF changes
 
 void SvxContourDlg::SetExecState( BOOL bEnable )
 {
@@ -376,13 +318,6 @@ void SvxContourDlg::Update( const Graphic& rGraphic, BOOL bGraphicLinked,
     pSuperClass->UpdateGraphic( rGraphic, bGraphicLinked, pPolyPoly, pEditingObj );
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 SvxSuperContourDlg::SvxSuperContourDlg( SfxBindings *_pBindings, SfxChildWindow *pCW,
                                         Window* _pParent, const ResId& rResId ) :
         SvxContourDlg       ( _pBindings, pCW, _pParent, rResId ),
@@ -440,23 +375,11 @@ SvxSuperContourDlg::SvxSuperContourDlg( SfxBindings *_pBindings, SfxChildWindow
     aCreateTimer.SetTimeoutHdl( LINK( this, SvxSuperContourDlg, CreateHdl ) );
 }
 
-
-/*************************************************************************
-|*
-|* Dtor
-|*
-\************************************************************************/
-
 SvxSuperContourDlg::~SvxSuperContourDlg()
 {
 }
 
-
-/*************************************************************************
-|*
-|* Resize-Methode
-|*
-\************************************************************************/
+// Resize methods
 
 void SvxSuperContourDlg::Resize()
 {
@@ -470,11 +393,11 @@ void SvxSuperContourDlg::Resize()
         Size    _aSize( aStbStatus.GetSizePixel() );
         Point   aPoint( 0, aNewSize.Height() - _aSize.Height() );
 
-        // StatusBar positionieren
+        // Position the StatusBar
         aStbStatus.SetPosSizePixel( aPoint, Size( aNewSize.Width(), _aSize.Height() ) );
         aStbStatus.Show();
 
-        // EditWindow positionieren
+        // Position the EditWindow
         _aSize.Width() = aNewSize.Width() - 18;
         _aSize.Height() = aPoint.Y() - aContourWnd.GetPosPixel().Y() - 6;
         aContourWnd.SetSizePixel( _aSize );
@@ -483,12 +406,7 @@ void SvxSuperContourDlg::Resize()
     }
 }
 
-
-/*************************************************************************
-|*
-|* Close-Methode
-|*
-\************************************************************************/
+// Close methods
 
 BOOL SvxSuperContourDlg::Close()
 {
@@ -513,25 +431,13 @@ BOOL SvxSuperContourDlg::Close()
     return( bRet ? SfxFloatingWindow::Close() : FALSE );
 }
 
-
-/*************************************************************************
-|*
-|* Enabled oder disabled alle Controls
-|*
-\************************************************************************/
+// Enabled or disabled all Controls
 
 void SvxSuperContourDlg::SetExecState( BOOL bEnable )
 {
     bExecState = bEnable;
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void SvxSuperContourDlg::SetGraphic( const Graphic& rGraphic )
 {
     aUndoGraphic = aRedoGraphic = Graphic();
@@ -540,13 +446,6 @@ void SvxSuperContourDlg::SetGraphic( const Graphic& rGraphic )
     aContourWnd.SetGraphic( aGraphic );
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void SvxSuperContourDlg::SetPolyPolygon( const PolyPolygon& rPolyPoly )
 {
     DBG_ASSERT(  aContourWnd.GetGraphic().GetType() != GRAPHIC_NONE, "Graphic must've been set first!" );
@@ -576,13 +475,6 @@ void SvxSuperContourDlg::SetPolyPolygon( const PolyPolygon& rPolyPoly )
     aContourWnd.GetSdrModel()->SetChanged( sal_True );
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 PolyPolygon SvxSuperContourDlg::GetPolyPolygon( BOOL bRescaleToGraphic )
 {
     PolyPolygon aRetPolyPoly( aContourWnd.GetPolyPolygon() );
@@ -613,13 +505,6 @@ PolyPolygon SvxSuperContourDlg::GetPolyPolygon( BOOL bRescaleToGraphic )
     return aRetPolyPoly;
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void SvxSuperContourDlg::UpdateGraphic( const Graphic& rGraphic, BOOL _bGraphicLinked,
                                  const PolyPolygon* pPolyPoly, void* pEditingObj )
 {
@@ -635,49 +520,21 @@ void SvxSuperContourDlg::UpdateGraphic( const Graphic& rGraphic, BOOL _bGraphicL
     aUpdateTimer.Start();
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 BOOL SvxSuperContourDlg::IsUndoPossible() const
 {
     return aUndoGraphic.GetType() != GRAPHIC_NONE;
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 BOOL SvxSuperContourDlg::IsRedoPossible() const
 {
     return aRedoGraphic.GetType() != GRAPHIC_NONE;
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void SvxSuperContourDlg::DoAutoCreate()
 {
     aCreateTimer.Start();
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void SvxSuperContourDlg::ReducePoints( const long nTol )
 {
     PolyPolygon aPolyPoly( GetPolyPolygon( FALSE ) );
@@ -717,11 +574,7 @@ void SvxSuperContourDlg::ReducePoints( const long nTol )
 }
 
 
-/*************************************************************************
-|*
-|* Click-Hdl fuer ToolBox
-|*
-\************************************************************************/
+// Click handler for ToolBox
 
 IMPL_LINK( SvxSuperContourDlg, Tbx1ClickHdl, ToolBox*, pTbx )
 {
@@ -857,13 +710,6 @@ IMPL_LINK( SvxSuperContourDlg, Tbx1ClickHdl, ToolBox*, pTbx )
     return 0L;
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 IMPL_LINK( SvxSuperContourDlg, MousePosHdl, ContourWindow*, pWnd )
 {
     String aStr;
@@ -881,12 +727,6 @@ IMPL_LINK( SvxSuperContourDlg, MousePosHdl, ContourWindow*, pWnd )
     return 0L;
 }
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 IMPL_LINK( SvxSuperContourDlg, GraphSizeHdl, ContourWindow*, pWnd )
 {
     String aStr;
@@ -904,12 +744,6 @@ IMPL_LINK( SvxSuperContourDlg, GraphSizeHdl, ContourWindow*, pWnd )
     return 0L;
 }
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 IMPL_LINK( SvxSuperContourDlg, UpdateHdl, Timer*, EMPTYARG )
 {
     aUpdateTimer.Stop();
@@ -936,13 +770,6 @@ IMPL_LINK( SvxSuperContourDlg, UpdateHdl, Timer*, EMPTYARG )
     return 0L;
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 IMPL_LINK( SvxSuperContourDlg, CreateHdl, Timer*, EMPTYARG )
 {
     aCreateTimer.Stop();
@@ -958,13 +785,6 @@ IMPL_LINK( SvxSuperContourDlg, CreateHdl, Timer*, EMPTYARG )
     return 0L;
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 IMPL_LINK( SvxSuperContourDlg, StateHdl, ContourWindow*, pWnd )
 {
     const SdrObject*    pObj = pWnd->GetSelectedSdrObject();
@@ -1023,13 +843,6 @@ IMPL_LINK( SvxSuperContourDlg, StateHdl, ContourWindow*, pWnd )
     return 0L;
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 IMPL_LINK( SvxSuperContourDlg, PipetteHdl, ContourWindow*, pWnd )
 {
     const Color& rOldLineColor = aStbStatus.GetLineColor();
@@ -1054,13 +867,6 @@ IMPL_LINK( SvxSuperContourDlg, PipetteHdl, ContourWindow*, pWnd )
     return 0L;
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 IMPL_LINK( SvxSuperContourDlg, PipetteClickHdl, ContourWindow*, pWnd )
 {
     if ( pWnd->IsClickValid() )
@@ -1108,13 +914,6 @@ IMPL_LINK( SvxSuperContourDlg, PipetteClickHdl, ContourWindow*, pWnd )
     return 0L;
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 IMPL_LINK( SvxSuperContourDlg, WorkplaceClickHdl, ContourWindow*, pWnd )
 {
     aTbx1.CheckItem( TBI_WORKPLACE, FALSE );
@@ -1139,12 +938,6 @@ void SvxSuperContourDlg::DataChanged( const DataChangedEvent& rDCEvt )
             ApplyImageList();
 }
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 IMPL_LINK( SvxSuperContourDlg, MiscHdl, void*, EMPTYARG )
 {
     SvtMiscOptions aMiscOptions;
diff --git a/svx/source/dialog/charmap.cxx b/svx/source/dialog/charmap.cxx
index 66b175b00b6a..bce0b3c779f8 100644
--- a/svx/source/dialog/charmap.cxx
+++ b/svx/source/dialog/charmap.cxx
@@ -760,11 +760,9 @@ void SubsetMap::InitList()
         aAllSubsets.push_back( Subset( 0x02B0, 0x02FF, RID_SUBSETSTR_SPACING_MODIFIERS ) );
         aAllSubsets.push_back( Subset( 0x0300, 0x036F, RID_SUBSETSTR_COMB_DIACRITICAL ) );
         aAllSubsets.push_back( Subset( 0x0370, 0x03FF, RID_SUBSETSTR_BASIC_GREEK ) );
-    //  aAllSubsets.push_back( Subset( 0x03D0, 0x03F3, RID_SUBSETSTR_GREEK_SYMS_COPTIC ) );
         aAllSubsets.push_back( Subset( 0x0400, 0x04FF, RID_SUBSETSTR_CYRILLIC ) );
         aAllSubsets.push_back( Subset( 0x0530, 0x058F, RID_SUBSETSTR_ARMENIAN ) );
         aAllSubsets.push_back( Subset( 0x0590, 0x05FF, RID_SUBSETSTR_BASIC_HEBREW ) );
-    //  aAllSubsets.push_back( Subset( 0x0591, 0x05C4, RID_SUBSETSTR_HEBREW_EXTENDED ) );
         aAllSubsets.push_back( Subset( 0x0600, 0x065F, RID_SUBSETSTR_BASIC_ARABIC ) );
         aAllSubsets.push_back( Subset( 0x0660, 0x06FF, RID_SUBSETSTR_ARABIC_EXTENDED ) );
         aAllSubsets.push_back( Subset( 0x0700, 0x074F, RID_SUBSETSTR_SYRIAC ) );
diff --git a/svx/source/dialog/connctrl.cxx b/svx/source/dialog/connctrl.cxx
index fe90a3030463..0c05dda3d085 100644
--- a/svx/source/dialog/connctrl.cxx
+++ b/svx/source/dialog/connctrl.cxx
@@ -42,19 +42,11 @@
 #include <svx/dialmgr.hxx>
 #include "dlgutil.hxx"
 
-// #110094#
 #include <svx/sdr/contact/objectcontactofobjlistpainter.hxx>
 
-// #110094#
 #include <svx/sdr/contact/displayinfo.hxx>
 #include <vcl/svapp.hxx>
 
-/*************************************************************************
-|*
-|* Ctor SvxXConnectionPreview
-|*
-*************************************************************************/
-
 SvxXConnectionPreview::SvxXConnectionPreview( Window* pParent, const ResId& rResId,
                             const SfxItemSet& rInAttrs ) :
                             Control ( pParent, rResId ),
@@ -67,26 +59,14 @@ SvxXConnectionPreview::SvxXConnectionPreview( Window* pParent, const ResId& rRes
     SetStyles();
 }
 
-/*************************************************************************
-|*
-|* Dtor SvxXConnectionPreview
-|*
-*************************************************************************/
-
 SvxXConnectionPreview::~SvxXConnectionPreview()
 {
     delete pObjList;
 }
 
-/*************************************************************************
-|*
-|* Dtor SvxXConnectionPreview
-|*
-*************************************************************************/
-
 void SvxXConnectionPreview::Construct()
 {
-    DBG_ASSERT( pView, "Keine gueltige View Uebergeben!" );
+    DBG_ASSERT( pView, "No valid view is passed on! ");
 
     const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
     ULONG nMarkCount = rMarkList.GetMarkCount();
@@ -117,7 +97,6 @@ void SvxXConnectionPreview::Construct()
                 SdrObject* pTmpObj1 = pTmpEdgeObj->GetConnectedNode( TRUE );
                 SdrObject* pTmpObj2 = pTmpEdgeObj->GetConnectedNode( FALSE );
 
-                // #110094#
                 // potential memory leak here (!). Create SdrObjList only when there is
                 // not yet one.
                 if(!pObjList)
@@ -145,7 +124,7 @@ void SvxXConnectionPreview::Construct()
     if( !pEdgeObj )
         pEdgeObj = new SdrEdgeObj();
 
-    // Groesse anpassen
+    // Adapt size
     if( pObjList )
     {
         OutputDevice* pOD = pView->GetFirstOutputDevice(); // GetWin( 0 );
@@ -164,7 +143,7 @@ void SvxXConnectionPreview::Construct()
         double          fRectWH = (double) aRect.GetWidth() / aRect.GetHeight();
         double          fWinWH = (double) nWidth / nHeight;
 
-        // Bitmap an Thumbgroesse anpassen (hier nicht!)
+        // Adapt bitmap to Thumb size (not here!)
         if ( fRectWH < fWinWH)
         {
             aNewSize.Width() = (long) ( (double) nHeight * fRectWH );
@@ -180,18 +159,18 @@ void SvxXConnectionPreview::Construct()
         Fraction aFrac2( aWinSize.Height(), aRect.GetHeight() );
         Fraction aMinFrac( aFrac1 <= aFrac2 ? aFrac1 : aFrac2 );
 
-        // MapMode umsetzen
+        // Implement MapMode
         aDisplayMap.SetScaleX( aMinFrac );
         aDisplayMap.SetScaleY( aMinFrac );
 
-        // Zentrierung
+        // Centering
         aNewPos.X() = ( nWidth - aNewSize.Width() )  >> 1;
         aNewPos.Y() = ( nHeight - aNewSize.Height() ) >> 1;
 
         aDisplayMap.SetOrigin( LogicToLogic( aNewPos, aMapMode, aDisplayMap ) );
         SetMapMode( aDisplayMap );
 
-        // Ursprung
+        // Origin
         aNewPos = aDisplayMap.GetOrigin();
         aNewPos -= Point( aRect.TopLeft().X(), aRect.TopLeft().Y() );
         aDisplayMap.SetOrigin( aNewPos );
@@ -201,53 +180,9 @@ void SvxXConnectionPreview::Construct()
         Point aPos;
         MouseEvent aMEvt( aPos, 1, 0, MOUSE_RIGHT );
         MouseButtonDown( aMEvt );
-        /*
-        Point aPt( -aRect.TopLeft().X(), -aRect.TopLeft().Y() );
-        aMapMode.SetOrigin( aPt );
-
-        // Skalierung
-        Size aSize = GetOutputSize();
-        Fraction aFrac1( aSize.Width(), aRect.GetWidth() );
-        Fraction aFrac2( aSize.Height(), aRect.GetHeight() );
-        Fraction aMaxFrac( aFrac1 > aFrac2 ? aFrac1 : aFrac2 );
-        Fraction aMinFrac( aFrac1 <= aFrac2 ? aFrac1 : aFrac2 );
-        BOOL bChange = (BOOL) ( (double)aMinFrac > 1.0 );
-        aMapMode.SetScaleX( aMinFrac );
-        aMapMode.SetScaleY( aMinFrac );
-
-        // zentrieren
-        long nXXL = aSize.Width() > aRect.GetWidth() ? aSize.Width() : aRect.GetWidth();
-        long nXS = aSize.Width() <= aRect.GetWidth() ? aSize.Width() : aRect.GetWidth();
-        if( bChange )
-        {
-            long nTmp = nXXL; nXXL = nXS; nXS = nTmp;
-        }
-        long nX = (long) ( (double)aMinFrac * (double)nXXL );
-        nX = (long) ( (double)labs( nXS - nX ) / (double)aMinFrac / 2.0 );
-
-        long nYXL = aSize.Height() > aRect.GetHeight() ? aSize.Height() : aRect.GetHeight();
-        long nYS = aSize.Height() <= aRect.GetHeight() ? aSize.Height() : aRect.GetHeight();
-        if( bChange )
-        {
-            long nTmp = nXXL; nXXL = nXS; nXS = nTmp;
-        }
-        long nY = (long) ( (double)aMinFrac * (double)nYXL );
-        nY = (long) ( (double)labs( nYS - nY ) / (double)aMinFrac / 2.0 );
-
-        aPt += Point( nX, nY );
-        aMapMode.SetOrigin( aPt );
-
-        SetMapMode( aMapMode );
-        */
     }
 }
 
-/*************************************************************************
-|*
-|* SvxXConnectionPreview: Paint()
-|*
-*************************************************************************/
-
 void SvxXConnectionPreview::Paint( const Rectangle& )
 {
     if( pObjList )
@@ -278,25 +213,15 @@ void SvxXConnectionPreview::Paint( const Rectangle& )
     }
 }
 
-/*************************************************************************
-|*
-|* SvxXConnectionPreview: SetAttributes()
-|*
-*************************************************************************/
-
 void SvxXConnectionPreview::SetAttributes( const SfxItemSet& rInAttrs )
 {
-    //pEdgeObj->SetItemSetAndBroadcast(rInAttrs);
     pEdgeObj->SetMergedItemSetAndBroadcast(rInAttrs);
 
     Invalidate();
 }
 
-/*************************************************************************
-|*
-|* Ermittelt die Anzahl der Linienversaetze anhand des Preview-Objektes
-|*
-*************************************************************************/
+
+// Get number of lines which are offset based on the preview object
 
 USHORT SvxXConnectionPreview::GetLineDeltaAnz()
 {
@@ -309,12 +234,6 @@ USHORT SvxXConnectionPreview::GetLineDeltaAnz()
     return nCount;
 }
 
-/*************************************************************************
-|*
-|* SvxXConnectionPreview: MouseButtonDown()
-|*
-*************************************************************************/
-
 void SvxXConnectionPreview::MouseButtonDown( const MouseEvent& rMEvt )
 {
     BOOL bZoomIn  = rMEvt.IsLeft() && !rMEvt.IsShift();
diff --git a/svx/source/dialog/contdlg.hrc b/svx/source/dialog/contdlg.hrc
index 4aba6fc629cc..612365c2e449 100644
--- a/svx/source/dialog/contdlg.hrc
+++ b/svx/source/dialog/contdlg.hrc
@@ -27,7 +27,7 @@
 #include <svx/dialogs.hrc>
 
 
-// ImapDlg-Dialoge
+// ImapDlg dialog
 #define RID_SVX_CONTOURDLG_START    RID_SVX_CONTOUR_START
 
 
diff --git a/svx/source/dialog/contimp.hxx b/svx/source/dialog/contimp.hxx
index 278b38d61270..99f04e2ac6d9 100644
--- a/svx/source/dialog/contimp.hxx
+++ b/svx/source/dialog/contimp.hxx
@@ -35,12 +35,6 @@
 
 #define CONT_RESID(nId)  ResId( nId, DIALOG_MGR() )
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 class SvxSuperContourDlg : public SvxContourDlg
 {
     using SvxContourDlg::GetPolyPolygon;
diff --git a/svx/source/dialog/contwnd.cxx b/svx/source/dialog/contwnd.cxx
index 46529aadbad0..1f0008e2ba95 100644
--- a/svx/source/dialog/contwnd.cxx
+++ b/svx/source/dialog/contwnd.cxx
@@ -45,12 +45,6 @@
 
 #define TRANSCOL Color( COL_WHITE )
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 ContourWindow::ContourWindow( Window* pParent, const ResId& rResId ) :
             GraphCtrl       ( pParent, rResId ),
             aWorkRect       ( 0, 0, 0, 0 ),
@@ -61,33 +55,18 @@ ContourWindow::ContourWindow( Window* pParent, const ResId& rResId ) :
     SetWinStyle( WB_SDRMODE );
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 ContourWindow::~ContourWindow()
 {
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void ContourWindow::SetPolyPolygon( const PolyPolygon& rPolyPoly )
 {
     SdrPage*        pPage = (SdrPage*) pModel->GetPage( 0 );
     const USHORT    nPolyCount = rPolyPoly.Count();
 
-    // zuerst alle Zeichenobjekte loeschen
+    // First delete all drawing objects
     aPolyPoly = rPolyPoly;
 
-    // #117412#
     // To avoid to have destroyed objects which are still selected, it is necessary to deselect
     // them first (!)
     pView->UnmarkAllObj();
@@ -108,7 +87,6 @@ void ContourWindow::SetPolyPolygon( const PolyPolygon& rPolyPoly )
             aSet.Put( XFillColorItem( String(), TRANSCOL ) );
             aSet.Put( XFillTransparenceItem( 50 ) );
 
-            //pPathObj->SetItemSetAndBroadcast(aSet);
             pPathObj->SetMergedItemSetAndBroadcast(aSet);
 
             pPage->InsertObject( pPathObj );
@@ -124,13 +102,6 @@ void ContourWindow::SetPolyPolygon( const PolyPolygon& rPolyPoly )
     pModel->SetChanged( sal_False );
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 const PolyPolygon& ContourWindow::GetPolyPolygon()
 {
     if ( pModel->IsChanged() )
@@ -154,13 +125,6 @@ const PolyPolygon& ContourWindow::GetPolyPolygon()
     return aPolyPoly;
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void ContourWindow::InitSdrModel()
 {
     GraphCtrl::InitSdrModel();
@@ -173,26 +137,12 @@ void ContourWindow::InitSdrModel()
     pView->SetFrameDragSingles( TRUE );
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void ContourWindow::SdrObjCreated( const SdrObject&  )
 {
     pView->MarkAll();
     pView->CombineMarkedObjects( sal_False );
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 BOOL ContourWindow::IsContourChanged() const
 {
     SdrPage*    pPage = (SdrPage*) pModel->GetPage( 0 );
@@ -204,13 +154,6 @@ BOOL ContourWindow::IsContourChanged() const
     return bRet;
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void ContourWindow::MouseButtonDown( const MouseEvent& rMEvt )
 {
     if ( bWorkplaceMode )
@@ -227,13 +170,6 @@ void ContourWindow::MouseButtonDown( const MouseEvent& rMEvt )
         GraphCtrl::MouseButtonDown( rMEvt );
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void ContourWindow::MouseMove( const MouseEvent& rMEvt )
 {
     bClickValid = FALSE;
@@ -255,13 +191,6 @@ void ContourWindow::MouseMove( const MouseEvent& rMEvt )
         GraphCtrl::MouseMove( rMEvt );
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void ContourWindow::MouseButtonUp(const MouseEvent& rMEvt)
 {
     Point aTmpPoint;
@@ -307,13 +236,6 @@ void ContourWindow::MouseButtonUp(const MouseEvent& rMEvt)
         GraphCtrl::MouseButtonUp( rMEvt );
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void ContourWindow::Paint( const Rectangle& rRect )
 {
     // #i75482#
diff --git a/svx/source/dialog/contwnd.hxx b/svx/source/dialog/contwnd.hxx
index 022349451f2c..32159a301a42 100644
--- a/svx/source/dialog/contwnd.hxx
+++ b/svx/source/dialog/contwnd.hxx
@@ -32,12 +32,6 @@
 #include <tools/poly.hxx>
 #include <svx/graphctl.hxx>
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 class ContourWindow : public GraphCtrl
 {
     PolyPolygon         aPolyPoly;
diff --git a/svx/source/dialog/ctredlin.cxx b/svx/source/dialog/ctredlin.cxx
index 12d164d7309d..6b6c2ec6159e 100644
--- a/svx/source/dialog/ctredlin.cxx
+++ b/svx/source/dialog/ctredlin.cxx
@@ -76,7 +76,7 @@ RedlinData::~RedlinData()
 }
 
 //============================================================================
-//  class SvxRedlinEntry (Eintraege fuer Liste)
+//  class SvxRedlinEntry (Entries for list)
 //----------------------------------------------------------------------------
 
 SvxRedlinEntry::SvxRedlinEntry()
@@ -93,26 +93,10 @@ SvxRedlinEntry::~SvxRedlinEntry()
     }
 }
 
-/*************************************************************************
-#* Funktionen der in den SvxRedlinTable eingefuegten Items
-#************************************************************************/
+// Functions in the inserts Items of SvxRedlinTable
 
 DBG_NAME(SvLBoxColorString);
 
-/*************************************************************************
-#*  Member:     SvLBoxColorString                           Datum:23.10.97
-#*------------------------------------------------------------------------
-#*
-#*  Klasse:     SvLBoxColorString
-#*
-#*  Funktion:   Konstruktor der Klasse SvLBoxColorString
-#*
-#*  Input:      Box- Entry,Flags, Text fuer Anzeige, Schrift
-#*
-#*  Output:     ---
-#*
-#************************************************************************/
-
 SvLBoxColorString::SvLBoxColorString( SvLBoxEntry*pEntry,USHORT nFlags,const XubString& rStr,
                                     const Color& rCol)
 
@@ -123,87 +107,31 @@ SvLBoxColorString::SvLBoxColorString( SvLBoxEntry*pEntry,USHORT nFlags,const Xub
     SetText( pEntry, rStr );
 }
 
-/*************************************************************************
-#*  Member:     SvLBoxColorString                           Datum:23.10.97
-#*------------------------------------------------------------------------
-#*
-#*  Klasse:     SvLBoxColorString
-#*
-#*  Funktion:   Default Konstruktor der Klasse SvLBoxColorString
-#*
-#*  Input:      ---
-#*
-#*  Output:     ---
-#*
-#************************************************************************/
-
 SvLBoxColorString::SvLBoxColorString()
 : SvLBoxString()
 {
     DBG_CTOR(SvLBoxColorString,0);
 }
 
-/*************************************************************************
-#*  Member:     ~SvLBoxColorString                          Datum:23.10.97
-#*------------------------------------------------------------------------
-#*
-#*  Klasse:     SvLBoxColorString
-#*
-#*  Funktion:   Destruktor der Klasse SvLBoxColorString
-#*
-#*  Input:      ---
-#*
-#*  Output:     ---
-#*
-#************************************************************************/
-
 SvLBoxColorString::~SvLBoxColorString()
 {
     DBG_DTOR(SvLBoxColorString,0);
 }
 
-
-/*************************************************************************
-#*  Member:     SvLBoxColorString                           Datum:23.10.97
-#*------------------------------------------------------------------------
-#*
-#*  Klasse:     SvLBoxColorString
-#*
-#*  Funktion:   Erzeugt einen neuen SvLBoxColorString
-#*
-#*  Input:      ---
-#*
-#*  Output:     SvLBoxColorString
-#*
-#************************************************************************/
-
 SvLBoxItem* SvLBoxColorString::Create() const
 {
     DBG_CHKTHIS(SvLBoxColorString,0);
     return new SvLBoxColorString;
 }
 
-
-
-/*************************************************************************
-#*  Member:     SvLBoxColorString                           Datum:23.10.97
-#*------------------------------------------------------------------------
-#*
-#*  Klasse:     SvLBoxColorString
-#*
-#*  Funktion:   Zeichenroutine des SvLBoxColorString. Gezeichnet wird
-#*              der entsprechende Text mit der eingestellten Farbe
-#*              im Ausgabe- Device.
-#*
-#*  Input:      Position, Ausgabe- Device, Flag fuer Selection,
-#*              Zeiger auf den Eintrag
-#*
-#*  Output:     ---
-#*
-#************************************************************************/
-
 void SvLBoxColorString::Paint( const Point& rPos, SvLBox& rDev,
                              USHORT nFlags, SvLBoxEntry* pEntry )
+/* [Description]
+
+   Paint function of the SvLBoxColorString class. The relevant text with the
+   selected color is drawn in the output device.
+*/
+
 {
     Color aColor=rDev.GetTextColor();
     Color a2Color=aColor;
@@ -597,7 +525,6 @@ void SvxRedlinTable::InitEntry( SvLBoxEntry* pEntry, const XubString& rStr,
     for( USHORT nToken = 0; nToken < nCount; nToken++ )
     {
         if( pCurToken && nCurTokenLen )
-            // aToken.Assign( pCurToken, nCurTokenLen );
             aToken = XubString( pCurToken, nCurTokenLen );
         else
             aToken.Erase();
@@ -628,7 +555,7 @@ SvxTPView::SvxTPView( Window * pParent)
     PbAcceptAll ( this, SVX_RES(PB_ACCEPTALL  ) ),
     PbRejectAll ( this, SVX_RES(PB_REJECTALL  ) ),
     PbUndo      ( this, SVX_RES(PB_UNDO  ) ),
-    aTitle1     ( SVX_RES( STR_TITLE1 ) ),      // lokale Resource
+    aTitle1     ( SVX_RES( STR_TITLE1 ) ),      // local resource
     aTitle2     ( SVX_RES( STR_TITLE2 ) ),
     aTitle3     ( SVX_RES( STR_TITLE3 ) ),
     aTitle4     ( SVX_RES( STR_TITLE4 ) ),
diff --git a/svx/source/dialog/ctredlin.hrc b/svx/source/dialog/ctredlin.hrc
index ef4db94e21c0..6bc98ee702b0 100644
--- a/svx/source/dialog/ctredlin.hrc
+++ b/svx/source/dialog/ctredlin.hrc
@@ -65,4 +65,3 @@
 #define STR_TITLE3      3
 #define STR_TITLE4      4
 #define STR_TITLE5      5
-//
diff --git a/svx/source/dialog/dialcontrol.cxx b/svx/source/dialog/dialcontrol.cxx
index 4324b2fed9e4..522da52ed282 100644
--- a/svx/source/dialog/dialcontrol.cxx
+++ b/svx/source/dialog/dialcontrol.cxx
@@ -186,7 +186,7 @@ void DialControlBmp::DrawBackground()
     SetFillColor();
     Erase();
 
-    EnableRTL( TRUE ); // #107807# draw 3D effect in correct direction
+    EnableRTL( TRUE ); // draw 3D effect in correct direction
 
     sal_uInt8 nDiff = mbEnabled ? 0x18 : 0x10;
     Color aColor;
@@ -456,7 +456,7 @@ const Link& DialControl::GetModifyHdl() const
 void DialControl::Init( const Size& rWinSize, const Font& rWinFont )
 {
     mpImpl->Init( rWinSize, rWinFont );
-    EnableRTL( FALSE ); // #107807# don't mirror mouse handling
+    EnableRTL( FALSE ); // don't mirror mouse handling
     SetOutputSizePixel( mpImpl->maWinSize );
     SetBackground();
 }
diff --git a/svx/source/dialog/dlgctl3d.cxx b/svx/source/dialog/dlgctl3d.cxx
index 63e87b5cbfa1..d866c1065789 100644
--- a/svx/source/dialog/dlgctl3d.cxx
+++ b/svx/source/dialog/dlgctl3d.cxx
@@ -412,7 +412,7 @@ void Svx3DLightControl::ConstructLightObjects()
 {
     for(sal_uInt32 a(0); a < MAX_NUMBER_LIGHTS; a++)
     {
-        // get rid of evtl. existing light object
+        // get rid of possible existing light object
         if(maLightObjects[a])
         {
             mpScene->Remove3DObj(maLightObjects[a]);
@@ -587,8 +587,7 @@ void Svx3DLightControl::MouseButtonDown( const MouseEvent& rMEvt )
         }
         else
         {
-            // Einfacher Click ohne viel Bewegen, versuche eine
-            // Selektion
+            // Single click without moving much trying to do a selection
             TrySelection(rMEvt.GetPosPixel());
             bCallParent = false;
         }
diff --git a/svx/source/dialog/dlgctrl.cxx b/svx/source/dialog/dlgctrl.cxx
index 1e4ff0cdbf01..a0dd46c14748 100644
--- a/svx/source/dialog/dlgctrl.cxx
+++ b/svx/source/dialog/dlgctrl.cxx
@@ -65,13 +65,8 @@ using namespace ::com::sun::star::uno;
 using namespace ::com::sun::star::lang;
 using namespace ::com::sun::star::accessibility;
 
-
-/*************************************************************************
-|*
-|*  Control zur Darstellung und Auswahl der Eckpunkte (und Mittelpunkt)
-|*  eines Objekts
-|*
-\************************************************************************/
+// Control fo display and selection of the corner points and mid point of an
+// object
 
 Bitmap& SvxRectCtl::GetRectBitmap( void )
 {
@@ -237,16 +232,11 @@ void SvxRectCtl::InitSettings( BOOL bForeground, BOOL bBackground )
     Invalidate();
 }
 
-/*************************************************************************
-|*
-|*  Das angeklickte Rechteck (3 x 3) wird ermittelt und der Parent (Dialog)
-|*  wird benachrichtigt, dass der Punkt geaendert wurde
-|*
-\************************************************************************/
-
+// The clicked rectangle (3 x 3) is determined and the parent (dialog)
+// is notified that the item was changed
 void SvxRectCtl::MouseButtonDown( const MouseEvent& rMEvt )
 {
-    // #103516# CompletelyDisabled() added to have a disabled state for SvxRectCtl
+    // CompletelyDisabled() added to have a disabled state for SvxRectCtl
     if(!IsCompletelyDisabled())
     {
         Point aPtLast = aPtNew;
@@ -277,7 +267,7 @@ void SvxRectCtl::MouseButtonDown( const MouseEvent& rMEvt )
 
 void SvxRectCtl::KeyInput( const KeyEvent& rKeyEvt )
 {
-    // #103516# CompletelyDisabled() added to have a disabled state for SvxRectCtl
+    // CompletelyDisabled() added to have a disabled state for SvxRectCtl
     if(!IsCompletelyDisabled())
     {
         RECT_POINT eNewRP = eRP;
@@ -383,11 +373,7 @@ void SvxRectCtl::DataChanged( const DataChangedEvent& rDCEvt )
         Window::DataChanged( rDCEvt );
 }
 
-/*************************************************************************
-|*
-|*  Zeichnet das Control (Rechteck mit 9 Kreisen)
-|*
-\************************************************************************/
+// the control (rectangle with 9 circles)
 
 void SvxRectCtl::Paint( const Rectangle& )
 {
@@ -468,7 +454,7 @@ void SvxRectCtl::Paint( const Rectangle& )
 
     Bitmap&         rBitmap = GetRectBitmap();
 
-    // #103516# CompletelyDisabled() added to have a disabled state for SvxRectCtl
+    // CompletelyDisabled() added to have a disabled state for SvxRectCtl
     if(IsCompletelyDisabled())
     {
         DrawBitmap( aPtLT - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap );
@@ -490,7 +476,7 @@ void SvxRectCtl::Paint( const Rectangle& )
 
         DrawBitmap( aPtLM - aToCenter, aDstBtnSize, bNoHorz?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap );
 
-        // Mittelpunkt bei Rechteck und Linie
+        // Center for rectangle and line
         if( eCS == CS_RECT || eCS == CS_LINE )
             DrawBitmap( aPtMM - aToCenter, aDstBtnSize, aBtnPnt1, aBtnSize, rBitmap );
 
@@ -502,7 +488,7 @@ void SvxRectCtl::Paint( const Rectangle& )
     }
 
     // draw active button, avoid center pos for angle
-    // #103516# CompletelyDisabled() added to have a disabled state for SvxRectCtl
+    // CompletelyDisabled() added to have a disabled state for SvxRectCtl
     if(!IsCompletelyDisabled())
     {
         if( IsEnabled() && (eCS != CS_ANGLE || aPtNew != aPtMM) )
@@ -515,9 +501,7 @@ void SvxRectCtl::Paint( const Rectangle& )
     }
 }
 
-/*************************************************************************
-|*
-|*  Konvertiert RECT_POINT in Point
+// Convert RECT_POINT Point
 |*
 \************************************************************************/
 
@@ -614,11 +598,7 @@ Point SvxRectCtl::GetApproxLogPtFromPixPt( const Point& rPt ) const
 }
 
 
-/*************************************************************************
-|*
-|*  Konvertiert Point in RECT_POINT
-|*
-\************************************************************************/
+// Converts Point in RECT_POINT
 
 RECT_POINT SvxRectCtl::GetRPFromPoint( Point aPt ) const
 {
@@ -635,11 +615,7 @@ RECT_POINT SvxRectCtl::GetRPFromPoint( Point aPt ) const
         return RP_MM; // default
 }
 
-/*************************************************************************
-|*
-|*  Bewirkt den Ursprungszustand des Controls
-|*
-\************************************************************************/
+// Resets to the original state of the control
 
 void SvxRectCtl::Reset()
 {
@@ -648,23 +624,13 @@ void SvxRectCtl::Reset()
     Invalidate();
 }
 
-/*************************************************************************
-|*
-|*  Gibt den aktuell ausgewaehlten RECT_POINT zur�ck
-|*
-\************************************************************************/
+// Returns the currently selected RECT_POINT
 
 RECT_POINT SvxRectCtl::GetActualRP() const
 {
     return( eRP );
 }
 
-/*************************************************************************
-|*
-|*  Gibt den aktuell ausgewaehlten RECT_POINT zur�ck
-|*
-\************************************************************************/
-
 void SvxRectCtl::SetActualRP( RECT_POINT eNewRP )
 {
     Point aPtLast( SetActualRPWithoutInvalidate( eNewRP ) );
@@ -753,18 +719,14 @@ RECT_POINT SvxRectCtl::GetApproxRPFromPixPt( const ::com::sun::star::awt::Point&
     return GetRPFromPoint( GetApproxLogPtFromPixPt( Point( r.X, r.Y ) ) );
 }
 
-// #103516# CompletelyDisabled() added to have a disabled state for SvxRectCtl
+// CompletelyDisabled() added to have a disabled state for SvxRectCtl
 void SvxRectCtl::DoCompletelyDisable(sal_Bool bNew)
 {
     mbCompleteDisable = bNew;
     Invalidate();
 }
 
-/*************************************************************************
-|*
-|* Konstruktor ohne Size-Parameter
-|*
-\************************************************************************/
+// Constructor without the size parameter
 
 SvxAngleCtl::SvxAngleCtl( Window* pParent, const ResId& rResId ) :
 
@@ -776,11 +738,7 @@ SvxAngleCtl::SvxAngleCtl( Window* pParent, const ResId& rResId ) :
     Initialize();
 }
 
-/*************************************************************************
-|*
-|* Konstruktor mit Size-Parameter
-|*
-\************************************************************************/
+// Constructor with the size parameter
 
 SvxAngleCtl::SvxAngleCtl( Window* pParent, const ResId& rResId, Size _aSize ) :
 
@@ -792,17 +750,10 @@ SvxAngleCtl::SvxAngleCtl( Window* pParent, const ResId& rResId, Size _aSize ) :
     Initialize();
 }
 
-/*************************************************************************
-|*
-|* Initialisierung
-|*
-\************************************************************************/
-
 void SvxAngleCtl::Initialize()
 {
     bPositive = TRUE;
 
-    // aFont.SetName( "Helvetica" );
     aFont.SetSize( aFontSize );
     aFont.SetWeight( WEIGHT_NORMAL );
     aFont.SetTransparent( FALSE );
@@ -810,11 +761,7 @@ void SvxAngleCtl::Initialize()
     SetFont( aFont );
 }
 
-/*************************************************************************
-|*
-|*  Zeichnet das (Mini-)Koordinatensystem
-|*
-\************************************************************************/
+// Draws the (mini) coordinate system
 
 void SvxAngleCtl::Paint( const Rectangle& )
 {
@@ -866,18 +813,13 @@ void SvxAngleCtl::Paint( const Rectangle& )
                                  RTL_CONSTASCII_STRINGPARAM( "-45" ) ) );
 }
 
-/*************************************************************************
-|*
-|*  Control zum Editieren von Bitmaps
-|*
-\************************************************************************/
+// Control for editing bitmaps
 
 SvxPixelCtl::SvxPixelCtl( Window* pParent, const ResId& rResId, USHORT nNumber ) :
                         Control     ( pParent, rResId ),
                         nLines      ( nNumber ),
                         bPaintable  ( TRUE )
 {
-    // SetMapMode( MAP_100TH_MM );
     aRectSize = GetOutputSize();
 
     SetPixelColor( Color( COL_BLACK ) );
@@ -889,36 +831,24 @@ SvxPixelCtl::SvxPixelCtl( Window* pParent, const ResId& rResId, USHORT nNumber )
     rtl_zeroMemory(pPixel, nSquares * sizeof(USHORT));
 }
 
-/*************************************************************************
-|*
-|*  Destruktor dealociert dyn. Array
-|*
-\************************************************************************/
+// Destructor dealocating the dynamic array
 
 SvxPixelCtl::~SvxPixelCtl( )
 {
     delete []pPixel;
 }
 
-/*************************************************************************
-|*
-|*  Wechselt die Vordergrund- ,bzw. Hintergrundfarbe
-|*
-\************************************************************************/
+// Changes the foreground or Background color
 
 void SvxPixelCtl::ChangePixel( USHORT nPixel )
 {
     if( *( pPixel + nPixel) == 0 )
-        *( pPixel + nPixel) = 1; // koennte erweitert werden auf mehrere Farben
+        *( pPixel + nPixel) = 1; //  could be extended to more colors
     else
         *( pPixel + nPixel) = 0;
 }
 
-/*************************************************************************
-|*
-|*  Das angeklickte Rechteck wird ermittelt um die Farbe zu wechseln
-|*
-\************************************************************************/
+// The clicked rectangle is identified, to change its color
 
 void SvxPixelCtl::MouseButtonDown( const MouseEvent& rMEvt )
 {
@@ -939,14 +869,10 @@ void SvxPixelCtl::MouseButtonDown( const MouseEvent& rMEvt )
     Invalidate( Rectangle( aPtTl, aPtBr ) );
 
     if( WINDOW_TABPAGE == GetParent()->GetType() )
-        ( (SvxTabPage*) GetParent() )->PointChanged( this, RP_MM ); // RectPoint ist dummy
+        ( (SvxTabPage*) GetParent() )->PointChanged( this, RP_MM ); // RectPoint is a dummy
 }
 
-/*************************************************************************
-|*
-|*  Zeichnet das Control (Rechteck mit 9 Kreisen)
-|*
-\************************************************************************/
+// Draws the Control (Rectangle with nine circles)
 
 void SvxPixelCtl::Paint( const Rectangle& )
 {
@@ -955,19 +881,19 @@ void SvxPixelCtl::Paint( const Rectangle& )
 
     if( bPaintable )
     {
-        // Linien Zeichnen
+        // Draw lines
         Control::SetLineColor( aLineColor );
         for( i = 1; i < nLines; i++)
         {
             // horizontal
             nTmp = (USHORT) ( aRectSize.Height() * i / nLines );
             DrawLine( Point( 0, nTmp ), Point( aRectSize.Width(), nTmp ) );
-            // vertikal
+            // vertically
             nTmp = (USHORT) ( aRectSize.Width() * i / nLines );
             DrawLine( Point( nTmp, 0 ), Point( nTmp, aRectSize.Height() ) );
         }
 
-        // Rechtecke (Quadrate) zeichnen
+        //Draw Rectangles (squares)
         Control::SetLineColor();
         USHORT nLastPixel = *pPixel ? 0 : 1;
 
@@ -984,7 +910,7 @@ void SvxPixelCtl::Paint( const Rectangle& )
                 if ( *( pPixel + i * nLines + j ) != nLastPixel )
                 {
                     nLastPixel = *( pPixel + i * nLines + j );
-                    // Farbe wechseln: 0 -> Hintergrundfarbe
+                    // Change color: 0 -> Background color
                     SetFillColor( nLastPixel ? aPixelColor : aBackgroundColor );
                 }
                 DrawRect( Rectangle( aPtTl, aPtBr ) );
@@ -1000,12 +926,6 @@ void SvxPixelCtl::Paint( const Rectangle& )
     }
 }
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void SvxPixelCtl::SetXBitmap( const XOBitmap& rXBmp )
 {
     if( rXBmp.GetBitmapType() == XBITMAP_8X8 )
@@ -1020,22 +940,14 @@ void SvxPixelCtl::SetXBitmap( const XOBitmap& rXBmp )
     }
 }
 
-/*************************************************************************
-|*
-|*  Gibt ein bestimmtes Pixel zurueck
-|*
-\************************************************************************/
+// Returns a specific pixel
 
 USHORT SvxPixelCtl::GetBitmapPixel( const USHORT nPixel )
 {
     return( *( pPixel + nPixel ) );
 }
 
-/*************************************************************************
-|*
-|*  Bewirkt den Ursprungszustand des Controls
-|*
-\************************************************************************/
+// Resets to the original state of the control
 
 void SvxPixelCtl::Reset()
 {
@@ -1044,33 +956,18 @@ void SvxPixelCtl::Reset()
     Invalidate();
 }
 
-/*************************************************************************
-|*
-|*  Ctor: BitmapCtl fuer SvxPixelCtl
-|*
-\************************************************************************/
+// Constructor: BitmapCtl for SvxPixelCtl
 
 SvxBitmapCtl::SvxBitmapCtl( Window* /*pParent*/, const Size& rSize )
 {
     aSize = rSize;
-    // aVD.SetOutputSizePixel( aSize );
 }
 
-/*************************************************************************
-|*
-|*  Dtor
-|*
-\************************************************************************/
-
 SvxBitmapCtl::~SvxBitmapCtl()
 {
 }
 
-/*************************************************************************
-|*
-|*  BitmapCtl:  Gibt die Bitmap zurueck
-|*
-\************************************************************************/
+// BitmapCtl: Returns the Bitmap
 
 XOBitmap SvxBitmapCtl::GetXBitmap()
 {
@@ -1079,11 +976,7 @@ XOBitmap SvxBitmapCtl::GetXBitmap()
     return( aXOBitmap );
 }
 
-/*************************************************************************
-|*
-|*  Fuellt die Listbox mit Farben und Strings
-|*
-\************************************************************************/
+// Fills the Listbox with color and strings
 
 void ColorLB::Fill( const XColorTable* pColorTab )
 {
@@ -1114,11 +1007,7 @@ void ColorLB::Modify( XColorEntry* pEntry, USHORT nPos, Bitmap*  )
     InsertEntry( pEntry->GetColor(), pEntry->GetName(), nPos );
 }
 
-/*************************************************************************
-|*
-|*  Fuellt die Listbox mit Farben und Strings
-|*
-\************************************************************************/
+// Fills the Listbox with color and strings
 
 void FillAttrLB::Fill( const XColorTable* pColorTab )
 {
@@ -1134,11 +1023,7 @@ void FillAttrLB::Fill( const XColorTable* pColorTab )
     SetUpdateMode( TRUE );
 }
 
-/*************************************************************************
-|*
-|*  Fuellt die Listbox (vorlaeufig) mit Strings
-|*
-\************************************************************************/
+// Fills the listbox (provisional) with strings
 
 HatchingLB::HatchingLB( Window* pParent, ResId Id, BOOL bUserDraw /*= TRUE*/ )
 : ListBox( pParent, Id ),
@@ -1269,11 +1154,7 @@ void HatchingLB::SelectEntryByList( const XHatchList* pList, const String& rStr,
         SelectEntryPos( (USHORT) ( i - 1 + nDist ) );
 }
 
-/*************************************************************************
-|*
-|*  Fuellt die Listbox (vorlaeufig) mit Strings
-|*
-\************************************************************************/
+// Fills the listbox (provisional) with strings
 
 void FillAttrLB::Fill( const XHatchList* pList )
 {
@@ -1293,11 +1174,7 @@ void FillAttrLB::Fill( const XHatchList* pList )
     ListBox::SetUpdateMode( TRUE );
 }
 
-/*************************************************************************
-|*
-|*  Fuellt die Listbox (vorlaeufig) mit Strings
-|*
-\************************************************************************/
+// Fills the listbox (provisional) with strings
 
 GradientLB::GradientLB( Window* pParent, ResId Id, BOOL bUserDraw /*= TRUE*/ )
 : ListBox( pParent, Id ),
@@ -1441,11 +1318,7 @@ void GradientLB::SelectEntryByList( const XGradientList* pList, const String& rS
         SelectEntryPos( (USHORT) ( i - 1 + nDist ) );
 }
 
-/*************************************************************************
-|*
-|*  Fuellt die Listbox (vorlaeufig) mit Strings
-|*
-\************************************************************************/
+// Fills the listbox (provisional) with strings
 
 void FillAttrLB::Fill( const XGradientList* pList )
 {
@@ -1465,11 +1338,7 @@ void FillAttrLB::Fill( const XGradientList* pList )
     ListBox::SetUpdateMode( TRUE );
 }
 
-/*************************************************************************
-|*
-|*  Konstruktor von BitmapLB
-|*
-\************************************************************************/
+// BitmapLB Constructor
 
 BitmapLB::BitmapLB( Window* pParent, ResId Id, BOOL bUserDraw /*= TRUE*/ )
 : ListBox( pParent, Id ),
@@ -1625,7 +1494,6 @@ void BitmapLB::SelectEntryByList( const XBitmapList* pList, const String& rStr,
         pEntry = pList->GetBitmap( i );
 
         String aStr = pEntry->GetName();
-        // Bitmap aBmp = pEntry->GetBitmap();
 
         if( rStr == aStr )
         {
@@ -1636,11 +1504,7 @@ void BitmapLB::SelectEntryByList( const XBitmapList* pList, const String& rStr,
         SelectEntryPos( (USHORT) ( i - 1 ) );
 }
 
-/*************************************************************************
-|*
-|*  Konstruktor von FillAttrLB
-|*
-\************************************************************************/
+// FillAttrLB Constructor
 
 FillAttrLB::FillAttrLB( Window* pParent, ResId Id ) :
                     ColorListBox( pParent, Id )
@@ -1713,25 +1577,17 @@ void FillAttrLB::SelectEntryByList( const XBitmapList* pList, const String& rStr
         pEntry = pList->GetBitmap( i );
 
         String aStr = pEntry->GetName();
-        // Bitmap aBmp = pEntry->GetBitmap();
 
         if( rStr == aStr )
         {
             bFound = TRUE;
         }
-        /*
-        if( rStr == aStr && rBmp == aBmp )
-            bFound = TRUE; */
     }
     if( bFound )
         SelectEntryPos( (USHORT) ( i - 1 ) );
 }
 
-/*************************************************************************
-|*
-|*  Fuellt die Listbox (vorlaeufig) mit Strings
-|*
-\************************************************************************/
+// Fills the listbox (provisional) with strings
 
 void FillTypeLB::Fill()
 {
@@ -1744,11 +1600,7 @@ void FillTypeLB::Fill()
     SetUpdateMode( TRUE );
 }
 
-/*************************************************************************
-|*
-|*  Fuellt die Listbox (vorlaeufig) mit Strings
-|*
-\************************************************************************/
+// Fills the listbox (provisional) with strings
 
 void LineLB::Fill( const XDashList* pList )
 {
@@ -1775,7 +1627,7 @@ void LineLB::FillStyles()
 {
     ResMgr& rMgr = DIALOG_MGR();
 
-    // Linienstile
+    // Line Styles
     Clear();
     InsertEntry( String( ResId( RID_SVXSTR_INVISIBLE, rMgr ) ) );
 
@@ -1843,11 +1695,7 @@ void LineLB::SelectEntryByList( const XDashList* pList, const String& rStr,
         SelectEntryPos( (USHORT) ( i - 1 + nDist ) );
 }
 
-/*************************************************************************
-|*
-|*  Fuellt die Listbox (vorlaeufig) mit Strings
-|*
-\************************************************************************/
+// Fills the listbox (provisional) with strings
 
 void LineEndLB::Fill( const XLineEndList* pList, BOOL bStart )
 {
@@ -2039,12 +1887,6 @@ void SvxPreviewBase::DataChanged(const DataChangedEvent& rDCEvt)
     }
 }
 
-/*************************************************************************
-|*
-|*    SvxXLinePreview::SvxXLinePreview()
-|*
-*************************************************************************/
-
 SvxXLinePreview::SvxXLinePreview( Window* pParent, const ResId& rResId )
 :   SvxPreviewBase( pParent, rResId ),
     mpLineObjA( 0L ),
@@ -2166,12 +2008,6 @@ void SvxXLinePreview::Paint( const Rectangle& )
     LocalPostPaint();
 }
 
-/*************************************************************************
-|*
-|*    SvxXRectPreview::SvxXRectPreview()
-|*
-*************************************************************************/
-
 SvxXRectPreview::SvxXRectPreview( Window* pParent, const ResId& rResId )
 :   SvxPreviewBase( pParent, rResId ),
     mpRectangleObject(0)
@@ -2211,12 +2047,6 @@ void SvxXRectPreview::Paint( const Rectangle& )
     LocalPostPaint();
 }
 
-/*************************************************************************
-|*
-|*    SvxXShadowPreview::SvxXShadowPreview()
-|*
-*************************************************************************/
-
 SvxXShadowPreview::SvxXShadowPreview( Window* pParent, const ResId& rResId )
 :   SvxPreviewBase( pParent, rResId ),
     mpRectangleObject(0),
diff --git a/svx/source/dialog/dlgutil.cxx b/svx/source/dialog/dlgutil.cxx
index d26716d6de78..bf28925bb2ee 100644
--- a/svx/source/dialog/dlgutil.cxx
+++ b/svx/source/dialog/dlgutil.cxx
@@ -70,7 +70,7 @@ BOOL GetApplyCharUnit( const SfxItemSet& rSet )
         SfxObjectShell* pSh = NULL;
         if ( pFrame )
             pSh = pFrame->GetObjectShell();
-        if ( pSh )  // #93209# the object shell is not always available during reload
+        if ( pSh )  // the object shell is not always available during reload
         {
             SfxModule* pModule = pSh->GetModule();
             if ( pModule )
diff --git a/svx/source/dialog/docrecovery.cxx b/svx/source/dialog/docrecovery.cxx
index 26ba61659cd9..c4ade753b7c2 100644
--- a/svx/source/dialog/docrecovery.cxx
+++ b/svx/source/dialog/docrecovery.cxx
@@ -1737,12 +1737,6 @@ void BrokenRecoveryDialog::impl_askForSavePath()
 
             ReadParams();
 
-            /*
-            maDocTypeED.SetText( maParams.maSubject );
-            maUsingML.SetText( maParams.maBody );
-            maContactCB.Check( maParams.mbAllowContact );
-            maEMailAddrED.SetText( maParams.maReturnAddress );
-            */
             ContactCBHdl( 0 );
         }
 
@@ -2044,26 +2038,6 @@ void BrokenRecoveryDialog::impl_askForSavePath()
 #define PRVFILE ".crash_report_preview"
 #endif
 
-//      static ::rtl::OUString GetChecksumURL()
-//      {
-//          ::rtl::OUString aURL = GetCrashConfigDir();
-
-//          aURL += ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "/" ) );
-//          aURL += ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( CHKFILE ) );
-
-//          return aURL;
-//      }
-
-//      static ::rtl::OUString GetStackURL()
-//      {
-//          ::rtl::OUString aURL = GetCrashConfigDir();
-
-//          aURL += ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "/" ) );
-//          aURL += ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( STKFILE ) );
-
-//          return aURL;
-//      }
-
         static ::rtl::OUString GetPreviewURL()
         {
             ::rtl::OUString aURL = GetCrashConfigDir();
diff --git a/svx/source/dialog/fontlb.cxx b/svx/source/dialog/fontlb.cxx
index 10eda3e83257..f3e080dc7475 100644
--- a/svx/source/dialog/fontlb.cxx
+++ b/svx/source/dialog/fontlb.cxx
@@ -72,7 +72,6 @@ void SvLBoxFontString::Paint( const Point& rPos, SvLBox& rDev, sal_uInt16 nFlags
     Font aOldFont( rDev.GetFont() );
     Font aNewFont( maFont );
     bool bSel = (nFlags & SVLISTENTRYFLAG_SELECTED) != 0;
-//  if( !mbUseColor )               // selection gets font color, if available
     if( !mbUseColor || bSel )       // selection always gets highlight color
     {
         const StyleSettings& rSett = Application::GetSettings().GetStyleSettings();
@@ -177,11 +176,6 @@ SvxFontListBox::SvxFontListBox( Context* pParent, const char* pFile)
 {
 }
 
-/*IMPL_IMPL (SvxFontListBox, ListBox);
-IMPL_CONSTRUCTORS (SvxFontListBox, ListBox, "svxfontlistbox");
-IMPL_GET_IMPL (SvxFontListBox);
-IMPL_GET_WINDOW (SvxFontListBox);*/
-
 };
 
 #endif
diff --git a/svx/source/dialog/fontwork.cxx b/svx/source/dialog/fontwork.cxx
index f39809572213..ef7677ca65da 100644
--- a/svx/source/dialog/fontwork.cxx
+++ b/svx/source/dialog/fontwork.cxx
@@ -53,11 +53,7 @@
 
 SFX_IMPL_DOCKINGWINDOW( SvxFontWorkChildWindow, SID_FONTWORK );
 
-/*************************************************************************
-|*
-|* ControllerItem fuer Fontwork
-|*
-\************************************************************************/
+// ControllerItem for Fontwork
 
 SvxFontWorkControllerItem::SvxFontWorkControllerItem
 (
@@ -72,11 +68,7 @@ SvxFontWorkControllerItem::SvxFontWorkControllerItem
 {
 }
 
-/*************************************************************************
-|*
-|* StateChanged-Methode fuer FontWork-Items
-|*
-\************************************************************************/
+// StateChanged method for FontWork items
 
 void SvxFontWorkControllerItem::StateChanged( USHORT /*nSID*/, SfxItemState /*eState*/,
                                               const SfxPoolItem* pItem )
@@ -87,7 +79,7 @@ void SvxFontWorkControllerItem::StateChanged( USHORT /*nSID*/, SfxItemState /*eS
         {
             const XFormTextStyleItem* pStateItem =
                                 PTR_CAST(XFormTextStyleItem, pItem);
-            DBG_ASSERT(pStateItem || pItem == 0, "XFormTextStyleItem erwartet");
+            DBG_ASSERT(pStateItem || pItem == 0, "XFormTextStyleItem expected");
             rFontWorkDlg.SetStyle_Impl(pStateItem);
             break;
         }
@@ -95,7 +87,7 @@ void SvxFontWorkControllerItem::StateChanged( USHORT /*nSID*/, SfxItemState /*eS
         {
             const XFormTextAdjustItem* pStateItem =
                                 PTR_CAST(XFormTextAdjustItem, pItem);
-            DBG_ASSERT(pStateItem || pItem == 0, "XFormTextAdjustItem erwartet");
+            DBG_ASSERT(pStateItem || pItem == 0, "XFormTextAdjustItem expected");
             rFontWorkDlg.SetAdjust_Impl(pStateItem);
             break;
         }
@@ -111,7 +103,7 @@ void SvxFontWorkControllerItem::StateChanged( USHORT /*nSID*/, SfxItemState /*eS
         {
             const XFormTextStartItem* pStateItem =
                                 PTR_CAST(XFormTextStartItem, pItem);
-            DBG_ASSERT(pStateItem || pItem == 0, "XFormTextStartItem erwartet");
+            DBG_ASSERT(pStateItem || pItem == 0, "XFormTextStartItem expected");
             rFontWorkDlg.SetStart_Impl(pStateItem);
             break;
         }
@@ -119,7 +111,7 @@ void SvxFontWorkControllerItem::StateChanged( USHORT /*nSID*/, SfxItemState /*eS
         {
             const XFormTextMirrorItem* pStateItem =
                                 PTR_CAST(XFormTextMirrorItem, pItem);
-            DBG_ASSERT(pStateItem || pItem == 0, "XFormTextMirrorItem erwartet");
+            DBG_ASSERT(pStateItem || pItem == 0, "XFormTextMirrorItem expected");
             rFontWorkDlg.SetMirror_Impl(pStateItem);
             break;
         }
@@ -127,7 +119,7 @@ void SvxFontWorkControllerItem::StateChanged( USHORT /*nSID*/, SfxItemState /*eS
         {
             const XFormTextStdFormItem* pStateItem =
                                 PTR_CAST(XFormTextStdFormItem, pItem);
-            DBG_ASSERT(pStateItem || pItem == 0, "XFormTextStdFormItem erwartet");
+            DBG_ASSERT(pStateItem || pItem == 0, "XFormTextStdFormItem expected");
             rFontWorkDlg.SetStdForm_Impl(pStateItem);
             break;
         }
@@ -135,7 +127,7 @@ void SvxFontWorkControllerItem::StateChanged( USHORT /*nSID*/, SfxItemState /*eS
         {
             const XFormTextHideFormItem* pStateItem =
                                 PTR_CAST(XFormTextHideFormItem, pItem);
-            DBG_ASSERT(pStateItem || pItem == 0, "XFormTextHideFormItem erwartet");
+            DBG_ASSERT(pStateItem || pItem == 0, "XFormTextHideFormItem expected");
             rFontWorkDlg.SetShowForm_Impl(pStateItem);
             break;
         }
@@ -143,7 +135,7 @@ void SvxFontWorkControllerItem::StateChanged( USHORT /*nSID*/, SfxItemState /*eS
         {
             const XFormTextOutlineItem* pStateItem =
                                 PTR_CAST(XFormTextOutlineItem, pItem);
-            DBG_ASSERT(pStateItem || pItem == 0, "XFormTextOutlineItem erwartet");
+            DBG_ASSERT(pStateItem || pItem == 0, "XFormTextOutlineItem expected");
             rFontWorkDlg.SetOutline_Impl(pStateItem);
             break;
         }
@@ -151,7 +143,7 @@ void SvxFontWorkControllerItem::StateChanged( USHORT /*nSID*/, SfxItemState /*eS
         {
             const XFormTextShadowItem* pStateItem =
                                 PTR_CAST(XFormTextShadowItem, pItem);
-            DBG_ASSERT(pStateItem || pItem == 0, "XFormTextShadowItem erwartet");
+            DBG_ASSERT(pStateItem || pItem == 0, "XFormTextShadowItem expected");
             rFontWorkDlg.SetShadow_Impl(pStateItem);
             break;
         }
@@ -159,7 +151,7 @@ void SvxFontWorkControllerItem::StateChanged( USHORT /*nSID*/, SfxItemState /*eS
         {
             const XFormTextShadowColorItem* pStateItem =
                                 PTR_CAST(XFormTextShadowColorItem, pItem);
-            DBG_ASSERT(pStateItem || pItem == 0, "XFormTextShadowColorItem erwartet");
+            DBG_ASSERT(pStateItem || pItem == 0, "XFormTextShadowColorItem expected");
             rFontWorkDlg.SetShadowColor_Impl(pStateItem);
             break;
         }
@@ -167,7 +159,7 @@ void SvxFontWorkControllerItem::StateChanged( USHORT /*nSID*/, SfxItemState /*eS
         {
             const XFormTextShadowXValItem* pStateItem =
                                 PTR_CAST(XFormTextShadowXValItem, pItem);
-            DBG_ASSERT(pStateItem || pItem == 0, "XFormTextShadowXValItem erwartet");
+            DBG_ASSERT(pStateItem || pItem == 0, "XFormTextShadowXValItem expected");
             rFontWorkDlg.SetShadowXVal_Impl(pStateItem);
             break;
         }
@@ -175,18 +167,14 @@ void SvxFontWorkControllerItem::StateChanged( USHORT /*nSID*/, SfxItemState /*eS
         {
             const XFormTextShadowYValItem* pStateItem =
                                 PTR_CAST(XFormTextShadowYValItem, pItem);
-            DBG_ASSERT(pStateItem || pItem == 0, "XFormTextShadowYValItem erwartet");
+            DBG_ASSERT(pStateItem || pItem == 0, "XFormTextShadowYValItem expected");
             rFontWorkDlg.SetShadowYVal_Impl(pStateItem);
             break;
         }
     }
 }
 
-/*************************************************************************
-|*
-|* Ableitung vom SfxChildWindow als "Behaelter" fuer Fontwork-Dialog
-|*
-\************************************************************************/
+// Derivation from SfxChildWindow as "containers" for Fontwork dialog
 
 SvxFontWorkChildWindow::SvxFontWorkChildWindow
 (
@@ -208,11 +196,7 @@ SvxFontWorkChildWindow::SvxFontWorkChildWindow
     pDlg->Initialize( pInfo );
 }
 
-/*************************************************************************
-|*
-|* Floating Window zur Attributierung von Texteffekten
-|*
-\************************************************************************/
+// Floating Window to the attribution of text effects
 
 SvxFontWorkDialog::SvxFontWorkDialog( SfxBindings *pBindinx,
                                       SfxChildWindow *pCW,
@@ -288,7 +272,7 @@ SvxFontWorkDialog::SvxFontWorkDialog( SfxBindings *pBindinx,
     aMtrFldShadowX.SetModifyHdl( aLink );
     aMtrFldShadowY.SetModifyHdl( aLink );
 
-    // System-Metrik setzen
+    // Set System metric
     const FieldUnit eDlgUnit = rBindings.GetDispatcher()->GetModule()->GetFieldUnit();
     SetFieldUnit( aMtrFldDistance, eDlgUnit, TRUE );
     SetFieldUnit( aMtrFldTextStart, eDlgUnit, TRUE );
@@ -323,12 +307,6 @@ SvxFontWorkDialog::SvxFontWorkDialog( SfxBindings *pBindinx,
     aFormSet.SetSizePixel(aSize);
 }
 
-/*************************************************************************
-|*
-|* Destruktor
-|*
-\************************************************************************/
-
 SvxFontWorkDialog::~SvxFontWorkDialog()
 {
     for (USHORT i = 0; i < CONTROLLER_COUNT; i++)
@@ -379,12 +357,7 @@ SfxChildAlignment SvxFontWorkDialog::CheckAlignment( SfxChildAlignment eActAlign
     return eAlignment;
 }
 
-
-/*************************************************************************
-|*
-|* Style-Buttons setzen
-|*
-\************************************************************************/
+// Set style buttons
 
 void SvxFontWorkDialog::SetStyle_Impl(const XFormTextStyleItem* pItem)
 {
@@ -424,11 +397,7 @@ void SvxFontWorkDialog::SetStyle_Impl(const XFormTextStyleItem* pItem)
         aTbxStyle.Disable();
 }
 
-/*************************************************************************
-|*
-|* Adjust-Buttons setzen
-|*
-\************************************************************************/
+// Set adjust buttons
 
 void SvxFontWorkDialog::SetAdjust_Impl(const XFormTextAdjustItem* pItem)
 {
@@ -466,41 +435,29 @@ void SvxFontWorkDialog::SetAdjust_Impl(const XFormTextAdjustItem* pItem)
     }
 }
 
-/*************************************************************************
-|*
-|* Abstand-Wert in Editfeld eintragen
-|*
-\************************************************************************/
+// Enter Distance value in the edit field
 
 void SvxFontWorkDialog::SetDistance_Impl(const XFormTextDistanceItem* pItem)
 {
-    // #104596# Use HasChildPathFocus() instead of HasFocus() at SpinFields
+    // Use HasChildPathFocus() instead of HasFocus() at SpinFields
     if ( pItem && !aMtrFldDistance.HasChildPathFocus() )
     {
         SetMetricValue( aMtrFldDistance, pItem->GetValue(), SFX_MAPUNIT_100TH_MM );
     }
 }
 
-/*************************************************************************
-|*
-|* Einzug-Wert in Editfeld eintragen
-|*
-\************************************************************************/
+// Enter indent value in the edit field
 
 void SvxFontWorkDialog::SetStart_Impl(const XFormTextStartItem* pItem)
 {
-    // #104596# Use HasChildPathFocus() instead of HasFocus() at SpinFields
+    // Use HasChildPathFocus() instead of HasFocus() at SpinFields
     if ( pItem && !aMtrFldTextStart.HasChildPathFocus() )
     {
         SetMetricValue( aMtrFldTextStart, pItem->GetValue(), SFX_MAPUNIT_100TH_MM );
     }
 }
 
-/*************************************************************************
-|*
-|* Button fuer Umkehrung der Textrichtung setzen
-|*
-\************************************************************************/
+// Set button for reversing the direction of text
 
 void SvxFontWorkDialog::SetMirror_Impl(const XFormTextMirrorItem* pItem)
 {
@@ -508,11 +465,7 @@ void SvxFontWorkDialog::SetMirror_Impl(const XFormTextMirrorItem* pItem)
         aTbxAdjust.CheckItem(TBI_ADJUST_MIRROR, pItem->GetValue());
 }
 
-/*************************************************************************
-|*
-|* Standardform im ValueSet anzeigen
-|*
-\************************************************************************/
+// Standard form in ValueSet View
 
 void SvxFontWorkDialog::SetStdForm_Impl(const XFormTextStdFormItem* pItem)
 {
@@ -529,11 +482,7 @@ void SvxFontWorkDialog::SetStdForm_Impl(const XFormTextStdFormItem* pItem)
         aFormSet.Disable();
 }
 
-/*************************************************************************
-|*
-|* Button fuer Konturanzeige setzen
-|*
-\************************************************************************/
+// Set button for contour display
 
 void SvxFontWorkDialog::SetShowForm_Impl(const XFormTextHideFormItem* pItem)
 {
@@ -541,11 +490,7 @@ void SvxFontWorkDialog::SetShowForm_Impl(const XFormTextHideFormItem* pItem)
         aTbxShadow.CheckItem(TBI_SHOWFORM, !pItem->GetValue());
 }
 
-/*************************************************************************
-|*
-|* Button fuer Zeichenumrandung setzen
-|*
-\************************************************************************/
+// Set button for text border
 
 void SvxFontWorkDialog::SetOutline_Impl(const XFormTextOutlineItem* pItem)
 {
@@ -553,11 +498,7 @@ void SvxFontWorkDialog::SetOutline_Impl(const XFormTextOutlineItem* pItem)
         aTbxShadow.CheckItem(TBI_OUTLINE, pItem->GetValue());
 }
 
-/*************************************************************************
-|*
-|* Shadow-Buttons setzen
-|*
-\************************************************************************/
+// Set shadow buttons
 
 void SvxFontWorkDialog::SetShadow_Impl(const XFormTextShadowItem* pItem,
                                         BOOL bRestoreValues)
@@ -665,11 +606,7 @@ void SvxFontWorkDialog::SetShadow_Impl(const XFormTextShadowItem* pItem,
     }
 }
 
-/*************************************************************************
-|*
-|* Schattenfarbe in Listbox eintragen
-|*
-\************************************************************************/
+// Insert shadow color in listbox
 
 void SvxFontWorkDialog::SetShadowColor_Impl(const XFormTextShadowColorItem* pItem)
 {
@@ -677,15 +614,11 @@ void SvxFontWorkDialog::SetShadowColor_Impl(const XFormTextShadowColorItem* pIte
         aShadowColorLB.SelectEntry(pItem->GetColorValue());
 }
 
-/*************************************************************************
-|*
-|* X-Wert fuer Schatten in Editfeld eintragen
-|*
-\************************************************************************/
+// Enter X-value for shadow in edit field
 
 void SvxFontWorkDialog::SetShadowXVal_Impl(const XFormTextShadowXValItem* pItem)
 {
-    // #104596# Use HasChildPathFocus() instead of HasFocus() at SpinFields
+    // Use HasChildPathFocus() instead of HasFocus() at SpinFields
     if ( pItem && !aMtrFldShadowX.HasChildPathFocus() )
     {
         // #i19251#
@@ -712,15 +645,11 @@ void SvxFontWorkDialog::SetShadowXVal_Impl(const XFormTextShadowXValItem* pItem)
     }
 }
 
-/*************************************************************************
-|*
-|* Y-Wert fuer Schatten in Editfeld eintragen
-|*
-\************************************************************************/
+// Enter Y-value for shadow in edit field
 
 void SvxFontWorkDialog::SetShadowYVal_Impl(const XFormTextShadowYValItem* pItem)
 {
-    // #104596# Use HasChildPathFocus() instead of HasFocus() at SpinFields
+    // Use HasChildPathFocus() instead of HasFocus() at SpinFields
     if ( pItem && !aMtrFldShadowY.HasChildPathFocus() )
     {
         // #i19251#
@@ -842,9 +771,9 @@ IMPL_LINK_INLINE_END( SvxFontWorkDialog, ModifyInputHdl_Impl, void *, EMPTYARG )
 
 IMPL_LINK( SvxFontWorkDialog, InputTimoutHdl_Impl, void *, EMPTYARG )
 {
-    // System-Metrik evtl. neu setzen
-    // Dieses sollte mal als Listener passieren, ist aber aus
-    // inkompatibilitaetsgruenden z.Z. nicht moeglich
+    // Possibly set the Metric system again. This should be done with a
+    // listen, this is however not possible at the moment due to compabillity
+    // issues.
     const FieldUnit eDlgUnit = rBindings.GetDispatcher()->GetModule()->GetFieldUnit();
     if( eDlgUnit != aMtrFldDistance.GetUnit() )
     {
@@ -888,7 +817,7 @@ IMPL_LINK( SvxFontWorkDialog, InputTimoutHdl_Impl, void *, EMPTYARG )
     XFormTextShadowXValItem aShadowXItem( nValueX );
     XFormTextShadowYValItem aShadowYItem( nValueY );
 
-    // Slot-ID ist egal, die Exec-Methode wertet das gesamte ItemSet aus
+    // Slot-ID does not matter, the Exec method evaluates the entire item set
     GetBindings().GetDispatcher()->Execute( SID_FORMTEXT_DISTANCE, SFX_CALLMODE_RECORD, &aDistItem,
                                             &aStartItem, &aShadowXItem, &aShadowYItem, 0L );
     return 0;
@@ -929,11 +858,7 @@ void SvxFontWorkDialog::SetActive(BOOL /*bActivate*/)
 {
 }
 
-/*************************************************************************
-|*
-|* Standard-FontWork-Objekt erzeugen
-|*
-\************************************************************************/
+// Create standard fontWork Object
 
 void SvxFontWorkDialog::CreateStdFormObj(SdrView& rView, SdrPageView& rPV,
                                          const SfxItemSet& rAttr,
@@ -1031,7 +956,7 @@ void SvxFontWorkDialog::CreateStdFormObj(SdrView& rView, SdrPageView& rPV,
             basegfx::B2DPolygon aTopArc(XPolygon(aCenter, -nR, nR, 50, 1750, FALSE).getB2DPolygon());
             basegfx::B2DPolygon aBottomArc(XPolygon(aCenter, -nR, nR, 1850, 3550, FALSE).getB2DPolygon());
 
-            // Polygone schliessen
+            // Close Polygon
             aTopArc.setClosed(true);
             aBottomArc.setClosed(true);
             aPolyPolygon.append(aTopArc);
@@ -1102,7 +1027,7 @@ void SvxFontWorkDialog::CreateStdFormObj(SdrView& rView, SdrPageView& rPV,
     }
     if ( pNewObj )
     {
-        // #78478# due to DLs changes in Outliner the object needs
+        // due to DLs changes in Outliner the object needs
         // a model to get an outliner for later calls to
         // pNewObj->SetOutlinerParaObject(pPara) (see below).
         pNewObj->SetModel(rOldObj.GetModel());
diff --git a/svx/source/dialog/graphctl.cxx b/svx/source/dialog/graphctl.cxx
index f98907b95ed6..d4300f5cbdde 100644
--- a/svx/source/dialog/graphctl.cxx
+++ b/svx/source/dialog/graphctl.cxx
@@ -47,12 +47,6 @@
 // #i72889#
 #include "sdrpaintwindow.hxx"
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void GraphCtrlUserCall::Changed( const SdrObject& rObj, SdrUserCallType eType, const Rectangle& /*rOldBoundRect*/ )
 {
     switch( eType )
@@ -71,13 +65,6 @@ void GraphCtrlUserCall::Changed( const SdrObject& rObj, SdrUserCallType eType, c
     }
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 GraphCtrl::GraphCtrl( Window* pParent, const WinBits nWinBits ) :
             Control         ( pParent, nWinBits ),
             aMap100         ( MAP_100TH_MM ),
@@ -99,13 +86,6 @@ GraphCtrl::GraphCtrl( Window* pParent, const WinBits nWinBits ) :
     EnableRTL( FALSE );
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 GraphCtrl::GraphCtrl( Window* pParent, const ResId& rResId ) :
             Control         ( pParent, rResId ),
             aMap100         ( MAP_100TH_MM ),
@@ -126,13 +106,6 @@ GraphCtrl::GraphCtrl( Window* pParent, const ResId& rResId ) :
     EnableRTL( FALSE );
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 GraphCtrl::~GraphCtrl()
 {
     if( mpAccContext )
@@ -145,13 +118,6 @@ GraphCtrl::~GraphCtrl()
     delete pUserCall;
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void GraphCtrl::SetWinStyle( WinBits nWinBits )
 {
     nWinStyle = nWinBits;
@@ -172,24 +138,17 @@ void GraphCtrl::SetWinStyle( WinBits nWinBits )
         InitSdrModel();
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void GraphCtrl::InitSdrModel()
 {
     SolarMutexGuard aGuard;
 
     SdrPage* pPage;
 
-    // alten Kram zerstoeren
+    // destroy old junk
     delete pView;
     delete pModel;
 
-    // Model anlegen
+    // Creating a Model
     pModel = new SdrModel;
     pModel->GetItemPool().FreezeIdRanges();
     pModel->SetScaleUnit( aMap100.GetMapUnit() );
@@ -203,12 +162,11 @@ void GraphCtrl::InitSdrModel()
     pModel->InsertPage( pPage );
     pModel->SetChanged( sal_False );
 
-    // View anlegen
+    // Creating a View
     pView = new GraphCtrlView( pModel, this );
     pView->SetWorkArea( Rectangle( Point(), aGraphSize ) );
     pView->EnableExtendedMouseEventDispatcher( TRUE );
     pView->ShowSdrPage(pView->GetModel()->GetPage(0));
-//  pView->ShowSdrPage(pView->GetModel()->GetPage(0));
     pView->SetFrameDragSingles( TRUE );
     pView->SetMarkedPointsSmooth( SDRPATHSMOOTH_SYMMETRIC );
     pView->SetEditMode( TRUE );
@@ -223,16 +181,9 @@ void GraphCtrl::InitSdrModel()
         mpAccContext->setModelAndView (pModel, pView);
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void GraphCtrl::SetGraphic( const Graphic& rGraphic, BOOL bNewModel )
 {
-    // Bitmaps dithern wir ggf. fuer die Anzeige
+    // If possible we dither bitmaps for the display
     if ( !bAnim && ( rGraphic.GetType() == GRAPHIC_BITMAP )  )
     {
         if ( rGraphic.IsTransparent() )
@@ -267,13 +218,6 @@ void GraphCtrl::SetGraphic( const Graphic& rGraphic, BOOL bNewModel )
     Invalidate();
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void GraphCtrl::Resize()
 {
     Control::Resize();
@@ -289,7 +233,7 @@ void GraphCtrl::Resize()
         double          fGrfWH = (double) aGraphSize.Width() / aGraphSize.Height();
         double          fWinWH = (double) nWidth / nHeight;
 
-        // Bitmap an Thumbgroesse anpassen
+        // Adapt Bitmap to Thumb size
         if ( fGrfWH < fWinWH)
         {
             aNewSize.Width() = (long) ( (double) nHeight * fGrfWH );
@@ -304,7 +248,7 @@ void GraphCtrl::Resize()
         aNewPos.X() = ( nWidth - aNewSize.Width() )  >> 1;
         aNewPos.Y() = ( nHeight - aNewSize.Height() ) >> 1;
 
-        // MapMode fuer Engine umsetzen
+        // Implementing MapMode for Engine
         aDisplayMap.SetScaleX( Fraction( aNewSize.Width(), aGraphSize.Width() ) );
         aDisplayMap.SetScaleY( Fraction( aNewSize.Height(), aGraphSize.Height() ) );
 
@@ -315,13 +259,6 @@ void GraphCtrl::Resize()
     Invalidate();
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void GraphCtrl::Paint( const Rectangle& rRect )
 {
     // #i72889# used splitted repaint to be able to paint an own background
@@ -356,48 +293,20 @@ void GraphCtrl::Paint( const Rectangle& rRect )
     }
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void GraphCtrl::SdrObjChanged( const SdrObject&  )
 {
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void GraphCtrl::SdrObjCreated( const SdrObject& )
 {
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void GraphCtrl::MarkListHasChanged()
 {
     if ( aMarkObjLink.IsSet() )
         aMarkObjLink.Call( this );
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void GraphCtrl::KeyInput( const KeyEvent& rKEvt )
 {
     KeyCode aCode( rKEvt.GetKeyCode() );
@@ -486,7 +395,7 @@ void GraphCtrl::KeyInput( const KeyEvent& rKEvt )
 
             if ( aCode.IsMod1() )
             {
-                // #97016# mark last object
+                // mark last object
                 pView->UnmarkAllObj();
                 pView->MarkNextObj(FALSE);
 
@@ -517,25 +426,25 @@ void GraphCtrl::KeyInput( const KeyEvent& rKEvt )
 
             if (aCode.GetCode() == KEY_UP)
             {
-                // Scroll nach oben
+                // Scroll up
                 nX = 0;
                 nY =-1;
             }
             else if (aCode.GetCode() == KEY_DOWN)
             {
-                // Scroll nach unten
+                // Scroll down
                 nX = 0;
                 nY = 1;
             }
             else if (aCode.GetCode() == KEY_LEFT)
             {
-                // Scroll nach links
+                // Scroll left
                 nX =-1;
                 nY = 0;
             }
             else if (aCode.GetCode() == KEY_RIGHT)
             {
-                // Scroll nach rechts
+                // Scroll right
                 nX = 1;
                 nY = 0;
             }
@@ -544,7 +453,7 @@ void GraphCtrl::KeyInput( const KeyEvent& rKEvt )
             {
                 if(aCode.IsMod2())
                 {
-                    // #97016# move in 1 pixel distance
+                    // move in 1 pixel distance
                     Size aLogicSizeOnePixel = PixelToLogic(Size(1,1));
                     nX *= aLogicSizeOnePixel.Width();
                     nY *= aLogicSizeOnePixel.Height();
@@ -556,13 +465,13 @@ void GraphCtrl::KeyInput( const KeyEvent& rKEvt )
                     nY *= 100;
                 }
 
-                // #97016# II
+                // II
                 const SdrHdlList& rHdlList = pView->GetHdlList();
                 SdrHdl* pHdl = rHdlList.GetFocusHdl();
 
                 if(0L == pHdl)
                 {
-                    // #90129# restrict movement to WorkArea
+                    // restrict movement to WorkArea
                     const Rectangle& rWorkArea = pView->GetWorkArea();
 
                     if(!rWorkArea.IsEmpty())
@@ -711,13 +620,6 @@ void GraphCtrl::KeyInput( const KeyEvent& rKEvt )
         ReleaseMouse();
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void GraphCtrl::MouseButtonDown( const MouseEvent& rMEvt )
 {
     if ( bSdrMode && ( rMEvt.GetClicks() < 2 ) )
@@ -728,7 +630,7 @@ void GraphCtrl::MouseButtonDown( const MouseEvent& rMEvt )
             Control::MouseButtonDown( rMEvt );
         else
         {
-            // Focus anziehen fuer Key-Inputs
+            // Get Focus for key inputs
             GrabFocus();
 
             if ( nPolyEdit )
@@ -747,7 +649,7 @@ void GraphCtrl::MouseButtonDown( const MouseEvent& rMEvt )
 
         SdrObject* pCreateObj = pView->GetCreateObj();
 
-        // Wir wollen das Inserten mitbekommen
+        // We want to realize the insert
         if ( pCreateObj && !pCreateObj->GetUserCall() )
             pCreateObj->SetUserCall( pUserCall );
 
@@ -757,13 +659,6 @@ void GraphCtrl::MouseButtonDown( const MouseEvent& rMEvt )
         Control::MouseButtonDown( rMEvt );
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void GraphCtrl::MouseMove(const MouseEvent& rMEvt)
 {
     const Point aLogPos( PixelToLogic( rMEvt.GetPosPixel() ) );
@@ -795,13 +690,6 @@ void GraphCtrl::MouseMove(const MouseEvent& rMEvt)
     }
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void GraphCtrl::MouseButtonUp(const MouseEvent& rMEvt)
 {
     if ( bSdrMode )
@@ -818,13 +706,6 @@ void GraphCtrl::MouseButtonUp(const MouseEvent& rMEvt)
         Control::MouseButtonUp( rMEvt );
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 SdrObject* GraphCtrl::GetSelectedSdrObject() const
 {
     SdrObject* pSdrObj = NULL;
@@ -840,13 +721,6 @@ SdrObject* GraphCtrl::GetSelectedSdrObject() const
     return pSdrObj;
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void GraphCtrl::SetEditMode( const BOOL _bEditMode )
 {
     if ( bSdrMode )
@@ -860,13 +734,6 @@ void GraphCtrl::SetEditMode( const BOOL _bEditMode )
         bEditMode = FALSE;
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void GraphCtrl::SetPolyEditMode( const USHORT _nPolyEdit )
 {
     if ( bSdrMode && ( _nPolyEdit != nPolyEdit ) )
@@ -878,13 +745,6 @@ void GraphCtrl::SetPolyEditMode( const USHORT _nPolyEdit )
         nPolyEdit = 0;
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void GraphCtrl::SetObjKind( const SdrObjKind _eObjKind )
 {
     if ( bSdrMode )
@@ -898,13 +758,6 @@ void GraphCtrl::SetObjKind( const SdrObjKind _eObjKind )
         eObjKind = OBJ_NONE;
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 String GraphCtrl::GetStringFromDouble( const double& rDouble )
 {
     sal_Unicode cSep =
@@ -914,13 +767,6 @@ String GraphCtrl::GetStringFromDouble( const double& rDouble )
     return aStr;
 }
 
-
-/*************************************************************************
-www|*
-|*
-|*
-\************************************************************************/
-
 IMPL_LINK( GraphCtrl, UpdateHdl, Timer*, pTimer )
 {
     if ( aUpdateLink.IsSet() )
@@ -944,7 +790,7 @@ IMPL_LINK( GraphCtrl, UpdateHdl, Timer*, pTimer )
         {
             ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > xAccParent( pParent->GetAccessible() );
 
-            // #103856# Disable accessibility if no model/view data available
+            // Disable accessibility if no model/view data available
             if( pView &&
                 pModel &&
                 xAccParent.is() )
diff --git a/svx/source/dialog/hdft.cxx b/svx/source/dialog/hdft.cxx
index 04e9cff1680f..c5c38ade741a 100644
--- a/svx/source/dialog/hdft.cxx
+++ b/svx/source/dialog/hdft.cxx
@@ -65,12 +65,11 @@
 // static ----------------------------------------------------------------
 
 // Word 97 incompatibility (#i19922#)
-//static const long MINBODY = 284;            // 0,5cm in twips aufgerundet
 static const long MINBODY = 56;  // 1mm in twips rounded
 
 // default distance to Header or footer
 static const long DEF_DIST_WRITER = 500;    // 5mm (Writer)
-static const long DEF_DIST_CALC = 250;      // 2,5mm (Calc)
+static const long DEF_DIST_CALC = 250;      // 2.5mm (Calc)
 
 static USHORT pRanges[] =
 {
@@ -90,7 +89,7 @@ static USHORT pRanges[] =
     0
 };
 
-// gibt den Bereich der Which-Werte zurueck
+// returns the Which values to the range
 
 
 USHORT* SvxHeaderPage::GetRanges()
@@ -168,12 +167,12 @@ SvxHFPage::SvxHFPage( Window* pParent, USHORT nResId, const SfxItemSet& rAttr, U
     InitHandler();
     aBspWin.EnableRTL( FALSE );
 
-    // diese Page braucht ExchangeSupport
+    // This Page needs ExchangeSupport
     SetExchangeSupport();
 
     FreeResource();
 
-    // Metrik einstellen
+    // Set metrics
     FieldUnit eFUnit = GetModuleFieldUnit( rAttr );
     SetFieldUnit( aDistEdit, eFUnit );
     SetFieldUnit( aHeightEdit, eFUnit );
@@ -234,20 +233,18 @@ BOOL SvxHFPage::FillItemSet( SfxItemSet& rSet )
         delete pBoolItem;
     }
 
-    // Groesse
+    // Size
     SvxSizeItem aSizeItem( (const SvxSizeItem&)rOldSet.Get( nWSize ) );
     Size        aSize( aSizeItem.GetSize() );
     long        nDist = GetCoreValue( aDistEdit, eUnit );
     long        nH    = GetCoreValue( aHeightEdit, eUnit );
 
-    // fixe Hoehe?
-//  if ( !aHeightDynBtn.IsChecked() )
-        nH += nDist; // dann Abstand dazu addieren
+    nH += nDist; // add distance
     aSize.Height() = nH;
     aSizeItem.SetSize( aSize );
     aSet.Put( aSizeItem );
 
-    // Raender
+    // Margins
     SvxLRSpaceItem aLR( nWLRSpace );
     aLR.SetLeft( (USHORT)GetCoreValue( aLMEdit, eUnit ) );
     aLR.SetRight( (USHORT)GetCoreValue( aRMEdit, eUnit ) );
@@ -260,7 +257,7 @@ BOOL SvxHFPage::FillItemSet( SfxItemSet& rSet )
         aUL.SetUpper( (USHORT)nDist );
     aSet.Put( aUL );
 
-    // Hintergrund und Umrandung?
+    // Background and border?
     if ( pBBSet )
         aSet.Put( *pBBSet );
     else
@@ -284,7 +281,7 @@ BOOL SvxHFPage::FillItemSet( SfxItemSet& rSet )
         }
     }
 
-    // Das SetItem wegschreiben
+    // Flush the SetItem
     SvxSetItem aSetItem( GetWhich( nId ), aSet );
     rSet.Put( aSetItem );
 
@@ -298,11 +295,10 @@ void SvxHFPage::Reset( const SfxItemSet& rSet )
     ResetBackground_Impl( rSet );
 
     SfxItemPool* pPool = GetItemSet().GetPool();
-    DBG_ASSERT( pPool, "Wo ist der Pool" );
+    DBG_ASSERT( pPool, "Where is the pool" );
     SfxMapUnit eUnit = pPool->GetMetric( GetWhich( SID_ATTR_PAGE_SIZE ) );
 
-    // Kopf-/Fusszeilen-Attribute auswerten
-    //
+    // Evaluate header-/footer- attributes
     const SvxSetItem* pSetItem = 0;
 
     if ( SFX_ITEM_SET == rSet.GetItemState( GetWhich(nId), FALSE,
@@ -335,12 +331,12 @@ void SvxHFPage::Reset( const SfxItemSet& rSet )
 
 
             if ( nId == SID_ATTR_PAGE_HEADERSET )
-            {   // Kopfzeile
+            {   // Header
                 SetMetricValue( aDistEdit, rUL.GetLower(), eUnit );
                 SetMetricValue( aHeightEdit, rSize.GetSize().Height() - rUL.GetLower(), eUnit );
             }
             else
-            {   // Fusszeile
+            {   // Footer
                 SetMetricValue( aDistEdit, rUL.GetUpper(), eUnit );
                 SetMetricValue( aHeightEdit, rSize.GetSize().Height() - rUL.GetUpper(), eUnit );
             }
@@ -402,10 +398,6 @@ void SvxHFPage::Reset( const SfxItemSet& rSet )
 
 }
 
-/*--------------------------------------------------------------------
-    Beschreibung:   Handler initialisieren
- --------------------------------------------------------------------*/
-
 void SvxHFPage::InitHandler()
 {
     aTurnOnBox.SetClickHdl(LINK(this,   SvxHFPage, TurnOnHdl));
@@ -422,10 +414,6 @@ void SvxHFPage::InitHandler()
     aBackgroundBtn.SetClickHdl(LINK(this,SvxHFPage, BackgroundHdl));
 }
 
-/*--------------------------------------------------------------------
-    Beschreibung:   Ein/aus
- --------------------------------------------------------------------*/
-
 IMPL_LINK( SvxHFPage, TurnOnHdl, CheckBox *, pBox )
 {
     if ( aTurnOnBox.IsChecked() )
@@ -480,10 +468,6 @@ IMPL_LINK( SvxHFPage, TurnOnHdl, CheckBox *, pBox )
     return 0;
 }
 
-/*--------------------------------------------------------------------
-    Beschreibung:   Abstand im Bsp Modifizieren
- --------------------------------------------------------------------*/
-
 IMPL_LINK_INLINE_START( SvxHFPage, DistModify, MetricField *, EMPTYARG )
 {
     UpdateExample();
@@ -499,10 +483,6 @@ IMPL_LINK_INLINE_START( SvxHFPage, HeightModify, MetricField *, EMPTYARG )
 }
 IMPL_LINK_INLINE_END( SvxHFPage, HeightModify, MetricField *, EMPTYARG )
 
-/*--------------------------------------------------------------------
-    Beschreibung: Raender einstellen
- --------------------------------------------------------------------*/
-
 IMPL_LINK_INLINE_START( SvxHFPage, BorderModify, MetricField *, EMPTYARG )
 {
     UpdateExample();
@@ -510,21 +490,17 @@ IMPL_LINK_INLINE_START( SvxHFPage, BorderModify, MetricField *, EMPTYARG )
 }
 IMPL_LINK_INLINE_END( SvxHFPage, BorderModify, MetricField *, EMPTYARG )
 
-/*--------------------------------------------------------------------
-    Beschreibung:   Hintergrund
- --------------------------------------------------------------------*/
-
 IMPL_LINK( SvxHFPage, BackgroundHdl, Button *, EMPTYARG )
 {
     if ( !pBBSet )
     {
-        // nur die n"otigen Items f"uer Umrandung und Hintergrund benutzen
+        // Use only the necessary items for border and background
         USHORT nBrush = GetWhich( SID_ATTR_BRUSH );
         USHORT nOuter = GetWhich( SID_ATTR_BORDER_OUTER );
         USHORT nInner = GetWhich( SID_ATTR_BORDER_INNER, sal_False );
         USHORT nShadow = GetWhich( SID_ATTR_BORDER_SHADOW );
 
-        // einen leeren Set erzeugenc
+        // Create an empty set
         pBBSet = new SfxItemSet( *GetItemSet().GetPool(), nBrush, nBrush,
                                  nOuter, nOuter, nInner, nInner,
                                  nShadow, nShadow, 0 );
@@ -532,12 +508,12 @@ IMPL_LINK( SvxHFPage, BackgroundHdl, Button *, EMPTYARG )
 
         if ( SFX_ITEM_SET ==
              GetItemSet().GetItemState( GetWhich( nId ), FALSE, &pItem ) )
-            // wenn es schon einen gesetzen Set gibt, dann diesen benutzen
+            // if there is one that is already set, then use this
             pBBSet->Put( ( (SvxSetItem*)pItem)->GetItemSet() );
 
         if ( SFX_ITEM_SET ==
              GetItemSet().GetItemState( nInner, FALSE, &pItem ) )
-            // das gesetze InfoItem wird immer ben"otigt
+            // The set InfoItem is always required
             pBBSet->Put( *pItem );
     }
 
@@ -592,10 +568,6 @@ IMPL_LINK( SvxHFPage, BackgroundHdl, Button *, EMPTYARG )
     return 0;
 }
 
-/*--------------------------------------------------------------------
-    Beschreibung:   Bsp
- --------------------------------------------------------------------*/
-
 void SvxHFPage::UpdateExample()
 {
     if ( nId == SID_ATTR_PAGE_HEADERSET )
@@ -617,10 +589,6 @@ void SvxHFPage::UpdateExample()
     aBspWin.Invalidate();
 }
 
-/*--------------------------------------------------------------------
-    Beschreibung: Hintergrund im Beispiel setzen
- --------------------------------------------------------------------*/
-
 void SvxHFPage::ResetBackground_Impl( const SfxItemSet& rSet )
 {
     USHORT nWhich = GetWhich( SID_ATTR_PAGE_HEADERSET );
@@ -713,7 +681,7 @@ void SvxHFPage::ActivatePage( const SfxItemSet& rSet )
 
     if ( pItem )
     {
-        // linken und rechten Rand einstellen
+        // Set left and right margins
         const SvxLRSpaceItem& rLRSpace = (const SvxLRSpaceItem&)*pItem;
 
         aBspWin.SetLeft( rLRSpace.GetLeft() );
@@ -729,7 +697,7 @@ void SvxHFPage::ActivatePage( const SfxItemSet& rSet )
 
     if ( pItem )
     {
-        // oberen und unteren Rand einstellen
+        // Set top and bottom margins
         const SvxULSpaceItem& rULSpace = (const SvxULSpaceItem&)*pItem;
 
         aBspWin.SetTop( rULSpace.GetUpper() );
@@ -757,13 +725,13 @@ void SvxHFPage::ActivatePage( const SfxItemSet& rSet )
 
     if ( pItem )
     {
-        // Orientation und Size aus dem PageItem
+        // Orientation and Size from the PageItem
         const SvxSizeItem& rSize = (const SvxSizeItem&)*pItem;
-        // die Groesse ist ggf. schon geswappt (Querformat)
+        // if the size is already swapped (Landscape)
         aBspWin.SetSize( rSize.GetSize() );
     }
 
-    // Kopfzeilen-Attribute auswerten
+    // Evaluate Header attribute
     const SvxSetItem* pSetItem = 0;
 
     if ( SFX_ITEM_SET == rSet.GetItemState( GetWhich( SID_ATTR_PAGE_HEADERSET ),
@@ -865,10 +833,6 @@ int SvxHFPage::DeactivatePage( SfxItemSet* _pSet )
     return LEAVE_PAGE;
 }
 
-/*--------------------------------------------------------------------
-    Beschreibung:   Berech
- --------------------------------------------------------------------*/
-
 IMPL_LINK( SvxHFPage, RangeHdl, Edit *, EMPTYARG )
 {
     long nHHeight = aBspWin.GetHdHeight();
@@ -896,7 +860,7 @@ IMPL_LINK( SvxHFPage, RangeHdl, Edit *, EMPTYARG )
         nFDist   = nDist;
     }
 
-    // Aktuelle Werte der Seitenraender
+    // Current values of the side edges
     long nBT = aBspWin.GetTop();
     long nBB = aBspWin.GetBottom();
     long nBL = aBspWin.GetLeft();
@@ -905,7 +869,7 @@ IMPL_LINK( SvxHFPage, RangeHdl, Edit *, EMPTYARG )
     long nH  = aBspWin.GetSize().Height();
     long nW  = aBspWin.GetSize().Width();
 
-    // Grenzen
+    // Borders
     if ( nId == SID_ATTR_PAGE_HEADERSET )
     {
         // Header
@@ -931,7 +895,7 @@ IMPL_LINK( SvxHFPage, RangeHdl, Edit *, EMPTYARG )
         aDistEdit.SetMax( aDistEdit.Normalize( nDist ), FUNIT_TWIP );
     }
 
-    // Einzuege beschraenken
+    // Limit Indentation
     nMax = nW - nBL - nBR -
            static_cast<long>(aRMEdit.Denormalize( aRMEdit.GetValue( FUNIT_TWIP ) )) - MINBODY;
     aLMEdit.SetMax( aLMEdit.Normalize( nMax ), FUNIT_TWIP );
diff --git a/svx/source/dialog/imapdlg.cxx b/svx/source/dialog/imapdlg.cxx
index a8f9736bede3..8c2f8a3ab311 100644
--- a/svx/source/dialog/imapdlg.cxx
+++ b/svx/source/dialog/imapdlg.cxx
@@ -109,11 +109,7 @@ inline String GetUnitString( long nVal_100, FieldUnit eFieldUnit, sal_Unicode cS
     return aVal;
 }
 
-/*************************************************************************
-|*
-|* ControllerItem
-|*
-\************************************************************************/
+// ControllerItem
 
 SvxIMapDlgItem::SvxIMapDlgItem( USHORT _nId, SvxIMapDlg& rIMapDlg, SfxBindings& rBindings ) :
             SfxControllerItem   ( _nId, rBindings ),
@@ -121,12 +117,6 @@ SvxIMapDlgItem::SvxIMapDlgItem( USHORT _nId, SvxIMapDlg& rIMapDlg, SfxBindings&
 {
 }
 
-/*************************************************************************
-|*
-|* StateChanged-Methode
-|*
-\************************************************************************/
-
 void SvxIMapDlgItem::StateChanged( USHORT nSID, SfxItemState /*eState*/,
                                    const SfxPoolItem* pItem )
 {
@@ -134,19 +124,13 @@ void SvxIMapDlgItem::StateChanged( USHORT nSID, SfxItemState /*eState*/,
     {
         const SfxBoolItem* pStateItem = PTR_CAST( SfxBoolItem, pItem );
 
-        DBG_ASSERT( pStateItem || pItem == 0, "SfxBoolItem erwartet");
+        DBG_ASSERT( pStateItem || pItem == 0, "SfxBoolItem expected");
 
-        // Float ggf. disablen
+        // Disable Float if possible
         rIMap.SetExecState( !pStateItem->GetValue() );
     }
 }
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 SvxIMapDlgChildWindow::SvxIMapDlgChildWindow( Window* _pParent, USHORT nId,
                                               SfxBindings* pBindings,
                                               SfxChildWinInfo* pInfo ) :
@@ -163,13 +147,6 @@ SvxIMapDlgChildWindow::SvxIMapDlgChildWindow( Window* _pParent, USHORT nId,
     pDlg->Initialize( pInfo );
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void SvxIMapDlgChildWindow::UpdateIMapDlg( const Graphic& rGraphic, const ImageMap* pImageMap,
                                            const TargetList* pTargetList, void* pEditingObj )
 {
@@ -178,13 +155,6 @@ void SvxIMapDlgChildWindow::UpdateIMapDlg( const Graphic& rGraphic, const ImageM
         SVXIMAPDLG()->Update( rGraphic, pImageMap, pTargetList, pEditingObj );
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 SvxIMapDlg::SvxIMapDlg( SfxBindings *_pBindings, SfxChildWindow *pCW,
                         Window* _pParent, const ResId& rResId ) :
         SfxModelessDialog   ( _pBindings, pCW, _pParent, rResId ),
@@ -253,27 +223,13 @@ SvxIMapDlg::SvxIMapDlg( SfxBindings *_pBindings, SfxChildWindow *pCW,
     aTbxIMapDlg1.EnableItem( TBI_PROPERTY, FALSE );
 }
 
-
-/*************************************************************************
-|*
-|* Dtor
-|*
-\************************************************************************/
-
 SvxIMapDlg::~SvxIMapDlg()
 {
-    // URL-Liste loeschen
+    // Delete URL-List
     delete pIMapWnd;
     delete pOwnData;
 }
 
-
-/*************************************************************************
-|*
-|* Resize-Methode
-|*
-\************************************************************************/
-
 void SvxIMapDlg::Resize()
 {
     SfxModelessDialog::Resize();
@@ -286,11 +242,11 @@ void SvxIMapDlg::Resize()
         Size    _aSize( aStbStatus.GetSizePixel() );
         Point   aPoint( 0, aNewSize.Height() - _aSize.Height() );
 
-        // StatusBar positionieren
+        // Position the StatusBar
         aStbStatus.SetPosSizePixel( aPoint, Size( aNewSize.Width(), _aSize.Height() ) );
         aStbStatus.Show();
 
-        // EditWindow positionieren
+        // Position the EditWindow
         _aSize.Width() = aNewSize.Width() - 18;
         _aSize.Height() = aPoint.Y() - pIMapWnd->GetPosPixel().Y() - 6;
         pIMapWnd->SetSizePixel( _aSize );
@@ -299,13 +255,6 @@ void SvxIMapDlg::Resize()
     }
 }
 
-
-/*************************************************************************
-|*
-|* Close-Methode
-|*
-\************************************************************************/
-
 BOOL SvxIMapDlg::Close()
 {
     BOOL bRet = TRUE;
@@ -340,61 +289,28 @@ BOOL SvxIMapDlg::Close()
     return( bRet ? SfxModelessDialog::Close() : FALSE );
 }
 
-
-/*************************************************************************
-|*
-|* Enabled oder disabled alle Controls
-|*
-\************************************************************************/
+// Enabled or disable all Controls
 
 void SvxIMapDlg::SetExecState( BOOL bEnable )
 {
     pOwnData->bExecState = bEnable;
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void SvxIMapDlg::SetGraphic( const Graphic& rGraphic )
 {
     pIMapWnd->SetGraphic( rGraphic );
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void SvxIMapDlg::SetImageMap( const ImageMap& rImageMap )
 {
     pIMapWnd->SetImageMap( rImageMap );
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 const ImageMap& SvxIMapDlg::GetImageMap() const
 {
     return pIMapWnd->GetImageMap();
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void SvxIMapDlg::SetTargetList( const TargetList& rTargetList )
 {
     TargetList  aNewList( rTargetList );
@@ -407,25 +323,11 @@ void SvxIMapDlg::SetTargetList( const TargetList& rTargetList )
         maCbbTarget.InsertEntry( *aNewList[ i ] );
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 const TargetList& SvxIMapDlg::GetTargetList() const
 {
     return pIMapWnd->GetTargetList();
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void SvxIMapDlg::Update( const Graphic& rGraphic, const ImageMap* pImageMap,
                          const TargetList* pTargetList, void* pEditingObj )
 {
@@ -438,17 +340,15 @@ void SvxIMapDlg::Update( const Graphic& rGraphic, const ImageMap* pImageMap,
 
     pOwnData->pUpdateEditingObject = pEditingObj;
 
-    // UpdateTargetList loeschen, da diese Methode
-    // vor dem Zuschlagen des Update-Timers noch
-    // mehrmals gerufen werden kann( #46540 )
+    // Delete UpdateTargetList, because this method can still be called several
+    // times before the update timer is turned on
     for ( size_t i = 0, n = pOwnData->aUpdateTargetList.size(); i < n; ++i )
         delete pOwnData->aUpdateTargetList[ i ];
     pOwnData->aUpdateTargetList.clear();
 
-    // TargetListe muss kopiert werden, da sie im
-    // Besitz des Aufrufers ist und von ihm nach diesem
-    // Aufruf sofort geloescht werden kann;
-    // die kopierte Liste wird im Handler wieder geloescht
+    // TargetList must be copied, since it is owned by the caller and can be
+    // deleted immediately after this call the copied list will be deleted
+    // again in the handler
     if( pTargetList )
     {
         TargetList aTargetList( *pTargetList );
@@ -466,11 +366,7 @@ void SvxIMapDlg::KeyInput( const KeyEvent& rKEvt )
         SfxModelessDialog::KeyInput( rKEvt );
 }
 
-/*************************************************************************
-|*
-|* Click-Hdl fuer ToolBox
-|*
-\************************************************************************/
+// Click-handler for ToolBox
 
 IMPL_LINK( SvxIMapDlg, TbxClickHdl, ToolBox*, pTbx )
 {
@@ -613,13 +509,6 @@ IMPL_LINK( SvxIMapDlg, TbxClickHdl, ToolBox*, pTbx )
     return 0;
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void SvxIMapDlg::DoOpen()
 {
        ::sfx2::FileDialogHelper aDlg(
@@ -661,13 +550,6 @@ void SvxIMapDlg::DoOpen()
     }
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 BOOL SvxIMapDlg::DoSave()
 {
        ::sfx2::FileDialogHelper aDlg(
@@ -742,13 +624,6 @@ BOOL SvxIMapDlg::DoSave()
     return bRet;
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 IMPL_LINK( SvxIMapDlg, InfoHdl, IMapWindow*, pWnd )
 {
     String              aStr;
@@ -817,12 +692,6 @@ IMPL_LINK( SvxIMapDlg, InfoHdl, IMapWindow*, pWnd )
     return 0;
 }
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 IMPL_LINK( SvxIMapDlg, MousePosHdl, IMapWindow*, pWnd )
 {
     String aStr;
@@ -840,12 +709,6 @@ IMPL_LINK( SvxIMapDlg, MousePosHdl, IMapWindow*, pWnd )
     return 0L;
 }
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 IMPL_LINK( SvxIMapDlg, GraphSizeHdl, IMapWindow*, pWnd )
 {
     String aStr;
@@ -863,12 +726,6 @@ IMPL_LINK( SvxIMapDlg, GraphSizeHdl, IMapWindow*, pWnd )
     return 0L;
 }
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 IMPL_LINK( SvxIMapDlg, URLModifyHdl, void*, EMPTYARG )
 {
     NotifyInfo  aNewInfo;
@@ -882,13 +739,6 @@ IMPL_LINK( SvxIMapDlg, URLModifyHdl, void*, EMPTYARG )
     return 0;
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 IMPL_LINK( SvxIMapDlg, URLLoseFocusHdl, void*, EMPTYARG )
 {
     NotifyInfo      aNewInfo;
@@ -917,13 +767,6 @@ IMPL_LINK( SvxIMapDlg, URLLoseFocusHdl, void*, EMPTYARG )
     return 0;
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 IMPL_LINK( SvxIMapDlg, UpdateHdl, Timer*, EMPTYARG )
 {
     pOwnData->aTimer.Stop();
@@ -942,12 +785,12 @@ IMPL_LINK( SvxIMapDlg, UpdateHdl, Timer*, EMPTYARG )
         SetTargetList( pOwnData->aUpdateTargetList );
         SetEditingObject( pOwnData->pUpdateEditingObject );
 
-        // Nach Wechsel => default Selektion
+        // After changes => default selection
         aTbxIMapDlg1.CheckItem( TBI_SELECT, TRUE );
         pIMapWnd->SetEditMode( TRUE );
     }
 
-    // die in der Update-Methode kopierte Liste wieder loeschen
+    // Delete the copied list again in the Update method
     for ( size_t i = 0, n = pOwnData->aUpdateTargetList.size(); i < n; ++i )
         delete pOwnData->aUpdateTargetList[ i ];
     pOwnData->aUpdateTargetList.clear();
@@ -957,13 +800,6 @@ IMPL_LINK( SvxIMapDlg, UpdateHdl, Timer*, EMPTYARG )
     return 0L;
 }
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 IMPL_LINK( SvxIMapDlg, StateHdl, IMapWindow*, pWnd )
 {
     const SdrObject*    pObj = pWnd->GetSelectedSdrObject();
@@ -1016,12 +852,6 @@ IMPL_LINK( SvxIMapDlg, StateHdl, IMapWindow*, pWnd )
     return 0L;
 }
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 IMPL_LINK( SvxIMapDlg, MiscHdl, void*, EMPTYARG )
 {
        SvtMiscOptions aMiscOptions;
diff --git a/svx/source/dialog/imapdlg.hrc b/svx/source/dialog/imapdlg.hrc
index ecc6b83332cc..07cdf696eea1 100644
--- a/svx/source/dialog/imapdlg.hrc
+++ b/svx/source/dialog/imapdlg.hrc
@@ -27,7 +27,7 @@
 #include <svx/dialogs.hrc>
 
 
-// ImapDlg-Dialoge
+// ImapDlg-Dialog
 #define RID_SVX_IMAPDLG_START   RID_SVX_IMAP_START
 
 
diff --git a/svx/source/dialog/imapwnd.cxx b/svx/source/dialog/imapwnd.cxx
index b9a7727e40c7..5a483012277a 100644
--- a/svx/source/dialog/imapwnd.cxx
+++ b/svx/source/dialog/imapwnd.cxx
@@ -67,12 +67,6 @@ using ::com::sun::star::uno::Reference;
 
 #define TRANSCOL Color( COL_WHITE )
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 IMapWindow::IMapWindow( Window* pParent, const ResId& rResId, const Reference< XFrame >& rxDocumentFrame ) :
             GraphCtrl( pParent, rResId ),
             DropTargetHelper( this ),
@@ -87,15 +81,9 @@ IMapWindow::IMapWindow( Window* pParent, const ResId& rResId, const Reference< X
     pIMapPool->FreezeIdRanges();
 }
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 IMapWindow::~IMapWindow()
 {
-    // Liste loeschen
+    // Delete Liste
     for ( size_t i = 0, n = aTargetList.size(); i < n; ++i )
         delete aTargetList[ i ];
 
@@ -103,23 +91,11 @@ IMapWindow::~IMapWindow()
     delete[] pItemInfo;
 }
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void IMapWindow::SetImageMap( const ImageMap& rImageMap )
 {
     ReplaceImageMap( rImageMap, FALSE );
 }
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void IMapWindow::ReplaceImageMap( const ImageMap& rImageMap, BOOL /*bScaleToGraphic*/ )
 {
     SdrPage* pPage = 0;
@@ -157,12 +133,6 @@ void IMapWindow::ReplaceImageMap( const ImageMap& rImageMap, BOOL /*bScaleToGrap
     }
 }
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 BOOL IMapWindow::ReplaceActualIMapInfo( const NotifyInfo& rNewInfo )
 {
     const SdrObject*    pSdrObj = GetSelectedSdrObject();
@@ -183,12 +153,6 @@ BOOL IMapWindow::ReplaceActualIMapInfo( const NotifyInfo& rNewInfo )
     return bRet;
 }
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 const ImageMap& IMapWindow::GetImageMap()
 {
     if ( pModel->IsChanged() )
@@ -211,32 +175,20 @@ const ImageMap& IMapWindow::GetImageMap()
     return aIMap;
 }
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void IMapWindow::SetTargetList( TargetList& rTargetList )
 {
-    // alte Liste loeschen
+    // Delete old List
     for( size_t i = 0, n = aTargetList.size(); i < n; ++i )
         delete aTargetList[ i ];
     aTargetList.clear();
 
-    // mit uebergebener Liste fuellen
+    // Fill with the provided list
     for( size_t i = 0, n = rTargetList.size(); i < n; ++i )
         aTargetList.push_back( new String( *rTargetList[ i ] ) );
 
     pModel->SetChanged( sal_False );
 }
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 SdrObject* IMapWindow::CreateObj( const IMapObject* pIMapObj )
 {
     Point       aPoint;
@@ -251,7 +203,7 @@ SdrObject* IMapWindow::CreateObj( const IMapObject* pIMapObj )
             IMapRectangleObject*    pIMapRectObj = (IMapRectangleObject*) pIMapObj;
             Rectangle               aDrawRect( pIMapRectObj->GetRectangle( FALSE ) );
 
-            // auf Zeichenflaeche clippen
+            // clipped on CanvasPane
             aDrawRect.Intersection( aClipRect );
 
             pSdrObj = (SdrObject*) new SdrRectObj( aDrawRect );
@@ -267,7 +219,7 @@ SdrObject* IMapWindow::CreateObj( const IMapObject* pIMapObj )
             const Point         aOffset( nRadius, nRadius );
             Rectangle           aCircle( aCenter - aOffset, aCenter + aOffset );
 
-            // auf Zeichenflaeche begrenzen
+            // limited to CanvasPane
             aCircle.Intersection( aClipRect );
 
             pSdrObj = (SdrObject*) new SdrCircObj( OBJ_CIRC, aCircle, 0, 36000 );
@@ -279,13 +231,12 @@ SdrObject* IMapWindow::CreateObj( const IMapObject* pIMapObj )
         {
             IMapPolygonObject*  pIMapPolyObj = (IMapPolygonObject*) pIMapObj;
 
-            // Falls wir eigentlich eine Ellipse sind,
-            // erzeugen wir auch wieder eine Ellipse
+            // If it actually is an ellipse, then another ellipse is created again
             if ( pIMapPolyObj->HasExtraEllipse() )
             {
                 Rectangle aDrawRect( pIMapPolyObj->GetExtraEllipse() );
 
-                // auf Zeichenflaeche clippen
+                // clipped on CanvasPane
                 aDrawRect.Intersection( aClipRect );
 
                 pSdrObj = (SdrObject*) new SdrCircObj( OBJ_CIRC, aDrawRect, 0, 36000 );
@@ -295,7 +246,7 @@ SdrObject* IMapWindow::CreateObj( const IMapObject* pIMapObj )
                 const Polygon&  rPoly = pIMapPolyObj->GetPolygon( FALSE );
                 Polygon         aDrawPoly( rPoly );
 
-                // auf Zeichenflaeche clippen
+                // clipped on CanvasPane
                 aDrawPoly.Clip( aClipRect );
 
                 basegfx::B2DPolygon aPolygon;
@@ -329,7 +280,6 @@ SdrObject* IMapWindow::CreateObj( const IMapObject* pIMapObj )
             aSet.Put( XLineColorItem( String(), Color( COL_BLACK ) ) );
         }
 
-        //pSdrObj->SetItemSetAndBroadcast(aSet);
         pSdrObj->SetMergedItemSetAndBroadcast(aSet);
 
         pSdrObj->InsertUserData( new IMapUserData( pCloneIMapObj ) );
@@ -339,12 +289,6 @@ SdrObject* IMapWindow::CreateObj( const IMapObject* pIMapObj )
     return pSdrObj;
 }
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void IMapWindow::InitSdrModel()
 {
     GraphCtrl::InitSdrModel();
@@ -357,12 +301,6 @@ void IMapWindow::InitSdrModel()
     pView->SetFrameDragSingles( TRUE );
 }
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void IMapWindow::SdrObjCreated( const SdrObject& rObj )
 {
     switch( rObj.GetObjIdentifier() )
@@ -412,12 +350,6 @@ void IMapWindow::SdrObjCreated( const SdrObject& rObj )
     }
 }
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void IMapWindow::SdrObjChanged( const SdrObject& rObj )
 {
     IMapUserData* pUserData = (IMapUserData*) rObj.GetUserData( 0 );
@@ -458,7 +390,7 @@ void IMapWindow::SdrObjChanged( const SdrObject& rObj )
                 IMapPolygonObject* pObj = new IMapPolygonObject( aPoly, aURL, aAltText, aDesc, aTarget, String(), bActive, FALSE );
                 pObj->SetExtraEllipse( aPoly.GetBoundRect() );
 
-                // wurde von uns nur temporaer angelegt
+                // was only created by us temporarily
                 delete pPathObj;
                 pUserData->ReplaceObject( IMapObjectPtr(pObj) );
             }
@@ -487,36 +419,18 @@ void IMapWindow::SdrObjChanged( const SdrObject& rObj )
     }
 }
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void IMapWindow::MouseButtonUp(const MouseEvent& rMEvt)
 {
     GraphCtrl::MouseButtonUp( rMEvt );
     UpdateInfo( TRUE );
 }
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void IMapWindow::MarkListHasChanged()
 {
     GraphCtrl::MarkListHasChanged();
     UpdateInfo( FALSE );
 }
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 SdrObject* IMapWindow::GetHitSdrObj( const Point& rPosPixel ) const
 {
     SdrObject*  pObj = NULL;
@@ -546,12 +460,6 @@ SdrObject* IMapWindow::GetHitSdrObj( const Point& rPosPixel ) const
     return pObj;
 }
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 IMapObject* IMapWindow::GetIMapObj( const SdrObject* pSdrObj ) const
 {
     IMapObject* pIMapObj = NULL;
@@ -567,12 +475,6 @@ IMapObject* IMapWindow::GetIMapObj( const SdrObject* pSdrObj ) const
     return pIMapObj;
 }
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 SdrObject* IMapWindow::GetSdrObj( const IMapObject* pIMapObj ) const
 {
     SdrObject*  pSdrObj = NULL;
@@ -596,12 +498,6 @@ SdrObject* IMapWindow::GetSdrObj( const IMapObject* pIMapObj ) const
     return pSdrObj;
 }
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void IMapWindow::Command(const CommandEvent& rCEvt)
 {
     Region  aRegion;
@@ -653,23 +549,11 @@ void IMapWindow::Command(const CommandEvent& rCEvt)
         Window::Command(rCEvt);
 }
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 sal_Int8 IMapWindow::AcceptDrop( const AcceptDropEvent& rEvt )
 {
     return( ( GetHitSdrObj( rEvt.maPosPixel ) != NULL ) ? rEvt.mnAction : DND_ACTION_NONE );
 }
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 sal_Int8 IMapWindow::ExecuteDrop( const ExecuteDropEvent& rEvt )
 {
     sal_Int8 nRet = DND_ACTION_NONE;
@@ -697,12 +581,6 @@ sal_Int8 IMapWindow::ExecuteDrop( const ExecuteDropEvent& rEvt )
     return nRet;
 }
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void IMapWindow::RequestHelp( const HelpEvent& rHEvt )
 {
     SdrObject*          pSdrObj = NULL;
@@ -734,12 +612,6 @@ void IMapWindow::RequestHelp( const HelpEvent& rHEvt )
     }
 }
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void IMapWindow::SetCurrentObjState( BOOL bActive )
 {
     SdrObject* pObj = GetSelectedSdrObject();
@@ -767,12 +639,6 @@ void IMapWindow::SetCurrentObjState( BOOL bActive )
     }
 }
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void IMapWindow::UpdateInfo( BOOL bNewObj )
 {
     if ( aInfoLink.IsSet() )
@@ -802,12 +668,6 @@ void IMapWindow::UpdateInfo( BOOL bNewObj )
     }
 }
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void IMapWindow::DoMacroAssign()
 {
     SdrObject*  pSdrObj = GetSelectedSdrObject();
@@ -841,12 +701,6 @@ void IMapWindow::DoMacroAssign()
     }
 }
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 void IMapWindow::DoPropertyDialog()
 {
     SdrObject*  pSdrObj = GetSelectedSdrObject();
@@ -885,12 +739,6 @@ void IMapWindow::DoPropertyDialog()
     }
 }
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 IMPL_LINK( IMapWindow, MenuSelectHdl, Menu*, pMenu )
 {
     if (pMenu)
diff --git a/svx/source/dialog/imapwnd.hxx b/svx/source/dialog/imapwnd.hxx
index fbf36a49c55f..108c489229e5 100644
--- a/svx/source/dialog/imapwnd.hxx
+++ b/svx/source/dialog/imapwnd.hxx
@@ -41,12 +41,6 @@
 
 #include <com/sun/star/frame/XFrame.hpp>
 
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 struct NotifyInfo
 {
     String  aMarkURL;
@@ -66,13 +60,6 @@ struct NotifyPosSize
     BOOL    bMousePos;
 };
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 #define SVD_IMAP_USERDATA   0x0001
 
 const UINT32 IMapInventor = UINT32('I') * 0x00000001+
@@ -111,13 +98,6 @@ public:
     void                    ReplaceObject( const IMapObjectPtr& pNewIMapObject ) { mpObj = pNewIMapObject; }
 };
 
-
-/*************************************************************************
-|*
-|*
-|*
-\************************************************************************/
-
 class IMapWindow : public GraphCtrl, public DropTargetHelper
 {
     NotifyInfo          aInfo;
diff --git a/svx/source/dialog/langbox.cxx b/svx/source/dialog/langbox.cxx
index b2b52dd37e57..531f2eb6b650 100644
--- a/svx/source/dialog/langbox.cxx
+++ b/svx/source/dialog/langbox.cxx
@@ -514,10 +514,6 @@ bool SvxLanguageBox::IsLanguageSelected( const LanguageType/*type*/) const
     return true;
 }
 
-/*IMPL_IMPL (SvxLanguageBox, ListBox);
-IMPL_CONSTRUCTORS ( SvxLanguageBox, ListBox, "svxlanguagebox" );
-IMPL_GET_IMPL( SvxLanguageBox );
-IMPL_GET_WINDOW (SvxLanguageBox);*/
 };
 
 #endif
diff --git a/svx/source/dialog/measctrl.cxx b/svx/source/dialog/measctrl.cxx
index 5e26a9d64116..28c803322cb4 100644
--- a/svx/source/dialog/measctrl.cxx
+++ b/svx/source/dialog/measctrl.cxx
@@ -38,12 +38,6 @@
 #include <svx/dialmgr.hxx>
 #include "dlgutil.hxx"
 
-/*************************************************************************
-|*
-|* Ctor SvxXMeasurePreview
-|*
-*************************************************************************/
-
 SvxXMeasurePreview::SvxXMeasurePreview
 (
     Window* pParent,
@@ -59,7 +53,7 @@ SvxXMeasurePreview::SvxXMeasurePreview
 
     Size aSize = GetOutputSize();
 
-    // Massstab: 1:2
+    // Scale: 1:2
     MapMode aMapMode = GetMapMode();
     aMapMode.SetScaleX( Fraction( 1, 2 ) );
     aMapMode.SetScaleY( Fraction( 1, 2 ) );
@@ -73,7 +67,6 @@ SvxXMeasurePreview::SvxXMeasurePreview
     pModel = new SdrModel();
     pMeasureObj->SetModel( pModel );
 
-    //pMeasureObj->SetItemSetAndBroadcast(rInAttrs);
     pMeasureObj->SetMergedItemSetAndBroadcast(rInAttrs);
 
     SetDrawMode( GetSettings().GetStyleSettings().GetHighContrastMode() ? OUTPUT_DRAWMODE_CONTRAST : OUTPUT_DRAWMODE_COLOR );
@@ -81,15 +74,8 @@ SvxXMeasurePreview::SvxXMeasurePreview
     Invalidate();
 }
 
-/*************************************************************************
-|*
-|* Dtor SvxXMeasurePreview
-|*
-*************************************************************************/
-
 SvxXMeasurePreview::~SvxXMeasurePreview()
 {
-    // #111111#
     // No one is deleting the MeasureObj? This is not only an error but also
     // a memory leak (!). Main problem is that this object is still listening to
     // a StyleSheet of the model which was set. Thus, if You want to keep the obnject,
@@ -100,37 +86,18 @@ SvxXMeasurePreview::~SvxXMeasurePreview()
     delete pModel;
 }
 
-/*************************************************************************
-|*
-|* SvxXMeasurePreview: Paint()
-|*
-*************************************************************************/
-
 void SvxXMeasurePreview::Paint( const Rectangle&  )
 {
-    pMeasureObj->SingleObjectPainter(*this); // #110094#-17
+    pMeasureObj->SingleObjectPainter(*this);
 }
 
-/*************************************************************************
-|*
-|* SvxXMeasurePreview: SetAttributes()
-|*
-*************************************************************************/
-
 void SvxXMeasurePreview::SetAttributes( const SfxItemSet& rInAttrs )
 {
-    //pMeasureObj->SetItemSetAndBroadcast(rInAttrs);
     pMeasureObj->SetMergedItemSetAndBroadcast(rInAttrs);
 
     Invalidate();
 }
 
-/*************************************************************************
-|*
-|* SvxXMeasurePreview: SetAttributes()
-|*
-*************************************************************************/
-
 void SvxXMeasurePreview::MouseButtonDown( const MouseEvent& rMEvt )
 {
     BOOL bZoomIn  = rMEvt.IsLeft() && !rMEvt.IsShift();
diff --git a/svx/source/dialog/optgrid.cxx b/svx/source/dialog/optgrid.cxx
index c50286db6ee1..363bb827f0b9 100644
--- a/svx/source/dialog/optgrid.cxx
+++ b/svx/source/dialog/optgrid.cxx
@@ -61,10 +61,6 @@ void    lcl_SetMinMax(MetricField& rField, long nFirst, long nLast, long nMin, l
     rField.SetMax( rField.Normalize( nMax ), FUNIT_TWIP );
 }
 
-/*--------------------------------------------------------------------
-    Beschreibung: Rastereinstellungen Ctor
- --------------------------------------------------------------------*/
-
 SvxOptionsGrid::SvxOptionsGrid() :
     nFldDrawX       ( 100 ),
     nFldDivisionX   ( 0 ),
@@ -79,18 +75,10 @@ SvxOptionsGrid::SvxOptionsGrid() :
 {
 }
 
-/*--------------------------------------------------------------------
-    Beschreibung: Rastereinstellungen Dtor
- --------------------------------------------------------------------*/
-
 SvxOptionsGrid::~SvxOptionsGrid()
 {
 }
 
-/*--------------------------------------------------------------------
-    Beschreibung: Item fuer Rastereinstellungen
- --------------------------------------------------------------------*/
-
 SvxGridItem::SvxGridItem( const SvxGridItem& rItem )
 :   SvxOptionsGrid()
 ,   SfxPoolItem(rItem)
@@ -115,7 +103,7 @@ SfxPoolItem*  SvxGridItem::Clone( SfxItemPool* ) const
 
 int SvxGridItem::operator==( const SfxPoolItem& rAttr ) const
 {
-    DBG_ASSERT( SfxPoolItem::operator==(rAttr), "unterschiedliche Typen" );
+    DBG_ASSERT( SfxPoolItem::operator==(rAttr), "different types ");
 
     const SvxGridItem& rItem = (const SvxGridItem&) rAttr;
 
@@ -153,7 +141,7 @@ SfxItemPresentation  SvxGridItem::GetPresentation
     }
 }
 
-// TabPage Rastereinstellungen
+// TabPage Screen Settings
 SvxGridTabPage::SvxGridTabPage( Window* pParent, const SfxItemSet& rCoreSet) :
 
     SfxTabPage( pParent, SVX_RES( RID_SVXPAGE_GRID ), rCoreSet ),
@@ -199,13 +187,13 @@ SvxGridTabPage::SvxGridTabPage( Window* pParent, const SfxItemSet& rCoreSet) :
 
     bAttrModified( FALSE )
 {
-    // diese Page braucht ExchangeSupport
+    // This page requires exchange Support
     SetExchangeSupport();
 
     FreeResource();
 
     aDivisionPointY.SetText(aDivisionPointX.GetText());
-    // Metrik einstellen
+    // Set Metrics
     FieldUnit eFUnit = GetModuleFieldUnit( rCoreSet );
     long nFirst, nLast, nMin, nMax;
 
@@ -286,10 +274,6 @@ void SvxGridTabPage::Reset( const SfxItemSet& rSet )
         SetMetricValue( aMtrFldDrawX , pGridAttr->nFldDrawX, eUnit );
         SetMetricValue( aMtrFldDrawY , pGridAttr->nFldDrawY, eUnit );
 
-//      UINT32 nFineX = pGridAttr->nFldDivisionX;
-//      UINT32 nFineY = pGridAttr->nFldDivisionY;
-//      aNumFldDivisionX.SetValue( nFineX ? (pGridAttr->nFldDrawX / nFineX - 1) : 0 );
-//      aNumFldDivisionY.SetValue( nFineY ? (pGridAttr->nFldDrawY / nFineY - 1) : 0 );
         aNumFldDivisionX.SetValue( pGridAttr->nFldDivisionX );
         aNumFldDivisionY.SetValue( pGridAttr->nFldDivisionY );
     }
@@ -312,10 +296,8 @@ void SvxGridTabPage::ActivatePage( const SfxItemSet& rSet )
         ChangeGridsnapHdl_Impl( &aCbxUseGridsnap );
     }
 
-    // Metrik ggfs. aendern (da TabPage im Dialog liegt,
-    // wo die Metrik eingestellt werden kann
-    //USHORT nWhich = GetWhich( SID_ATTR_METRIC );
-    //if( rSet.GetItemState( GetWhich( SID_ATTR_METRIC ) ) >= SFX_ITEM_AVAILABLE )
+    // Metric Change if necessary (as TabPage is in the dialog, where the
+    // metric can be set
     if( SFX_ITEM_SET == rSet.GetItemState( SID_ATTR_METRIC , FALSE,
                                     (const SfxPoolItem**)&pAttr ))
     {
@@ -325,7 +307,7 @@ void SvxGridTabPage::ActivatePage( const SfxItemSet& rSet )
 
         if( eFUnit != aMtrFldDrawX.GetUnit() )
         {
-            // Metriken einstellen
+            // Set Metrics
             long nFirst, nLast, nMin, nMax;
             long nVal = static_cast<long>(aMtrFldDrawX.Denormalize( aMtrFldDrawX.GetValue( FUNIT_TWIP ) ));
 
diff --git a/svx/source/dialog/pagectrl.cxx b/svx/source/dialog/pagectrl.cxx
index a5307103813f..b0e8dd35e39b 100644
--- a/svx/source/dialog/pagectrl.cxx
+++ b/svx/source/dialog/pagectrl.cxx
@@ -102,7 +102,7 @@ SvxPageWindow::SvxPageWindow( Window* pParent, const ResId& rId ) :
 {
     pImpl = new PageWindow_Impl;
 
-    // defaultmaessing in Twips rechnen
+    // Count in Twips by default
     SetMapMode( MapMode( MAP_TWIP ) );
     aWinSize = GetOutputSizePixel();
     aWinSize.Height() -= 4;
@@ -145,10 +145,10 @@ void SvxPageWindow::Paint( const Rectangle& )
 
     if ( eUsage == SVX_PAGE_ALL )
     {
-        // alle Seiten gleich -> eine Seite malen
+        // all pages are equal -> draw one page
         if ( aSize.Width() > aSize.Height() )
         {
-            // Querformat in gleicher Gr"osse zeichnen
+            // Draw Landscape page of the same size
             Fraction aX = aMapMode.GetScaleX();
             Fraction aY = aMapMode.GetScaleY();
             Fraction a2( 1.5 );
@@ -163,12 +163,12 @@ void SvxPageWindow::Paint( const Rectangle& )
             DrawPage( Point( nXPos, nYPos ), TRUE, TRUE );
         }
         else
-            // Hochformat
+            // Portrait
             DrawPage( Point( ( aSz.Width() - aSize.Width() ) / 2, nYPos ), TRUE, TRUE );
     }
     else
     {
-        // Linke und rechte Seite unterschiedlich -> ggf. zwei Seiten malen
+        // Left and right page are different -> draw two pages if possible
         DrawPage( Point( 0, nYPos ), FALSE, (BOOL)( eUsage & SVX_PAGE_LEFT ) );
         DrawPage( Point( aSize.Width() + aSize.Width() / 8, nYPos ), TRUE,
                   (BOOL)( eUsage & SVX_PAGE_RIGHT ) );
@@ -196,9 +196,9 @@ void SvxPageWindow::DrawPage( const Point& rOrg, const BOOL bSecond, const BOOL
             pImpl->bResetBackground = sal_False;
     }
     SetLineColor( rFieldTextColor );
-    // Schatten
+    // Shadow
     Size aTempSize = aSize;
-    // Seite
+    // Page
     if ( !bEnabled )
     {
         SetFillColor( rDisableColor );
@@ -217,7 +217,7 @@ void SvxPageWindow::DrawPage( const Point& rOrg, const BOOL bSecond, const BOOL
 
     if ( eUsage == SVX_PAGE_MIRROR && !bSecond )
     {
-        // f"ur gespiegelt drehen
+        // turn for mirrored
         nL = nRight;
         nR = nLeft;
     }
@@ -234,7 +234,7 @@ void SvxPageWindow::DrawPage( const Point& rOrg, const BOOL bSecond, const BOOL
 
     if ( bHeader )
     {
-        // ggf. Header anzeigen
+        // show headers if possible
         aHdRect.Left() += nHdLeft;
         aHdRect.Right() -= nHdRight;
         aHdRect.Bottom() = aRect.Top() + nHdHeight;
@@ -245,7 +245,7 @@ void SvxPageWindow::DrawPage( const Point& rOrg, const BOOL bSecond, const BOOL
 
     if ( bFooter )
     {
-        // ggf. Footer anzeigen
+        // show footer if possible
         aFtRect.Left() += nFtLeft;
         aFtRect.Right() -= nFtRight;
         aFtRect.Top() = aRect.Bottom() - nFtHeight;
@@ -254,7 +254,7 @@ void SvxPageWindow::DrawPage( const Point& rOrg, const BOOL bSecond, const BOOL
         DrawRect( aFtRect );
     }
 
-    // Body malen
+    // Paint Body
     SetFillColor( aColor );
     if ( pImpl->bBitmap )
     {
@@ -274,7 +274,6 @@ void SvxPageWindow::DrawPage( const Point& rOrg, const BOOL bSecond, const BOOL
 
     if(pImpl->bFrameDirection && !bTable)
     {
-       //pImpl->nFrameDirection
         Point aPos;
         Font aFont(GetFont());
         const Size aSaveSize = aFont.GetSize();
@@ -340,7 +339,7 @@ void SvxPageWindow::DrawPage( const Point& rOrg, const BOOL bSecond, const BOOL
     }
     if ( bTable )
     {
-        // Tabelle malen, ggf. zentrieren
+        // Paint Table, if necessary center it
         SetLineColor( Color(COL_LIGHTGRAY) );
 
         long nW = aRect.GetWidth(), nH = aRect.GetHeight();
diff --git a/svx/source/dialog/paraprev.cxx b/svx/source/dialog/paraprev.cxx
index 73f9a5c4ff39..88a8f6caedc7 100644
--- a/svx/source/dialog/paraprev.cxx
+++ b/svx/source/dialog/paraprev.cxx
@@ -54,7 +54,7 @@ SvxParaPrevWindow::SvxParaPrevWindow( Window* pParent, const ResId& rId ) :
     nLineVal        ( 0 )
 
 {
-    // defaultmaessing in Twips rechnen
+    // Count in Twips by default
     SetMapMode( MapMode( MAP_TWIP ) );
     aWinSize = GetOutputSizePixel();
     aWinSize = PixelToLogic( aWinSize );
@@ -220,7 +220,7 @@ void SvxParaPrevWindow::DrawParagraph( BOOL bAll )
         }
 
         aPnt.Y() += nH;
-        // wieder zuruecksetzen, fuer jede Linie neu berechnen
+        // Reset, recalculate for each line
         aPnt.X() = DEF_MARGIN / 2;
         aSiz = aLineSiz;
     }
diff --git a/svx/source/dialog/pfiledlg.cxx b/svx/source/dialog/pfiledlg.cxx
index d4383cb8093b..9f0e85bd7d0d 100644
--- a/svx/source/dialog/pfiledlg.cxx
+++ b/svx/source/dialog/pfiledlg.cxx
@@ -48,11 +48,7 @@ using namespace ::com::sun::star;
 sal_Char const sAudio[] = "audio";
 sal_Char const sVideo[] = "video";
 
-/*************************************************************************
-|*
-|* Filedialog to insert Plugin-Fileformats
-|*
-\************************************************************************/
+// Filedialog to insert Plugin-Fileformats
 
 ErrCode SvxPluginFileDlg::Execute()
 {
@@ -196,12 +192,6 @@ SvxPluginFileDlg::SvxPluginFileDlg (Window *, sal_uInt16 nKind ) :
     maFileDlg.SetCurrentFilter( aAllFilter );
 }
 
-/*************************************************************************
-|*
-|* Dtor
-|*
-\************************************************************************/
-
 SvxPluginFileDlg::~SvxPluginFileDlg()
 {
 }
@@ -209,7 +199,7 @@ SvxPluginFileDlg::~SvxPluginFileDlg()
 /*************************************************************************
 |*
 |* Plugins available for the the MIME-Typ in nKind
-|* (whith nKind = SID_INSERT_SOUND for MIME-Type audio
+|* (with nKind = SID_INSERT_SOUND for MIME-Type audio
 |*                SID_INSERT_VIDEO for MIME-Type video
 |*
 \************************************************************************/
diff --git a/svx/source/dialog/rlrcitem.cxx b/svx/source/dialog/rlrcitem.cxx
index bd6475dfc877..cc79e618aeb8 100644
--- a/svx/source/dialog/rlrcitem.cxx
+++ b/svx/source/dialog/rlrcitem.cxx
@@ -67,7 +67,7 @@ void SvxRulerItem::StateChanged( USHORT nSID, SfxItemState eState,
 
     switch(nSID)
     {
-        // Linker / rechter Seitenrand
+        // Left / right margin
         case SID_RULER_LR_MIN_MAX:
         {
             const SfxRectangleItem *pItem = PTR_CAST(SfxRectangleItem, pState);
@@ -77,14 +77,14 @@ void SvxRulerItem::StateChanged( USHORT nSID, SfxItemState eState,
         case SID_ATTR_LONG_LRSPACE:
         {
             const SvxLongLRSpaceItem *pItem = PTR_CAST(SvxLongLRSpaceItem, pState);
-            DBG_ASSERT(pState? 0 != pItem: TRUE, "SvxLRSpaceItem erwartet");
+            DBG_ASSERT(pState? 0 != pItem: TRUE, "SvxLRSpaceItem expected");
             rRuler.UpdateFrame(pItem);
             break;
         }
         case SID_ATTR_LONG_ULSPACE:
         {
             const SvxLongULSpaceItem *pItem = PTR_CAST(SvxLongULSpaceItem, pState);
-            DBG_ASSERT(pState? 0 != pItem: TRUE, "SvxULSpaceItem erwartet");
+            DBG_ASSERT(pState? 0 != pItem: TRUE, "SvxULSpaceItem expected");
             rRuler.UpdateFrame(pItem);
             break;
         }
@@ -92,7 +92,7 @@ void SvxRulerItem::StateChanged( USHORT nSID, SfxItemState eState,
         case SID_ATTR_TABSTOP:
         {
             const SvxTabStopItem *pItem = PTR_CAST(SvxTabStopItem, pState);
-            DBG_ASSERT(pState?  0 != pItem: TRUE, "SvxTabStopItem erwartet");
+            DBG_ASSERT(pState?  0 != pItem: TRUE, "SvxTabStopItem expected");
             rRuler.Update(pItem);
             break;
         }
@@ -100,7 +100,7 @@ void SvxRulerItem::StateChanged( USHORT nSID, SfxItemState eState,
         case SID_ATTR_PARA_LRSPACE:
         {
             const SvxLRSpaceItem *pItem = PTR_CAST(SvxLRSpaceItem, pState);
-            DBG_ASSERT(pState?  0 != pItem: TRUE, "SvxLRSpaceItem erwartet");
+            DBG_ASSERT(pState?  0 != pItem: TRUE, "SvxLRSpaceItem expected");
             rRuler.UpdatePara(pItem);
             break;
         }
@@ -110,14 +110,14 @@ void SvxRulerItem::StateChanged( USHORT nSID, SfxItemState eState,
         case SID_RULER_ROWS_VERTICAL:
         {
             const SvxColumnItem *pItem = PTR_CAST(SvxColumnItem, pState);
-            DBG_ASSERT(pState?  0 != pItem: TRUE, "SvxColumnItem erwartet");
+            DBG_ASSERT(pState?  0 != pItem: TRUE, "SvxColumnItem expected");
 #ifdef DBG_UTIL
             if(pItem)
             {
                 if(pItem->IsConsistent())
                     rRuler.Update(pItem, nSID);
                 else
-                    DBG_ERROR("Spaltenitem corrupted");
+                    DBG_ERROR("Column item corrupted");
             }
             else
                 rRuler.Update(pItem, nSID);
@@ -127,37 +127,37 @@ void SvxRulerItem::StateChanged( USHORT nSID, SfxItemState eState,
             break;
         }
         case SID_RULER_PAGE_POS:
-        {   // Position Seite, Seitenbreite
+        {   // Position page, page width
             const SvxPagePosSizeItem *pItem = PTR_CAST(SvxPagePosSizeItem, pState);
-            DBG_ASSERT(pState?  0 != pItem: TRUE, "SvxPagePosSizeItem erwartet");
+            DBG_ASSERT(pState?  0 != pItem: TRUE, "SvxPagePosSizeItem expected");
             rRuler.Update(pItem);
             break;
         }
         case SID_RULER_OBJECT:
-        {   // Object-Selektion
+        {   // Object selection
             const SvxObjectItem *pItem = PTR_CAST(SvxObjectItem, pState);
-            DBG_ASSERT(pState?  0 != pItem: TRUE, "SvxObjectItem erwartet");
+            DBG_ASSERT(pState?  0 != pItem: TRUE, "SvxObjectItem expected");
             rRuler.Update(pItem);
             break;
         }
         case SID_RULER_PROTECT:
         {
             const SvxProtectItem *pItem = PTR_CAST(SvxProtectItem, pState);
-            DBG_ASSERT(pState?  0 != pItem: TRUE, "SvxProtectItem erwartet");
+            DBG_ASSERT(pState?  0 != pItem: TRUE, "SvxProtectItem expected");
             rRuler.Update(pItem);
             break;
         }
         case SID_RULER_BORDER_DISTANCE:
         {
             const SvxLRSpaceItem *pItem = PTR_CAST(SvxLRSpaceItem, pState);
-            DBG_ASSERT(pState?  0 != pItem: TRUE, "SvxLRSpaceItem erwartet");
+            DBG_ASSERT(pState?  0 != pItem: TRUE, "SvxLRSpaceItem expected");
             rRuler.UpdateParaBorder(pItem);
         }
         break;
         case SID_RULER_TEXT_RIGHT_TO_LEFT :
         {
             const SfxBoolItem *pItem = PTR_CAST(SfxBoolItem, pState);
-            DBG_ASSERT(pState?  0 != pItem: TRUE, "SfxBoolItem erwartet");
+            DBG_ASSERT(pState?  0 != pItem: TRUE, "SfxBoolItem expected");
             rRuler.UpdateTextRTL(pItem);
         }
         break;
diff --git a/svx/source/dialog/rubydialog.cxx b/svx/source/dialog/rubydialog.cxx
index 258d972c13dd..163c7c2accf0 100644
--- a/svx/source/dialog/rubydialog.cxx
+++ b/svx/source/dialog/rubydialog.cxx
@@ -239,7 +239,7 @@ SvxRubyDialog::SvxRubyDialog( SfxBindings *pBind, SfxChildWindow *pCW,
 {
     xImpl = pImpl = new SvxRubyData_Impl;
     FreeResource();
-    //#85638# automatic detection not yet available
+    // automatic detection not yet available
     aAutoDetectionCB.Hide();
     aEditArr[0] = &aLeft1ED; aEditArr[1] = &aRight1ED;
     aEditArr[2] = &aLeft2ED; aEditArr[3] = &aRight2ED;
diff --git a/svx/source/dialog/ruler.hrc b/svx/source/dialog/ruler.hrc
index 6aa5e4618da4..91abf6fd9c44 100644
--- a/svx/source/dialog/ruler.hrc
+++ b/svx/source/dialog/ruler.hrc
@@ -24,7 +24,7 @@
  * for a copy of the LGPLv3 License.
  *
  ************************************************************************/
-//!! Abhaegigkeit zu sv.hxx
+//!! Dependence on sv.hxx
 #define ID_MM 1
 #define ID_CM 2
 #define ID_M 3
diff --git a/svx/source/dialog/ruler.src b/svx/source/dialog/ruler.src
index ef965a6a7752..3a21d4be5ba5 100644
--- a/svx/source/dialog/ruler.src
+++ b/svx/source/dialog/ruler.src
@@ -65,8 +65,7 @@ Menu RID_SVXMN_RULER
         {
             Identifier = ID_FOOT ;
             Checkable = TRUE ;
-            /* ### ACHTUNG: Neuer Text in Resource? Fuß : Fu˜ */
-            /* ### ACHTUNG: Neuer Text in Resource? Fuß : Fu˜ */
+            /* ### ATTENTION: New text in Resource? Feet : Feet * /
             Text [ en-US ] = "Foot" ;
         };
         MenuItem
diff --git a/svx/source/dialog/rulritem.cxx b/svx/source/dialog/rulritem.cxx
index a89fedfc6715..0e3dbbbb6113 100644
--- a/svx/source/dialog/rulritem.cxx
+++ b/svx/source/dialog/rulritem.cxx
@@ -569,7 +569,7 @@ const SvxColumnItem &SvxColumnItem::operator=(const SvxColumnItem &rCopy)
 BOOL SvxColumnItem::CalcOrtho() const
 {
     const USHORT nCount = Count();
-    DBG_ASSERT(nCount >= 2, "keine Spalten");
+    DBG_ASSERT(nCount >= 2, "no columns");
     if(nCount < 2)
         return FALSE;
 
@@ -578,7 +578,7 @@ BOOL SvxColumnItem::CalcOrtho() const
         if( (*this)[i].GetWidth() != nColWidth)
             return FALSE;
     }
-    //!! Breite Trenner
+    //!! Wide divider
     return TRUE;
 }
 
diff --git a/svx/source/dialog/sdstring.src b/svx/source/dialog/sdstring.src
index fc4662994b69..3b3b1b6c6e7d 100644
--- a/svx/source/dialog/sdstring.src
+++ b/svx/source/dialog/sdstring.src
@@ -28,11 +28,10 @@
 #include <svx/dialogs.hrc>
  // pragma -------------------------------------------------------------------
 
- // Strings fuer die Draw-Dialoge --------------------------------------------
+ // Strings for the Draw-Dialog --------------------------------------------
 String RID_SVXSTR_SOLID
 {
-    /* ### ACHTUNG: Neuer Text in Resource? Durchgängig : Durchgõngig */
-    /* ### ACHTUNG: Neuer Text in Resource? Durchgängig : Durchgõngig */
+    /* ### ATTENTION: New text in Resource? Continuous : Continuous  */
     Text [ en-US ] = "Continuous" ;
 };
 String RID_SVXSTR_GRADIENT
@@ -66,8 +65,7 @@ String RID_SVXSTR_LINEEND
 
 String RID_SVXSTR_CLOSE
 {
-    /* ### ACHTUNG: Neuer Text in Resource? Schließen : Schlie˜en */
-    /* ### ACHTUNG: Neuer Text in Resource? Schließen : Schlie˜en */
+    /* ### ATTENTION: New text in Resource? Close : Close  */
     Text [ en-US ] = "Close" ;
 };
 String RID_SVXSTR_BLACK
@@ -80,14 +78,12 @@ String RID_SVXSTR_BLUE
 };
 String RID_SVXSTR_GREEN
 {
-    /* ### ACHTUNG: Neuer Text in Resource? Grün : Gr³n */
-    /* ### ACHTUNG: Neuer Text in Resource? Grün : Gr³n */
+    /* ### ATTENTION: New text in Resource? Green : Green */
     Text [ en-US ] = "Green" ;
 };
 String RID_SVXSTR_CYAN
 {
-    /* ### ACHTUNG: Neuer Text in Resource? Türkis : T³rkis */
-    /* ### ACHTUNG: Neuer Text in Resource? Türkis : T³rkis */
+    /* ### ATTENTION: New text in Resource? Turquoise : Turquoise */
     Text [ en-US ] = "Turquoise" ;
 };
 String RID_SVXSTR_RED
@@ -96,7 +92,7 @@ String RID_SVXSTR_RED
 };
 String RID_SVXSTR_MAGENTA
 {
-    /* ### ACHTUNG: Neuer Text in Resource? Magenta : Violett */
+    /* ### ATTENTION: New text in Resource? Magenta : Violett */
     Text [ en-US ] = "Magenta" ;
 };
 String RID_SVXSTR_BROWN
@@ -117,14 +113,12 @@ String RID_SVXSTR_LIGHTBLUE
 };
 String RID_SVXSTR_LIGHTGREEN
 {
-    /* ### ACHTUNG: Neuer Text in Resource? Hellgrün : Hellgr³n */
-    /* ### ACHTUNG: Neuer Text in Resource? Hellgrün : Hellgr³n */
+    /* ### ATTENTION: New text in Resource? Light green : Light green */
     Text [ en-US ] = "Light green" ;
 };
 String RID_SVXSTR_LIGHTCYAN
 {
-    /* ### ACHTUNG: Neuer Text in Resource? Helltürkis : Hellt³rkis */
-    /* ### ACHTUNG: Neuer Text in Resource? Helltürkis : Hellt³rkis */
+    /* ### ATTENTION: New text in Resource? Light cyan : Light cyan */
     Text [ en-US ] = "Light cyan" ;
 };
 String RID_SVXSTR_LIGHTRED
@@ -133,7 +127,7 @@ String RID_SVXSTR_LIGHTRED
 };
 String RID_SVXSTR_LIGHTMAGENTA
 {
-    /* ### ACHTUNG: Neuer Text in Resource? Hellmagenta : Hellviolett */
+    /* ### ATTENTION: New text in Resource? Light magenta : Light magenta */
     Text [ en-US ] = "Light magenta" ;
 };
 String RID_SVXSTR_YELLOW
@@ -142,8 +136,7 @@ String RID_SVXSTR_YELLOW
 };
 String RID_SVXSTR_WHITE
 {
-    /* ### ACHTUNG: Neuer Text in Resource? Weiß : Wei˜ */
-    /* ### ACHTUNG: Neuer Text in Resource? Weiß : Wei˜ */
+    /* ### ATTENTION: New text in Resource? White : White */
     Text [ en-US ] = "White" ;
 };
 String RID_SVXSTR_BLUEGREY
@@ -369,138 +362,138 @@ String RID_SVXSTR_LINEJOINT_ROUND
 // Reference-strings for standardcolor-table
 //
 
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_BLACK_DEF
 {
     Text = "Black" ;
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_BLUE_DEF
 {
     Text = "Blue" ;
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_GREEN_DEF
 {
     Text = "Green" ;
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_CYAN_DEF
 {
     Text = "Turquoise" ;
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_RED_DEF
 {
     Text = "Red" ;
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_MAGENTA_DEF
 {
     Text = "Magenta" ;
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_BROWN_DEF
 {
     Text = "Brown" ;
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_GREY_DEF
 {
     Text = "Gray" ;
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_LIGHTGREY_DEF
 {
     Text = "Light gray" ;
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_LIGHTBLUE_DEF
 {
     Text = "Light blue" ;
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_LIGHTGREEN_DEF
 {
     Text = "Light green" ;
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_LIGHTCYAN_DEF
 {
     Text = "Light cyan" ;
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_LIGHTRED_DEF
 {
     Text = "Light red" ;
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_LIGHTMAGENTA_DEF
 {
     Text = "Light magenta" ;
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_YELLOW_DEF
 {
     Text = "Yellow" ;
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_WHITE_DEF
 {
     Text = "White" ;
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_BLUEGREY_DEF
 {
     Text = "Blue gray" ;
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_ORANGE_DEF
 {
     Text = "Orange" ;
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_VIOLET_DEF
 {
     Text = "Violet";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_BORDEAUX_DEF
 {
     Text = "Bordeaux";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_PALE_YELLOW_DEF
 {
     Text = "Pale yellow";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_PALE_GREEN_DEF
 {
     Text = "Pale green";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_DKVIOLET_DEF
 {
     Text = "Dark violet";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_SALMON_DEF
 {
     Text = "Salmon";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_SEABLUE_DEF
 {
     Text = "Sea blue";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_COLOR_SUN_DEF
 {
     // attention: this is the color string for the Sun Microsystems specific colors !!!
     Text = "Sun";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_COLOR_CHART_DEF
 {
     Text = "Chart";
@@ -511,52 +504,52 @@ String RID_SVXSTR_COLOR_CHART_DEF
 // Reference-strings for standard-gradient-table
 //
 
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_GRDT0_DEF
 {
     Text = "Gradient";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_GRDT1_DEF
 {
     Text = "Linear blue/white";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_GRDT2_DEF
 {
     Text = "Linear magenta/green";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_GRDT3_DEF
 {
     Text = "Linear yellow/brown";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_GRDT4_DEF
 {
     Text = "Radial green/black";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_GRDT5_DEF
 {
     Text = "Radial red/yellow";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_GRDT6_DEF
 {
     Text = "Rectangular red/white";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_GRDT7_DEF
 {
     Text = "Square yellow/white";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_GRDT8_DEF
 {
     Text = "Ellipsoid blue grey/light blue";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_GRDT9_DEF
 {
     Text = "Axial light red/white";
@@ -608,57 +601,57 @@ String RID_SVXSTR_GRDT9
 // Reference-strings for standard-hatch-table
 //
 
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_HATCH0_DEF
 {
     Text = "Black 45 Degrees Wide";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_HATCH1_DEF
 {
     Text = "Black 45 Degrees";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_HATCH2_DEF
 {
     Text = "Black -45 Degrees";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_HATCH3_DEF
 {
     Text = "Black 90 Degrees";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_HATCH4_DEF
 {
     Text = "Red Crossed 45 Degrees";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_HATCH5_DEF
 {
     Text = "Red Crossed 0 Degrees";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_HATCH6_DEF
 {
     Text = "Blue Crossed 45 Degrees";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_HATCH7_DEF
 {
     Text = "Blue Crossed 0 Degrees";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_HATCH8_DEF
 {
     Text = "Blue Triple 90 Degrees";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_HATCH9_DEF
 {
     Text = "Black 0 Degrees";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_HATCH10_DEF
 {
     Text = "Hatch";
@@ -714,113 +707,113 @@ String RID_SVXSTR_HATCH10
 // Reference-strings for standard-bitmap-table
 //
 
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_BMP0_DEF
 {
     Text = "Empty";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_BMP1_DEF
 {
     Text = "Sky";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_BMP2_DEF
 {
     Text = "Aqua";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_BMP3_DEF
 {
     Text = "Coarse";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_BMP4_DEF
 {
     Text = "Space Metal";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_BMP5_DEF
 {
     Text = "Space";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_BMP6_DEF
 {
     Text = "Metal";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_BMP7_DEF
 {
     Text = "Wet";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_BMP8_DEF
 {
     Text = "Marble";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_BMP9_DEF
 {
     Text = "Linen";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_BMP10_DEF
 {
     Text = "Stone";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_BMP11_DEF
 {
     Text = "Pebbles";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_BMP12_DEF
 {
     Text = "Wall";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_BMP13_DEF
 {
     Text = "Red Wall";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_BMP14_DEF
 {
     Text = "Pattern";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_BMP15_DEF
 {
     Text = "Leaves";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_BMP16_DEF
 {
     Text = "Lawn Artificial";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_BMP17_DEF
 {
     Text = "Daisy";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_BMP18_DEF
 {
     Text = "Orange";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_BMP19_DEF
 {
     Text = "Fiery";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_BMP20_DEF
 {
     Text = "Roses";
 };
 
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_BMP21_DEF
 {
     Text = "Bitmape";
@@ -920,62 +913,62 @@ String RID_SVXSTR_BMP21
 // Reference-strings for standard-dash-table
 //
 
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_DASH0_DEF
 {
     Text = "Ultrafine Dashed";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_DASH1_DEF
 {
     Text = "Fine Dashed";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_DASH2_DEF
 {
     Text = "Ultrafine 2 Dots 3 Dashes";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_DASH3_DEF
 {
     Text = "Fine Dotted";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_DASH4_DEF
 {
     Text = "Line with Fine Dots";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_DASH5_DEF
 {
     Text = "Fine Dashed (var)";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_DASH6_DEF
 {
     Text = "3 Dashes 3 Dots (var)";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_DASH7_DEF
 {
     Text = "Ultrafine Dotted (var)";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_DASH8_DEF
 {
     Text = "Line Style 9";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_DASH9_DEF
 {
     Text = "2 Dots 1 Dash";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_DASH10_DEF
 {
     Text = "Dashed (var)";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_DASH11_DEF
 {
     Text = "Dash";
@@ -1035,62 +1028,62 @@ String RID_SVXSTR_DASH11
 // Reference-strings for standard-line-end-table
 //
 
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_LEND0_DEF
 {
     Text = "Arrow concave";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_LEND1_DEF
 {
     Text = "Square 45";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_LEND2_DEF
 {
     Text = "Small Arrow";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_LEND3_DEF
 {
     Text = "Dimension Lines";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_LEND4_DEF
 {
     Text = "Double Arrow";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_LEND5_DEF
 {
     Text = "Rounded short Arrow";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_LEND6_DEF
 {
     Text = "Symmetric Arrow";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_LEND7_DEF
 {
     Text = "Line Arrow";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_LEND8_DEF
 {
     Text = "Rounded large Arrow";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_LEND9_DEF
 {
     Text = "Circle";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_LEND10_DEF
 {
     Text = "Square";
 };
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_LEND11_DEF
 {
     Text = "Arrow";
@@ -1150,7 +1143,7 @@ String RID_SVXSTR_LEND11
 // Reference-strings for standard transparence gradients
 //
 
-/* nicht uebersetzen */
+/* do not translate */
 String RID_SVXSTR_TRASNGR0_DEF
 {
     Text = "Transparency";
@@ -1183,7 +1176,7 @@ StringArray RID_SVXSTR_FIELDUNIT_TABLE
     };
     };
 
-// unbekannte Zeichenfarbe
+// unknown text color
 String RID_SVXSTR_COLOR_USER
 {
     Text [ en-US ] = "User" ;
diff --git a/svx/source/dialog/srchctrl.cxx b/svx/source/dialog/srchctrl.cxx
index 63df3014a2be..2ed66c49631e 100644
--- a/svx/source/dialog/srchctrl.cxx
+++ b/svx/source/dialog/srchctrl.cxx
@@ -36,7 +36,7 @@
 
 #include <svx/svxids.hrc>
 
-#define _SVX_SRCHDLG_CXX // damit private-Methoden vom SrchDlg bekannt sind
+#define _SVX_SRCHDLG_CXX // so that private methods from SrchDlgare known
 
 
 
diff --git a/svx/source/dialog/srchdlg.cxx b/svx/source/dialog/srchdlg.cxx
index 1ca3584c7812..5cd887c73553 100644
--- a/svx/source/dialog/srchdlg.cxx
+++ b/svx/source/dialog/srchdlg.cxx
@@ -104,9 +104,6 @@ using namespace comphelper;
 
 SV_IMPL_VARARR(SrchAttrItemList, SearchAttrItem);
 
-//#define NotifyApp( nId )
-//    rBindings.ExecuteSynchron( nId, (const SfxPoolItem**)&pSearchItem, 0L )
-
 #define GetCheckBoxValue( rBox )                                \
     rBox.IsEnabled() ? rBox.IsChecked() : FALSE
 
@@ -176,7 +173,7 @@ void ListToStrArr_Impl( USHORT nId, SvStringsDtor& rStrLst, ComboBox& rCBox )
 
 void StrArrToList_Impl( USHORT nId, const SvStringsDtor& rStrLst )
 {
-    DBG_ASSERT( rStrLst.Count(), "vorher abpruefen!!" );
+    DBG_ASSERT( rStrLst.Count(), "check in advance");
     List aLst;
 
     for ( USHORT i = 0; i < rStrLst.Count(); ++i )
@@ -222,7 +219,7 @@ void SearchAttrItemList::Put( const SfxItemSet& rSet )
 
     while ( TRUE )
     {
-        // nur testen, ob vorhanden ist ?
+        // only test that it is available?
         if( IsInvalidItem( pItem ) )
         {
             nWhich = rSet.GetWhichByPos( aIter.GetCurPos() );
@@ -272,7 +269,7 @@ void SearchAttrItemList::Clear()
 
 // -----------------------------------------------------------------------
 
-// l"oscht die Pointer auf die Items
+// Deletes the pointer to the items
 void SearchAttrItemList::Remove( USHORT nPos, USHORT nLen )
 {
     if ( nPos + nLen > Count() )
@@ -440,14 +437,14 @@ void SvxSearchDialog::Construct_Impl()
 #endif /* !ENABLE_LAYOUT */
     EnableControls_Impl( 0 );
 
-    // alten Text des aWordBtn's merken
+    // Store old Text from aWordBtn
     aCalcStr += sal_Unicode('#');
     aCalcStr += aWordBtn.GetText();
 
     aLayoutStr = SVX_RESSTR( RID_SVXSTR_SEARCH_STYLES );
     aStylesStr = aLayoutBtn.GetText();
 
-    // gemerkte Such-Strings von der Applikation holen
+    // Get stored search-strings from the application
     ListToStrArr_Impl( SID_SEARCHDLG_SEARCHSTRINGS,
                        aSearchStrings, aSearchLB    );
     ListToStrArr_Impl( SID_SEARCHDLG_REPLACESTRINGS,
@@ -459,7 +456,7 @@ void SvxSearchDialog::Construct_Impl()
     FreeResource();
     InitControls_Impl();
 
-    // Attribut-Sets nur einmal im Ctor() besorgen
+    // Get attribut sets only once in construtor()
     const SfxPoolItem* ppArgs[] = { pSearchItem, 0 };
     const SvxSetItem* pSrchSetItem =
         (const SvxSetItem*) rBindings.GetDispatcher()->Execute( FID_SEARCH_SEARCHSET, SFX_CALLMODE_SLOT, ppArgs );
@@ -473,7 +470,7 @@ void SvxSearchDialog::Construct_Impl()
     if ( pReplSetItem )
         InitAttrList_Impl( 0, &pReplSetItem->GetItemSet() );
 
-    // Controller erzeugen und gleich aktualisieren
+    // Create controller and update at once
     rBindings.EnterRegistrations();
     pSearchController =
         new SvxSearchController( SID_SEARCH_ITEM, rBindings, *this );
@@ -516,10 +513,6 @@ void SvxSearchDialog::Construct_Impl()
 
     if( bSearchComponent1 || bSearchComponent2 )
     {
-        //get the labels of the FixedLine and the buttons
-        // "/org.openoffice.Office.Common/SearchOptions/ComponentSearchGroupLabel
-        // "/org.openoffice.Office.Common/SearchOptions/ComponentSearchCommandLabel1
-        // "/org.openoffice.Office.Common/SearchOptions/ComponentSearchCommandLabel2
         try
         {
             uno::Reference< lang::XMultiServiceFactory >  xMgr = getProcessServiceFactory();
@@ -631,10 +624,8 @@ BOOL SvxSearchDialog::Close()
     aOpt.SetWholeWordsOnly          ( aWordBtn                .IsChecked() );
     aOpt.SetBackwards               ( aBackwardsBtn           .IsChecked() );
     aOpt.SetUseRegularExpression    ( aRegExpBtn              .IsChecked() );
-    //aOpt.SetMatchCase             ( aMatchCaseCB            .IsChecked() );
     aOpt.SetSearchForStyles         ( aLayoutBtn              .IsChecked() );
     aOpt.SetSimilaritySearch        ( aSimilarityBox          .IsChecked() );
-    //aOpt.SetMatchFullHalfWidthForms   ( !aJapMatchFullHalfWidthCB.IsChecked() );
     aOpt.SetUseAsianOptions         ( aJapOptionsCB           .IsChecked() );
         aOpt.SetNotes                   ( aNotesBtn               .IsChecked() );
 
@@ -1050,7 +1041,7 @@ void SvxSearchDialog::Init_Impl( int bSearchPattern )
         if ( ( nModifyFlag & MODIFY_ALLTABLES ) == 0 )
             aAllSheetsCB.Check( pSearchItem->IsAllTables() );
 
-        // nur im Writer Suche nach Formatierung
+        // only look for formatting in Writer
         aFormatBtn.Hide();
         aNoFormatBtn.Hide();
         aAttributeBtn.Hide();
@@ -1066,7 +1057,7 @@ void SvxSearchDialog::Init_Impl( int bSearchPattern )
             aRegExpBtn.Hide();
             aLayoutBtn.Hide();
 
-            // nur im Writer Suche nach Formatierung
+            // only look for formatting in Writer
             aFormatBtn.Hide();
             aNoFormatBtn.Hide();
             aAttributeBtn.Hide();
@@ -1076,7 +1067,7 @@ void SvxSearchDialog::Init_Impl( int bSearchPattern )
         {
             if ( !pSearchList )
             {
-                // Attribut-Sets besorgen, wenn noch nicht geschehen
+                // Get attribute sets, if it not has been done already
                 const SfxPoolItem* ppArgs[] = { pSearchItem, 0 };
                 const SvxSetItem* pSrchSetItem =
                 (const SvxSetItem*)rBindings.GetDispatcher()->Execute( FID_SEARCH_SEARCHSET, SFX_CALLMODE_SLOT, ppArgs );
@@ -1090,14 +1081,7 @@ void SvxSearchDialog::Init_Impl( int bSearchPattern )
                 if ( pReplSetItem )
                     InitAttrList_Impl( 0, &pReplSetItem->GetItemSet() );
             }
-/*
-            aFormatBtn.Show();
-            aNoFormatBtn.Show();
-            aAttributeBtn.Show();
-*/
         }
-//       pMoreBtn->SetState( FALSE );
-//       pMoreBtn->Hide();
     }
 
     if ( 0 && !bDraw ) //!!!!!
@@ -1106,7 +1090,7 @@ void SvxSearchDialog::Init_Impl( int bSearchPattern )
         aLayoutBtn.Show();
     }
 
-    // "Ahnlichkeitssuche?
+    // similarity search?
     if ( ( nModifyFlag & MODIFY_SIMILARITY ) == 0 )
         aSimilarityBox.Check( pSearchItem->IsLevenshtein() );
     bSet = TRUE;
@@ -1130,14 +1114,14 @@ void SvxSearchDialog::Init_Impl( int bSearchPattern )
         }
     }
 
-    // Patternsuche und es wurden keine AttrSets "ubergeben
+    // Pattern Search and there were no AttrSets given
     if ( bSearchPattern )
     {
         SfxObjectShell* pShell = SfxObjectShell::Current();
 
         if ( pShell && pShell->GetStyleSheetPool() )
         {
-            // Vorlagen beschaffen
+            // Templates designed
             aSearchTmplLB .Clear();
             aReplaceTmplLB.Clear();
             SfxStyleSheetBasePool* pStylePool = pShell->GetStyleSheetPool();
@@ -1159,7 +1143,7 @@ void SvxSearchDialog::Init_Impl( int bSearchPattern )
         aSearchTmplLB.Show();
 
         if ( bConstruct )
-            // nur nach dem Erzeugen den Fokus grappen
+            // Grab focus only after creating
             aSearchTmplLB.GrabFocus();
         aReplaceTmplLB.Show();
         aSearchLB.Hide();
@@ -1198,7 +1182,7 @@ void SvxSearchDialog::Init_Impl( int bSearchPattern )
         aSearchLB.Show();
 
         if ( bConstruct )
-            // nur nach dem Erzeugen den Fokus grappen
+            // Grab focus only after creating
             aSearchLB.GrabFocus();
         aReplaceLB.Show();
         aSearchTmplLB.Hide();
@@ -1293,7 +1277,7 @@ void SvxSearchDialog::InitAttrList_Impl( const SfxItemSet* pSSet,
         memcpy( pImpl->pRanges, pTmp, sizeof(USHORT) * nCnt );
     }
 
-    // sorge daf"ur, das die Texte der Attribute richtig stehen
+    // See to it that are the texts of the attributes are correct
     String aDesc;
 
     if ( pSSet )
@@ -1431,7 +1415,7 @@ IMPL_LINK( SvxSearchDialog, FlagHdl_Impl, Control *, pCtrl )
                 EnableControl_Impl( &aSimilarityBox );
             }
 
-            // Such-String vorhanden? dann Buttons enablen
+            // Search-string in place? then enable Buttons
             bSet = TRUE;
             ModifyHdl_Impl( &aSearchLB );
         }
@@ -1531,7 +1515,7 @@ IMPL_LINK( SvxSearchDialog, CommandHdl_Impl, Button *, pBtn )
         else if ( pBtn == &aReplaceAllBtn )
             pSearchItem->SetCommand( SVX_SEARCHCMD_REPLACE_ALL );
 
-        // wenn nach Vorlagen gesucht wird, dann Format-Listen l"oschen
+        // when looking for templates, delete format lists
         if ( !bFormat && pSearchItem->GetPattern() )
         {
             if ( pSearchList )
@@ -1691,7 +1675,7 @@ IMPL_LINK( SvxSearchDialog, TemplateHdl_Impl, Button *, EMPTYARG )
         {
             USHORT nId = 0;
 
-            // Vorlagen-Controller enablen
+            // Enable templates controller
             switch ( pSearchItem->GetFamily() )
             {
                 case SFX_STYLE_FAMILY_CHAR:
@@ -1710,7 +1694,7 @@ IMPL_LINK( SvxSearchDialog, TemplateHdl_Impl, Button *, EMPTYARG )
                     break;
 
                 default:
-                    DBG_ERROR( "StyleSheetFamily wurde geaendert?" );
+                    DBG_ERROR( "StyleSheetFamily was changed?" );
             }
 
             rBindings.EnterRegistrations();
@@ -1744,7 +1728,7 @@ IMPL_LINK( SvxSearchDialog, TemplateHdl_Impl, Button *, EMPTYARG )
     }
     else
     {
-        // Vorlagen-Controller disablen
+        // Disable templates controller
         rBindings.EnterRegistrations();
         DELETEZ( pFamilyController );
         rBindings.LeaveRegistrations();
@@ -1788,14 +1772,14 @@ void SvxSearchDialog::Remember_Impl( const String &rStr,BOOL _bSearch )
     SvStringsDtor* pArr = _bSearch ? &aSearchStrings : &aReplaceStrings;
     ComboBox* pListBox = _bSearch ? &aSearchLB : &aReplaceLB;
 
-    // identische Strings ignorieren
+    // ignore identical strings
     for ( USHORT i = 0; i < pArr->Count(); ++i )
     {
         if ( COMPARE_EQUAL == (*pArr)[i]->CompareTo( rStr ) )
             return;
     }
 
-    // bei maximaler Belegung "altesten Eintrag l"oschen (ListBox und Array)
+    // delete oldest entry at maximum occupancy (ListBox and Array)
     String* pInsStr;
 
     if ( pArr->Count() >= REMEMBER_SIZE )
@@ -1816,7 +1800,6 @@ void SvxSearchDialog::Remember_Impl( const String &rStr,BOOL _bSearch )
 
 void SvxSearchDialog::TemplatesChanged_Impl( SfxStyleSheetBasePool& rPool )
 {
-//  SetUpdateMode( FALSE );
     String aOldSrch( aSearchTmplLB .GetSelectEntry() );
     String aOldRepl( aReplaceTmplLB.GetSelectEntry() );
     aSearchTmplLB .Clear();
@@ -1851,8 +1834,6 @@ void SvxSearchDialog::TemplatesChanged_Impl( SfxStyleSheetBasePool& rPool )
         EnableControl_Impl( &aReplaceBtn );
         EnableControl_Impl( &aReplaceAllBtn );
     }
-//  FlagHdl_Impl(0);
-//  SetUpdateMode( TRUE );
 }
 
 // -----------------------------------------------------------------------
@@ -1927,10 +1908,7 @@ void SvxSearchDialog::EnableControls_Impl( const USHORT nFlags )
         aBackwardsBtn.Enable();
     else
         aBackwardsBtn.Disable();
-    //!if ( ( SEARCH_OPTIONS_NOTES & nOptions ) != 0 )
         aNotesBtn.Enable();
-    //!else
-    //!    aNotesBtn.Disable();
     if ( ( SEARCH_OPTIONS_REG_EXP & nOptions ) != 0 )
         aRegExpBtn.Enable();
     else
@@ -1959,16 +1937,7 @@ void SvxSearchDialog::EnableControls_Impl( const USHORT nFlags )
         aFormatBtn.Disable();
         aNoFormatBtn.Disable();
     }
-/*
-    if ( ( SEARCH_OPTIONS_MORE & nOptions ) != 0 &&
-         pSearchItem && pSearchItem->GetAppFlag() == SVX_SEARCHAPP_CALC )
-        pMoreBtn->Enable();
-    else
-    {
-        pMoreBtn->SetState( FALSE );
-        pMoreBtn->Disable();
-    }
-*/
+
     if ( ( SEARCH_OPTIONS_SIMILARITY & nOptions ) != 0 )
     {
         aSimilarityBox.Enable();
@@ -2024,7 +1993,7 @@ void SvxSearchDialog::EnableControl_Impl( Control* pCtrl )
         aBackwardsBtn.Enable();
         return;
     }
-    if ( &aNotesBtn == pCtrl /*! && ( SEARCH_OPTIONS_NOTES & nOptions ) != 0 */ )
+    if ( &aNotesBtn == pCtrl ) != 0 */ )
     {
         aNotesBtn.Enable();
         return;
@@ -2233,7 +2202,7 @@ IMPL_LINK( SvxSearchDialog, FormatHdl_Impl, Button *, EMPTYARG )
             if( aOutSet.Count() )
                 pList->Put( aOutSet );
 
-            PaintAttrText_Impl(); // AttributText in GroupBox setzen
+            PaintAttrText_Impl(); // Set AttributText in GroupBox
         }
         delete pDlg;
     }
@@ -2362,7 +2331,7 @@ String& SvxSearchDialog::BuildAttrText_Impl( String& rStr,
     if ( !pList )
         return rStr;
 
-    // Metrik abfragen
+    // Metric query
     SfxMapUnit eMapUnit = SFX_MAPUNIT_CM;
     FieldUnit eFieldUnit = pSh->GetModule()->GetFieldUnit();
     switch ( eFieldUnit )
@@ -2400,7 +2369,7 @@ String& SvxSearchDialog::BuildAttrText_Impl( String& rStr,
         }
         else if ( rItem.nSlot == SID_ATTR_BRUSH_CHAR )
         {
-            //Sonderbehandlung fuer Zeichenhintergrund
+            // Special treatment for text background
             rStr += SVX_RESSTR( RID_SVXITEMS_BRUSH_CHAR );
         }
         else
diff --git a/svx/source/dialog/svxbmpnumvalueset.cxx b/svx/source/dialog/svxbmpnumvalueset.cxx
index 4b8dfc14718c..951da1459119 100644
--- a/svx/source/dialog/svxbmpnumvalueset.cxx
+++ b/svx/source/dialog/svxbmpnumvalueset.cxx
@@ -100,7 +100,7 @@ static const sal_Char cSuffix[] = "Suffix";
 static const sal_Char cBulletChar[] = "BulletChar";
 static const sal_Char cBulletFontName[] = "BulletFontName";
 
-// Die Auswahl an Bullets aus den StarSymbol
+// The selection of bullets from the star symbol
 static const sal_Unicode aBulletTypes[] =
 {
     0x2022,
@@ -203,8 +203,8 @@ void  SvxNumValueSet::UserDraw( const UserDrawEvent& rUDEvt )
 
     if(!pVDev)
     {
-        // Die Linien werden nur einmalig in das VirtualDevice gepainted
-        // nur die Gliederungspage bekommt es aktuell
+        // The lines are only one time in the virtual device, only the outline
+        // page is currently done
         pVDev = new VirtualDevice(*pDev);
         pVDev->SetMapMode(pDev->GetMapMode());
         pVDev->EnableRTL( IsRTLEnabled() );
@@ -216,7 +216,7 @@ void  SvxNumValueSet::UserDraw( const UserDrawEvent& rUDEvt )
         if(aBackColor == aLineColor)
             aLineColor.Invert();
         pVDev->SetLineColor(aLineColor);
-        // Linien nur einmalig Zeichnen
+        // Draw line only once
         if(nPageType != NUM_PAGETYPE_NUM)
         {
             Point aStart(aBLPos.X() + nRectWidth *25 / 100,0);
@@ -233,7 +233,7 @@ void  SvxNumValueSet::UserDraw( const UserDrawEvent& rUDEvt )
     pDev->DrawOutDev(   aRect.TopLeft(), aRectSize,
                         aOrgRect.TopLeft(), aRectSize,
                         *pVDev );
-    // jetzt kommt der Text
+    // Now comes the text
     const OUString sValue(C2U(cValue));
     if( NUM_PAGETYPE_SINGLENUM == nPageType ||
             NUM_PAGETYPE_BULLET == nPageType )
@@ -268,7 +268,7 @@ void  SvxNumValueSet::UserDraw( const UserDrawEvent& rUDEvt )
                         DBG_ERROR("Exception in DefaultNumberingProvider::makeNumberingString");
                     }
                 }
-                // knapp neben dem linken Rand beginnen
+                // start just next to the left edge
                 aStart.X() = aBLPos.X() + 2;
                 aStart.Y() -= pDev->GetTextHeight()/2;
             }
@@ -385,7 +385,7 @@ void  SvxNumValueSet::UserDraw( const UserDrawEvent& rUDEvt )
                     }
 
                     long nLineTop = nStartY + nRectHeight * aLinesArr[2 * i + 1]/100 ;
-                    Point aLineLeft(aLeft.X() /*+ nStartX + nRectWidth * aLinesArr[2 * i]/ 100*/, nLineTop );
+                    Point aLineLeft(aLeft.X(), nLineTop );
                     Point aLineRight(nStartX + nRectWidth * 90 /100, nLineTop );
                     pVDev->DrawLine(aLineLeft,  aLineRight);
                 }
@@ -416,11 +416,6 @@ void  SvxNumValueSet::UserDraw( const UserDrawEvent& rUDEvt )
     pDev->SetLineColor(aOldColor);
 }
 
-/**************************************************************************/
-/*                                                                        */
-/*                                                                        */
-/**************************************************************************/
-
 SvxNumValueSet::SvxNumValueSet( Window* pParent, const ResId& rResId, USHORT nType ) :
 
     ValueSet( pParent, rResId ),
@@ -484,10 +479,9 @@ void SvxNumValueSet::SetOutlineNumberingSettings(
     }
 }
 
-SvxBmpNumValueSet::SvxBmpNumValueSet( Window* pParent, const ResId& rResId/*, const List& rStrNames*/ ) :
+SvxBmpNumValueSet::SvxBmpNumValueSet( Window* pParent, const ResId& rResId ) :
 
     SvxNumValueSet( pParent, rResId, NUM_PAGETYPE_BMP ),
-//    rStrList    ( rStrNames ),
     bGrfNotFound( FALSE )
 
 {
@@ -536,7 +530,7 @@ void SvxBmpNumValueSet::UserDraw( const UserDrawEvent& rUDEvt )
 
 IMPL_LINK(SvxBmpNumValueSet, FormatHdl_Impl, Timer*, EMPTYARG)
 {
-    // nur, wenn eine Grafik nicht da war, muss formatiert werden
+    // only when a graphics was not there, it needs to be formatted
     if(bGrfNotFound)
     {
         bGrfNotFound = FALSE;
diff --git a/svx/source/dialog/svxruler.cxx b/svx/source/dialog/svxruler.cxx
index 3b36ed45ebc5..ec91367464c3 100644
--- a/svx/source/dialog/svxruler.cxx
+++ b/svx/source/dialog/svxruler.cxx
@@ -122,7 +122,7 @@ void DebugTabStops_Impl(const SvxTabStopItem& rTabs)
 {
     String aTmp("Tabs: ");
 
-    // Def Tabs loeschen
+    // Delete Def Tabs
     for(USHORT i = 0; i < rTabs.Count(); ++i)
     {
         aTmp += String(rTabs[i].GetTabPos() / 56);
@@ -218,11 +218,10 @@ struct SvxRuler_Impl  {
     SfxBoolItem* pTextRTLItem;
     USHORT nControlerItems;
     USHORT nIdx;
-    USHORT nColLeftPix, nColRightPix; // Pixelwerte fuer linken / rechten Rand
-                                      // bei Spalten; gepuffert, um Umrechenfehler
-                                      // zu vermeiden.
-                                      // Muesste vielleicht fuer weitere Werte
-                                      // aufgebohrt werden
+    USHORT nColLeftPix, nColRightPix; // Pixel values for left / right edge
+                                      // For columns; buffered to prevent
+                                      // recalculation errors
+                                      // May be has to be widen for future values
     BOOL bIsTableRows : 1;      // pColumnItem contains table rows instead of columns
     //#i24363# tab stops relative to indent
     BOOL bIsTabsRelativeToIndent : 1; // Tab stops relative to paragraph indent?
@@ -268,38 +267,38 @@ void SvxRuler_Impl::SetPercSize(USHORT nSize)
 }
 
 
-// Konstruktor des Lineals
+// Constructor of the ruler
 
 // SID_ATTR_ULSPACE, SID_ATTR_LRSPACE
-// erwartet als Parameter SvxULSpaceItem f"ur Seitenr"ander
-// (entweder links/rechts oder oben/unten)
-// Lineal: SetMargin1, SetMargin2
+// expects as parameter SvxULSpaceItem for page edge
+// (either left/right or top/bottom)
+// Ruler: SetMargin1, SetMargin2
 
 // SID_RULER_PAGE_POS
-// erwartet als Parameter Anfangswert der Seite sowie Seitenbreite
-// Lineal: SetPagePos
+// expectes as parameter the initial value of the page and page width
+// Ruler: SetPagePos
 
 // SID_ATTR_TABSTOP
-// erwartet: SvxTabStopItem
-// Lineal: SetTabs
+// expects: SvxTabStopItem
+// Ruler: SetTabs
 
 // SID_ATTR_PARA_LRSPACE
-// linker, rechter Absatzrand bei H-Lineal
-// Lineal: SetIndents
+// left, right paragraph edge in H-ruler
+// Ruler: SetIndents
 
 // SID_RULER_BORDERS
-// Tabellenraender, Spalten
-// erwartet: so etwas wie SwTabCols
-// Lineal: SetBorders
+// Table borders, columns
+// expects: something like SwTabCols
+// Ruler: SetBorders
 
 
 SvxRuler::SvxRuler
 (
  Window* pParent,                               // StarView Parent
- Window* pWin,                                  // Ausgabefenster; wird fuer Umrechnung logische
-                // Einheiten <-> Pixel verwendet
- USHORT  flags,                                 // Anzeige Flags, siehe ruler.hxx
- SfxBindings &rBindings,                // zugeordnete Bindings
+ Window* pWin,            // Output window: is used for conversion
+                          // logical units <-> pixels
+ USHORT  flags,           // Display flags, see ruler.hxx
+ SfxBindings &rBindings,  // associated Bindings
  WinBits nWinStyle                              // StarView WinBits
 )
 : Ruler(pParent, nWinStyle),
@@ -315,8 +314,7 @@ SvxRuler::SvxRuler
   pObjectItem(0),
   pEditWin(pWin),
   pRuler_Imp(new SvxRuler_Impl),
-  bAppSetNullOffset(FALSE),  //Wird der 0-Offset des Lineals
-                             //durch die appl. gesetzt?
+  bAppSetNullOffset(FALSE),  // Is the 0-offset of the ruler set by the application?
   lLogicNullOffset(0),
   lAppNullOffset(LONG_MAX),
   lMinFrame(5),
@@ -330,7 +328,7 @@ SvxRuler::SvxRuler
   lTabPos(-1),
   pTabs(0),
   pIndents(0),
-  pBorders(new RulerBorder[1]), //wg 1 Spaltiger Tabellen
+  pBorders(new RulerBorder[1]), // due to one column tables
   nBorderCount(0),
   pObjectBorders(0),
   pBindings(&rBindings),
@@ -341,21 +339,18 @@ SvxRuler::SvxRuler
   bListening(FALSE),
   bActive(TRUE)
 
-/*
-   [Beschreibung]
-
-   ctor;
-   Datenpuffer initialisieren; ControllerItems werden erzeugt
+/* [Description]
 
+   Constructor; Initialize data buffer; controller items are created
 */
 {
     memset(pCtrlItem, 0, sizeof(SvxRulerItem *) * CTRL_ITEM_COUNT);
 
     rBindings.EnterRegistrations();
 
-    // Unterstuetzte Items anlegen
+    // Create Supported Items
     USHORT i = 0;
-    // Seitenraender
+    // Page edges
 
     pCtrlItem[i++] = new SvxRulerItem(SID_RULER_LR_MIN_MAX, *this, rBindings);
     if((nWinStyle & WB_VSCROLL) == WB_VSCROLL)
@@ -369,7 +364,7 @@ SvxRuler::SvxRuler
         pCtrlItem[i++] = new SvxRulerItem(SID_ATTR_LONG_LRSPACE, *this, rBindings);
     }
 
-    // Seitenposition
+    // Page Position
     pCtrlItem[i++] = new SvxRulerItem(SID_RULER_PAGE_POS, *this, rBindings);
 
     if((nFlags & SVXRULER_SUPPORT_TABS) == SVXRULER_SUPPORT_TABS)
@@ -434,13 +429,10 @@ SvxRuler::SvxRuler
 
 
 SvxRuler::~SvxRuler()
-/*
-   [Beschreibung]
-
-   Destruktor Lineal
-   Freigabe interner Puffer
 
+/* [Description]
 
+   Destructor ruler; release internal buffer
 */
 {
     REMOVE_DEBUG_WINDOW
@@ -471,12 +463,9 @@ SvxRuler::~SvxRuler()
     pBindings->LeaveRegistrations();
 }
 
-/*
-
-   [Beschreibung]
-
-   Interne Umrechenroutinen
+/* [Description]
 
+   Internal conversion routines
 */
 
 long SvxRuler::ConvertHPosPixel(long nVal) const
@@ -571,15 +560,12 @@ inline USHORT SvxRuler::GetObjectBordersOff(USHORT nIdx) const
 }
 
 
-
 void SvxRuler::UpdateFrame()
 
-/*
-   [Beschreibung]
-
-   Linken, oberen Rand aktualisieren
-   Items werden in die Darstellung des Lineals uebersetzt.
+/* [Description]
 
+   Update Upper Left edge.
+   Items are translated into the representation of the ruler.
 */
 
 {
@@ -590,7 +576,7 @@ void SvxRuler::UpdateFrame()
 
     if(pLRSpaceItem && pPagePosItem)
     {
-        // wenn keine Initialisierung durch App Defaultverhalten
+        // if no initialization by default app behavior
         const long nOld = lLogicNullOffset;
         lLogicNullOffset = pColumnItem?
             pColumnItem->GetLeft(): pLRSpaceItem->GetLeft();
@@ -605,7 +591,7 @@ void SvxRuler::UpdateFrame()
         else
             SetMargin1( ConvertHPosPixel( lAppNullOffset ), nMarginStyle );
         long lRight = 0;
-            // bei Tabelle rechten Rand der Tabelle auswerten
+            // evaluate the table right edge of the table
         if(pColumnItem && pColumnItem->IsTable())
             lRight = pColumnItem->GetRight();
         else
@@ -619,7 +605,7 @@ void SvxRuler::UpdateFrame()
     else
         if(pULSpaceItem && pPagePosItem)
         {
-            // Nullpunkt aus oberem Rand des umgebenden Rahmens
+            // relative the upper edge of the surrounding frame
             const long nOld = lLogicNullOffset;
             lLogicNullOffset = pColumnItem?
                 pColumnItem->GetLeft(): pULSpaceItem->GetUpper();
@@ -642,7 +628,7 @@ void SvxRuler::UpdateFrame()
         }
     else
     {
-        // schaltet die Anzeige aus
+        // turns off the view
         SetMargin1();
         SetMargin2();
     }
@@ -683,14 +669,12 @@ void SvxRuler::StartListening_Impl()
 
 void SvxRuler::UpdateFrame
 (
- const SvxLongLRSpaceItem *pItem    // neuer Wert LRSpace
+ const SvxLongLRSpaceItem *pItem    // new value LRSpace
 )
 
-/*
-   [Beschreibung]
-
-   Neuen Wert fuer LRSpace merken; alten gfs. loeschen
+/* [Description]
 
+   Store new value LRSpace; delete old ones if possible
 */
 
 {
@@ -706,14 +690,12 @@ void SvxRuler::UpdateFrame
 
 void SvxRuler::UpdateFrameMinMax
 (
- const SfxRectangleItem *pItem  // Werte fuer MinMax
+ const SfxRectangleItem *pItem  // value for MinMax
 )
 
-/*
-   [Beschreibung]
-
-   Neuen Wert fuer MinMax setzen; alten gfs. loeschen
+/* [Description]
 
+   Set new value for MinMax; delete old ones if possible
 */
 
 {
@@ -728,14 +710,12 @@ void SvxRuler::UpdateFrameMinMax
 
 void SvxRuler::UpdateFrame
 (
- const SvxLongULSpaceItem *pItem    // neuer Wert
+ const SvxLongULSpaceItem *pItem    // new value
 )
 
-/*
-   [Beschreibung]
-
-   Rechten / unteren Rand aktualisieren
+/* [Description]
 
+   Update Right/bottom margin
 */
 
 
@@ -768,15 +748,13 @@ void SvxRuler::UpdateTextRTL(const SfxBoolItem* pItem)
 
 void SvxRuler::Update
 (
- const SvxColumnItem *pItem,             // neuer Wert
+ const SvxColumnItem *pItem,  // new value
  USHORT nSID //Slot Id to identify NULL items
 )
 
-/*
-   [Beschreibung]
-
-   Neuen Wert fuer Spaltendarstellung setzen
+/* [Description]
 
+   Set new value for column view
 */
 
 {
@@ -807,11 +785,10 @@ void SvxRuler::Update
 
 
 void SvxRuler::UpdateColumns()
-/*
-   [Beschreibung]
 
-   Anzeige der Spaltendarstellung aktualisieren
+/* [Description]
 
+   Update column view
 */
 {
     if(pColumnItem && pColumnItem->Count() > 1)
@@ -872,18 +849,16 @@ void SvxRuler::UpdateColumns()
 
 void SvxRuler::UpdateObject()
 
-/*
-   [Beschreibung]
-
-   Anzeige der Objektdarstellung aktualisieren
+/* [Description]
 
+   Update view of object representation
 */
 
 {
     if(pObjectItem)
     {
-        DBG_ASSERT(pObjectBorders, "kein Buffer");
-        // !! zum Seitenrand
+        DBG_ASSERT(pObjectBorders, "no Buffer");
+        // !! to the page margin
         long nMargin = pLRSpaceItem? pLRSpaceItem->GetLeft(): 0;
         pObjectBorders[0].nPos =
             ConvertPosPixel(pObjectItem->GetStartX() -
@@ -909,27 +884,26 @@ void SvxRuler::UpdateObject()
 
 void SvxRuler::UpdatePara()
 
-/*
-   [Beschreibung]
+/* [Description]
 
-   Anzeige der Absatzeinzuege aktualisieren:
-   Linken Rand, Erstzeileneinzug, rechten Rand Absatz aktualisieren
-   pIndents[0] = Buffer fuer alten Einzug
-   pIndents[1] = Buffer fuer alten Einzug
-   pIndents[INDENT_FIRST_LINE] = Erstzeileneinzug
-   pIndents[3] = linker Rand
-   pIndents[4] = rechter Rand
+   Update the view for paragraph indents:
+   Left margin, first line indent, right margin paragraph update
+   pIndents[0] = Buffer for old intent
+   pIndents[1] = Buffer for old intent
+   pIndents[INDENT_FIRST_LINE] = First line indent
+   pIndents[3] = left margin
+   pIndents[4] = right margin
    pIndents[5] = left border distance
    pIndents[6] = right border distance
 
 */
 
 {
-    // Abhaengigkeit zu PagePosItem
+    // Dependence on PagePosItem
     if(pParaItem && pPagePosItem && !pObjectItem)
     {
         BOOL bRTLText = pRuler_Imp->pTextRTLItem && pRuler_Imp->pTextRTLItem->GetValue();
-        // Erstzeileneinzug, ist negativ zum linken Absatzrand
+        // First-line indent is negative to the left paragraph margin
         long nLeftFrameMargin = GetLeftFrameMargin();
         long nRightFrameMargin = GetRightFrameMargin();
         if(bRTLText)
@@ -965,12 +939,12 @@ void SvxRuler::UpdatePara()
         }
         else
         {
-            // linker Rand
+            // left margin
             pIndents[INDENT_LEFT_MARGIN].nPos =
                 ConvertHPosPixel(
                     nLeftFrameMargin +
                     pParaItem->GetTxtLeft() + lAppNullOffset);
-            // rechter Rand, immer negativ zum rechten Rand des umgebenden Frames
+            // right margin, always negative to the right edge of the surrounding frames
             pIndents[INDENT_RIGHT_MARGIN].nPos =
                 ConvertHPosPixel(
                     nRightFrameMargin -
@@ -997,20 +971,19 @@ void SvxRuler::UpdatePara()
             pIndents[INDENT_LEFT_MARGIN].nPos =
             pIndents[INDENT_RIGHT_MARGIN].nPos = 0;
         }
-        SetIndents();        // ausschalten
+        SetIndents();        // turn off
     }
 }
 
 
 void SvxRuler::UpdatePara
 (
- const SvxLRSpaceItem *pItem    // neuer Wert Absatzeinzuege
+ const SvxLRSpaceItem *pItem    // new value of paragraph indents
 )
 
-/*
-   [Beschreibung]
+/* [Description]
 
-   Neuen Wert Absatzeinzuege merken
+   Store new value of paragraph indents
 */
 
 {
@@ -1023,8 +996,9 @@ void SvxRuler::UpdatePara
     }
 }
 void SvxRuler::UpdateParaBorder(const SvxLRSpaceItem * pItem )
-/*
-   [Description]
+
+/* [Description]
+
    Border distance
 */
 
@@ -1041,17 +1015,15 @@ void SvxRuler::UpdateParaBorder(const SvxLRSpaceItem * pItem )
 
 void SvxRuler::UpdatePage()
 
-/*
-   [Beschreibung]
-
-   Anzeige von Postion und Breite der Seite aktualisieren
+/* [Description]
 
+   Update view of position and width of page
 */
 
 {
     if(pPagePosItem)
     {
-        // alle Objekte werden automatisch angepasst
+        // all objects are automatically adjusted
         if(bHorz)
             SetPagePos(
                 pEditWin->LogicToPixel(pPagePosItem->GetPos()).X(),
@@ -1086,9 +1058,8 @@ void SvxRuler::UpdatePage()
         lPos= bHorz ? aPos.X() : aPos.Y();
     }
 
-// Leider bekommen wir den Offset des Editfensters zum Lineal nie
-// per Statusmeldung. Also setzen wir ihn selbst, wenn noetig.
-
+// Unfortunately, we get the offset of the edit window to the ruler never
+// through a status message. So we set it ourselves if necessary.
     if(lPos!=pRuler_Imp->lOldWinPos)
     {
         pRuler_Imp->lOldWinPos=lPos;
@@ -1099,14 +1070,12 @@ void SvxRuler::UpdatePage()
 
 void SvxRuler::Update
 (
- const SvxPagePosSizeItem *pItem // neuer Wert Seitenattribute
+ const SvxPagePosSizeItem *pItem // new value of page attributes
 )
 
-/*
-   [Beschreibung]
-
-   Neuen Wert Seitenattribute merken
+/* [Description]
 
+   Store new value of page attributes
 */
 
 {
@@ -1124,14 +1093,12 @@ void SvxRuler::Update
 
 void SvxRuler::SetDefTabDist
 (
- long l                                                 // Neuer Abstand fuer DefaultTabs in App-Metrik
+ long l  // New distance for DefaultTabs in App-Metrics
 )
 
-/*
-   [Beschreibung]
-
-   Neuer Abstand fuer DefaultTabs wird gesetzt
+/* [Description]
 
+   New distance is set for DefaultTabs
 */
 
 {
@@ -1143,11 +1110,9 @@ void SvxRuler::SetDefTabDist
 
 long SvxRuler::GetDefTabDist() const
 
-/*
-   [Beschreibung]
-
-   Wert fuer DefaultTabs erfragen (wird in App.-Methik geliefert)
+/* [Description]
 
+   Get value for DefaultTab (is delivered in App-metrics)
 */
 
 {
@@ -1157,11 +1122,9 @@ long SvxRuler::GetDefTabDist() const
 
 USHORT ToSvTab_Impl(SvxTabAdjust eAdj)
 
-/*
-   [Beschreibung]
-
-   Interne Konvertierungsroutinen zwischen SV-Tab.-Enum und Svx
+/* [Description]
 
+   Internal convertion routine between SV-Tab.-Enum and Svx
 */
 
 {
@@ -1192,11 +1155,9 @@ SvxTabAdjust ToAttrTab_Impl(USHORT eAdj)
 
 void SvxRuler::UpdateTabs()
 
-/*
-   [Beschreibung]
-
-   Anzeige der Tabulatoren
+/* [Description]
 
+   Update of Tabs
 */
 
 {
@@ -1204,8 +1165,8 @@ void SvxRuler::UpdateTabs()
         return;
     if(pPagePosItem && pParaItem && pTabStopItem && !pObjectItem)
     {
-        // Puffer fuer DefaultTabStop
-        // Abstand letzter Tab <-> Rechter Absatzrand / DefaultTabDist
+        // buffer for DefaultTabStop
+        // Distance last Tab <-> Right paragraph margin / DefaultTabDist
         BOOL bRTL = pRuler_Imp->pTextRTLItem && pRuler_Imp->pTextRTLItem->GetValue();
         long nLeftFrameMargin = GetLeftFrameMargin();
         long nRightFrameMargin = GetRightFrameMargin();
@@ -1233,7 +1194,7 @@ void SvxRuler::UpdateTabs()
         if(pTabStopItem->Count() + TAB_GAP + nDefTabBuf > nTabBufSize)
         {
             delete[] pTabs;
-            // 10 (GAP) auf Vorrat
+            // 10 (GAP) in stock
             nTabBufSize = pTabStopItem->Count() + TAB_GAP + nDefTabBuf + GAP;
             pTabs = new RulerTab[nTabBufSize];
         }
@@ -1259,7 +1220,7 @@ void SvxRuler::UpdateTabs()
         if(!pTabStopItem->Count())
             pTabs[0].nPos = bRTL ? lRightPixMargin : lParaIndentPix;
 
-        // Rest mit Default-Tabs fuellen
+        // fill the rest with default Tabs
         if(bRTL)
         {
             for(j = 0; j < nDefTabBuf; ++j)
@@ -1319,7 +1280,7 @@ void SvxRuler::UpdateTabs()
             }
         }
         SetTabs(nTabCount, pTabs+TAB_GAP);
-        DBG_ASSERT(nTabCount + TAB_GAP <= nTabBufSize, "BufferSize zu klein");
+        DBG_ASSERT(nTabCount + TAB_GAP <= nTabBufSize, "BufferSize too small");
     }
     else
     {
@@ -1330,14 +1291,12 @@ void SvxRuler::UpdateTabs()
 
 void SvxRuler::Update
 (
- const SvxTabStopItem *pItem    // Neuer Wert fuer Tabulatoren
+ const SvxTabStopItem *pItem    // new value for tabs
 )
 
-/*
-   [Beschreibung]
-
-   Neuen Wert fuer Tabulatoren merken; alten gfs. loeschen
+/* [Description]
 
+   Store new value for tabs; delete old ones if possible
 */
 
 {
@@ -1357,14 +1316,12 @@ void SvxRuler::Update
 
 void SvxRuler::Update
 (
- const SvxObjectItem *pItem             // Neuer Wert fuer Objekte
+ const SvxObjectItem *pItem             // new value for objects
 )
 
-/*
-   [Beschreibung]
-
-   Neuen Wert fuer Objekte merken
+/* [Description]
 
+   Store new value for objects
 */
 
 {
@@ -1380,7 +1337,7 @@ void SvxRuler::Update
 
 void SvxRuler::SetNullOffsetLogic
 (
- long lVal                                              // Setzen des logischen NullOffsets
+ long lVal  // Setting of the logic NullOffsets
 )
 {
     lAppNullOffset = lLogicNullOffset - lVal;
@@ -1392,11 +1349,9 @@ void SvxRuler::SetNullOffsetLogic
 
 void SvxRuler::Update()
 
-/*
-   [Beschreibung]
-
-   Aktualisierung der Anzeige anstossen
+/* [Description]
 
+   Perform update of view
 */
 
 {
@@ -1425,11 +1380,9 @@ inline long SvxRuler::GetPageWidth() const
 
 inline long SvxRuler::GetFrameLeft() const
 
-/*
-   [Beschreibung]
-
-   Erfragen des linken Randes in Pixeln
+/* [Description]
 
+   Get Left margin in Pixels
 */
 
 
@@ -1441,11 +1394,9 @@ inline long SvxRuler::GetFrameLeft() const
 
 inline void SvxRuler::SetFrameLeft(long l)
 
-/*
-   [Beschreibung]
-
-   Setzen des linken Randes in Pixeln
+/* [Description]
 
+   Set Left margin in Pixels
 */
 
 {
@@ -1462,10 +1413,9 @@ inline void SvxRuler::SetFrameLeft(long l)
 
 long SvxRuler::GetFirstLineIndent() const
 
-/*
-   [Beschreibung]
+/* [Description]
 
-   Erstzeileneinzug in Pixels erfragen
+   Get First-line indent in pixels
 */
 
 {
@@ -1475,10 +1425,9 @@ long SvxRuler::GetFirstLineIndent() const
 
 long SvxRuler::GetLeftIndent() const
 
-/*
-   [Beschreibung]
+/* [Description]
 
-   Linken Absatzrand in Pixels erfragen
+   Get Left paragraph margin in Pixels
 */
 
 {
@@ -1489,10 +1438,9 @@ long SvxRuler::GetLeftIndent() const
 
 long SvxRuler::GetRightIndent() const
 
-/*
-   [Beschreibung]
+/* [Description]
 
-   Rechten Absatzrand in Pixels erfragen
+   Get Right paragraph margin in Pixels
 */
 
 {
@@ -1502,20 +1450,17 @@ long SvxRuler::GetRightIndent() const
 
 long SvxRuler::GetLogicRightIndent() const
 
-/*
-   [Beschreibung]
+/* [Description]
 
-   Rechten Absatzrand in Logic erfragen
+   Get Right paragraph margin in Logic
 */
 
 {
     return pParaItem ? GetRightFrameMargin()-pParaItem->GetRight() : GetRightFrameMargin();
 }
 
-// linker Rand in App-Werten; ist entweder der Seitenrand (=0)
-// oder der linke Rand der Spalte, die im Spaltenattribut als
-// altuelle Spalte eingestellt ist.
-
+// Left margin in App values, is either the margin (= 0)  or the left edge of
+// the column that is set in the column attribute as current column.
 long SvxRuler::GetLeftFrameMargin() const
 {
     // #126721# for some unknown reason the current column is set to 0xffff
@@ -1531,7 +1476,7 @@ long SvxRuler::GetLeftFrameMargin() const
 
 inline long SvxRuler::GetLeftMin() const
 {
-    DBG_ASSERT(pMinMaxItem, "kein MinMax-Wert gesetzt");
+    DBG_ASSERT(pMinMaxItem, "no MinMax value set");
     return pMinMaxItem?
         bHorz?  pMinMaxItem->GetValue().Left(): pMinMaxItem->GetValue().Top()
                 : 0;
@@ -1539,7 +1484,7 @@ inline long SvxRuler::GetLeftMin() const
 
 inline long SvxRuler::GetRightMax() const
 {
-    DBG_ASSERT(pMinMaxItem, "kein MinMax-Wert gesetzt");
+    DBG_ASSERT(pMinMaxItem, "no MinMax value set");
     return pMinMaxItem?
         bHorz? pMinMaxItem->GetValue().Right(): pMinMaxItem->GetValue().Bottom()
             : 0;
@@ -1548,11 +1493,9 @@ inline long SvxRuler::GetRightMax() const
 
 long SvxRuler::GetRightFrameMargin() const
 
-/*
-   [Beschreibung]
-
-   Rechten umgebenden Rand erfragen (in logischen Einheiten)
+/* [Description]
 
+   Get right frame margin (in logical units)
 */
 
 {
@@ -1569,7 +1512,7 @@ long SvxRuler::GetRightFrameMargin() const
 
     long l = lLogicNullOffset;
 
-    // gfs. rechten Tabelleneinzug abziehen
+    // If possible deduct right table entry
     if(pColumnItem && pColumnItem->IsTable())
         l += pColumnItem->GetRight();
     else if(bHorz && pLRSpaceItem)
@@ -1594,12 +1537,10 @@ long SvxRuler::GetRightFrameMargin() const
 
 long SvxRuler::GetCorrectedDragPos( BOOL bLeft, BOOL bRight )
 
-/*
-   [Beschreibung]
-
-   Korrigiert die Position innerhalb der errechneten Grenzwerte.
-   Die Grenzwerte sind in Pixel relativ zum Seitenrand.
+/* [Description]
 
+   Corrects the position within the calculated limits. The limit values are in
+   pixels relative to the page edge.
 */
 
 {
@@ -1618,16 +1559,14 @@ ADD_DEBUG_TEXT("lDragPos: ", String::CreateFromInt32(lDragPos))
 
 void ModifyTabs_Impl
 (
- USHORT nCount,                                 // Anzahl Tabs
- RulerTab *pTabs,                               // Tab-Puffer
- long lDiff                                     // zu addierende Differenz
+ USHORT nCount,                                 // Number of Tabs
+ RulerTab *pTabs,                               // Tab buffer
+ long lDiff                                     // difference to be added
  )
 
-/*
-   [Beschreibung]
-
-   Hilfsroutine; alle Tabs um einen festen Wert verschieben
+/* [Description]
 
+   Helper function, move all the tabs by a fixed value
 */
 {
     if( pTabs )
@@ -1638,18 +1577,15 @@ void ModifyTabs_Impl
 
 void SvxRuler::DragMargin1()
 
-/*
-   [Beschreibung]
-
-   Draggen des linken Frame-Randes
+/* [Description]
 
+   Dragging the left edge of frame
 */
 {
     const long lDragPos = GetCorrectedDragPos( !TAB_FLAG || !NEG_FLAG, TRUE );
     DrawLine_Impl(lTabPos, ( TAB_FLAG && NEG_FLAG ) ? 3 : 7, bHorz);
     if(pColumnItem&&
-       (//nDragType & DRAG_OBJECT_SIZE_LINEAR ||
-        nDragType & DRAG_OBJECT_SIZE_PROPORTIONAL))
+       (nDragType & DRAG_OBJECT_SIZE_PROPORTIONAL))
         DragBorders();
     AdjustMargin1(lDragPos);
 }
@@ -1674,7 +1610,7 @@ void SvxRuler::AdjustMargin1(long lDiff)
 
             if(!pColumnItem && !pObjectItem && pParaItem)
             {
-                // Rechten Einzug an alter Position
+                // Right indent of the old position
                 pIndents[INDENT_RIGHT_MARGIN].nPos -= _lDiff;
                 SetIndents(INDENT_COUNT, pIndents+INDENT_GAP);
             }
@@ -1691,7 +1627,7 @@ void SvxRuler::AdjustMargin1(long lDiff)
                 SetBorders(pColumnItem->Count()-1, pBorders);
                 if(pColumnItem->IsFirstAct())
                 {
-                    // Rechten Einzug an alter Position
+                    // Right indent of the old position
                     if(pParaItem)
                     {
                         pIndents[INDENT_RIGHT_MARGIN].nPos -= _lDiff;
@@ -1727,7 +1663,7 @@ void SvxRuler::AdjustMargin1(long lDiff)
         {
             if(!pColumnItem && !pObjectItem && pParaItem)
             {
-                // Linke Einzuege an alter Position
+                // Left indent of the old position
                 pIndents[INDENT_FIRST_LINE].nPos += _lDiff;
                 pIndents[INDENT_LEFT_MARGIN].nPos += _lDiff;
                 SetIndents(INDENT_COUNT, pIndents+INDENT_GAP);
@@ -1740,7 +1676,7 @@ void SvxRuler::AdjustMargin1(long lDiff)
                 SetBorders(pColumnItem->Count()-1, pBorders);
                 if(pColumnItem->IsFirstAct())
                 {
-                    // Linke Einzuege an alter Position
+                    // Left indent of the old position
                     if(pParaItem)
                     {
                         pIndents[INDENT_FIRST_LINE].nPos += _lDiff;
@@ -1770,11 +1706,10 @@ void SvxRuler::AdjustMargin1(long lDiff)
 
 
 void SvxRuler::DragMargin2()
-/*
-   [Beschreibung]
 
-   Draggen des rechten Frame-Randes
+/* [Description]
 
+   Dragging the right edge of frame
 */
 {
     const long lDragPos = GetCorrectedDragPos( TRUE, !TAB_FLAG || !NEG_FLAG);
@@ -1782,8 +1717,7 @@ void SvxRuler::DragMargin2()
     long lDiff = lDragPos - GetMargin2();
 
     if(pRuler_Imp->bIsTableRows && !bHorz && pColumnItem&&
-       (//nDragType & DRAG_OBJECT_SIZE_LINEAR ||
-        nDragType & DRAG_OBJECT_SIZE_PROPORTIONAL))
+       (nDragType & DRAG_OBJECT_SIZE_PROPORTIONAL))
         DragBorders();
 
     BOOL bProtectColumns =
@@ -1793,7 +1727,7 @@ void SvxRuler::DragMargin2()
         bProtectColumns ? 0 : RULER_MARGIN_SIZEABLE;
     SetMargin2( lDragPos, nMarginStyle );
 
-    // Rechten Einzug an alter Position
+    // Right indent of the old position
     if((!pColumnItem || IsActLastColumn()) && pParaItem)
     {
         pIndents[INDENT_FIRST_LINE].nPos += lDiff;
@@ -1803,11 +1737,10 @@ void SvxRuler::DragMargin2()
 
 
 void SvxRuler::DragIndents()
-/*
-   [Beschreibung]
 
-   Draggen der Absatzeinzuege
+/* [Description]
 
+   Dragging the paragraph indents
 */
 {
     const long lDragPos = NEG_FLAG ? GetDragPos() : GetCorrectedDragPos();
@@ -1828,12 +1761,11 @@ void SvxRuler::DragIndents()
 
 
 void SvxRuler::DrawLine_Impl(long &_lTabPos, int nNew, BOOL Hori)
-/*
-   [Beschreibung]
 
-   Ausgaberoutine fuer Hilfslinie beim Vereschieben von Tabs, Tabellen-
-   und anderen Spalten
+/* [Description]
 
+   Output routine for the ledger line when moving tabs, tables and other
+   columns
 */
 {
     if(Hori)
@@ -1889,11 +1821,9 @@ void SvxRuler::DrawLine_Impl(long &_lTabPos, int nNew, BOOL Hori)
 
 void SvxRuler::DragTabs()
 
-/*
-   [Beschreibung]
-
-   Draggen von Tabs
+/* [Description]
 
+   Dragging of Tabs
 */
 {
 
@@ -1910,7 +1840,7 @@ void SvxRuler::DragTabs()
         for(USHORT i = nIdx; i < nTabCount; ++i)
         {
             pTabs[i].nPos += nDiff;
-            // auf Maximum begrenzen
+            // limit on maximum
             if(pTabs[i].nPos > GetMargin2())
                 pTabs[nIdx].nStyle |= RULER_STYLE_INVISIBLE;
             else
@@ -1924,7 +1854,7 @@ void SvxRuler::DragTabs()
         for(USHORT i = nIdx+1; i < nTabCount; ++i)
         {
             if(pTabs[i].nStyle & RULER_TAB_DEFAULT)
-                // bei den DefaultTabs kann abgebrochen werden
+                // can be canceled at the DefaultTabs
                 break;
             long nDelta = pRuler_Imp->nTotalDist * pRuler_Imp->pPercBuf[i];
             nDelta /= 1000;
@@ -1952,24 +1882,6 @@ void SvxRuler::SetActive(BOOL bOn)
     if(bOn)
     {
         Activate();
-/*      pBindings->Invalidate( SID_RULER_LR_MIN_MAX, TRUE, TRUE );
-        pBindings->Update( SID_RULER_LR_MIN_MAX );
-        pBindings->Invalidate( SID_ATTR_LONG_ULSPACE, TRUE, TRUE );
-        pBindings->Update( SID_ATTR_LONG_ULSPACE );
-        pBindings->Invalidate( SID_ATTR_LONG_LRSPACE, TRUE, TRUE );
-        pBindings->Update( SID_ATTR_LONG_LRSPACE );
-        pBindings->Invalidate( SID_RULER_PAGE_POS, TRUE, TRUE );
-        pBindings->Update( SID_RULER_PAGE_POS );
-        pBindings->Invalidate( SID_ATTR_TABSTOP, TRUE, TRUE );
-        pBindings->Update( SID_ATTR_TABSTOP );
-        pBindings->Invalidate( SID_ATTR_PARA_LRSPACE, TRUE, TRUE );
-        pBindings->Update( SID_ATTR_PARA_LRSPACE );
-        pBindings->Invalidate( SID_RULER_BORDERS, TRUE, TRUE );
-        pBindings->Update( SID_RULER_BORDERS );
-        pBindings->Invalidate( SID_RULER_OBJECT, TRUE, TRUE );
-        pBindings->Update( SID_RULER_OBJECT );
-        pBindings->Invalidate( SID_RULER_PROTECT, TRUE, TRUE );
-        pBindings->Update( SID_RULER_PROTECT );*/
     }
     else
         Deactivate();
@@ -1992,15 +1904,13 @@ void SvxRuler::SetActive(BOOL bOn)
 
 void SvxRuler::UpdateParaContents_Impl
 (
- long l,                                                // Differenz
- UpdateType eType                               // Art (alle, links oder rechts)
+ long l,           // Difference
+ UpdateType eType  // Art (all, left or right)
 )
 
-/*
-   [Beschreibung]
-
-   Hilfsroutine; Mitfuehren von Tabulatoren und Absatzraendern
+/* [Description]
 
+   Helper function; carry Tabs and Paragraph Margins
 */
 {
     switch(eType) {
@@ -2027,14 +1937,11 @@ void SvxRuler::UpdateParaContents_Impl
 }
 
 
-
 void SvxRuler::DragBorders()
 
-/*
-   [Beschreibung]
-
-   Draggen von Borders (Tabellen- und anderen Spalten)
+/* [Description]
 
+   Dragging of Borders (Tables and other columns)
 */
 {
     BOOL bLeftIndentsCorrected = FALSE, bRightIndentsCorrected = FALSE;
@@ -2064,24 +1971,22 @@ ADD_DEBUG_TEXT("lLastLMargin: ", String::CreateFromInt32(pRuler_Imp->lLastLMargi
                 lPos-nDragOffset - pBorders[nIdx].nPos
                 : GetDragType() == RULER_TYPE_MARGIN1 ? lPos - pRuler_Imp->lLastLMargin : lPos - pRuler_Imp->lLastRMargin;
 
-//          pBorders[nIdx].nPos += lDiff;
-//          lDiff = pBorders[nIdx].nPos - nOld;
             if(nDragType & DRAG_OBJECT_SIZE_LINEAR)
             {
-                long nRight = GetMargin2()-lMinFrame; // rechter Begrenzer
+                long nRight = GetMargin2()-lMinFrame; // Right limiters
                 for(int i = nBorderCount-2; i >= nIdx; --i)
                 {
                     long l = pBorders[i].nPos;
                     pBorders[i].nPos += lDiff;
                     pBorders[i].nPos = Min(pBorders[i].nPos, nRight - pBorders[i].nWidth);
                     nRight = pBorders[i].nPos - lMinFrame;
-                    // RR der Spalte aktualisieren
+                    // RR update the column
                     if(i == GetActRightColumn())
                     {
                         UpdateParaContents_Impl(pBorders[i].nPos - l, MOVE_RIGHT);
                         bRightIndentsCorrected = TRUE;
                     }
-                    // LAR, EZE der Spalte aktualisieren
+                    // LAR, EZE update the column
                     else if(i == GetActLeftColumn())
                     {
                         UpdateParaContents_Impl(pBorders[i].nPos - l, MOVE_LEFT);
@@ -2131,7 +2036,7 @@ ADD_DEBUG_TEXT("lLastLMargin: ", String::CreateFromInt32(pRuler_Imp->lLastLMargi
                 break;
                 case RULER_TYPE_MARGIN2:
                     nLimit = 0;
-                    lLeft= 0;//pRuler_Imp->lLastRMargin + lDiff;
+                    lLeft= 0;
                     nStartLimit = nBorderCount - 2;
                     pRuler_Imp->nTotalDist += lDiff;
                 break;
@@ -2145,7 +2050,7 @@ ADD_DEBUG_TEXT("lLastLMargin: ", String::CreateFromInt32(pRuler_Imp->lLastLMargi
                         (pRuler_Imp->nTotalDist*pRuler_Imp->pPercBuf[i])/1000+
                             pRuler_Imp->pBlockBuf[i];
 
-                    // RR der Spalte aktualisieren
+                    // RR update the column
                     if(!pRuler_Imp->bIsTableRows)
                     {
                         if(i == GetActRightColumn())
@@ -2153,7 +2058,7 @@ ADD_DEBUG_TEXT("lLastLMargin: ", String::CreateFromInt32(pRuler_Imp->lLastLMargi
                             UpdateParaContents_Impl(pBorders[i].nPos - l, MOVE_RIGHT);
                             bRightIndentsCorrected = TRUE;
                         }
-                        // LAR, EZE der Spalte aktualisieren
+                        // LAR, EZE update the column
                         else if(i == GetActLeftColumn())
                         {
                             UpdateParaContents_Impl(pBorders[i].nPos - l, MOVE_LEFT);
@@ -2252,11 +2157,9 @@ ADD_DEBUG_TEXT("lLastLMargin: ", String::CreateFromInt32(pRuler_Imp->lLastLMargi
 
 void SvxRuler::DragObjectBorder()
 
-/*
-   [Beschreibung]
-
-   Draggen von Objektraendern
+/* [Description]
 
+   Dragging of object edges
 */
 {
     if(RULER_DRAGSIZE_MOVE == GetDragSize())
@@ -2272,11 +2175,10 @@ void SvxRuler::DragObjectBorder()
 
 
 void SvxRuler::ApplyMargins()
-/*
-   [Beschreibung]
 
-   Anwenden von Randeinstellungen; durch Draggen veraendert.
+/* [Description]
 
+   Applying margins; changed by dragging.
 */
 {
     const SfxPoolItem *pItem = 0;
@@ -2337,11 +2239,10 @@ void SvxRuler::ApplyMargins()
 
 
 void SvxRuler::ApplyIndents()
-/*
-   [Beschreibung]
 
-   Anwenden von Absatzeinstellungen; durch Draggen veraendert.
+/* [Description]
 
+   Applying paragraph settings; changed by dragging.
 */
 {
     long nNewTxtLeft;
@@ -2381,9 +2282,10 @@ void SvxRuler::ApplyIndents()
                 lAppNullOffset,
                 pParaItem->GetTxtFirstLineOfst());
 
-    // #62986# : Ist der neue TxtLeft kleiner als der alte FirstLineIndent,
-    // dann geht die Differenz verloren und der Absatz wird insgesamt
-    // zu weit eingerueckt, deswegen erst den FirstLineOffset setzen, dann den TxtLeft
+    // If the new TxtLeft is smaller than the old FirstLineIndent, then the
+    // difference is lost and the paragraph is in total indented too far,
+    // so first set the FirstLineOffset, then the TxtLeft
+
     if(bRTL)
     {
         long nLeftFrameMargin = GetLeftFrameMargin();
@@ -2446,11 +2348,10 @@ void SvxRuler::ApplyIndents()
 
 
 void SvxRuler::ApplyTabs()
-/*
-   [Beschreibung]
 
-   Anwenden von Tabulatoreinstellungen; durch Draggen veraendert.
+/* [Description]
 
+   Apply tab settings, changed by dragging.
 */
 {
     BOOL bRTL = pRuler_Imp->pTextRTLItem && pRuler_Imp->pTextRTLItem->GetValue();
@@ -2535,11 +2436,10 @@ void SvxRuler::ApplyTabs()
 
 
 void SvxRuler::ApplyBorders()
-/*
-   [Beschreibung]
 
-   Anwenden von (Tabellen-)Spalteneinstellungen; durch Draggen veraendert.
+/* [Description]
 
+   Applying (table) column settings; changed by dragging.
 */
 {
     if(pColumnItem->IsTable())
@@ -2569,8 +2469,8 @@ void SvxRuler::ApplyBorders()
                              pBorders[i].nWidth) -
             lAppNullOffset,
             (*pColumnItem)[i+1].nStart);
-        // Es kann sein, dass aufgrund der PIXEL_H_ADJUST rejustierung auf
-        // alte Werte die Breite < 0 wird. Das rerejustieren wir.
+        // It may be that, due to the PIXEL_H_ADJUST readjustment to old values,
+        // the width becomes  < 0. This we readjust.
         if( nEnd > nStart )
             nStart = nEnd;
     }
@@ -2585,14 +2485,13 @@ void SvxRuler::ApplyBorders()
 }
 
 void SvxRuler::ApplyObject()
-/*
-   [Beschreibung]
 
-   Anwenden von Objekteinstellungen; durch Draggen veraendert.
+/* [Description]
 
+   Applying object settings, changed by dragging.
 */
 {
-        // zum Seitenrand
+    // to the page margin
     long nMargin = pLRSpaceItem? pLRSpaceItem->GetLeft(): 0;
     pObjectItem->SetStartX(
                            PixelAdjust(
@@ -2615,12 +2514,11 @@ void SvxRuler::ApplyObject()
 }
 
 void SvxRuler::PrepareProportional_Impl(RulerType eType)
-/*
-   [Beschreibung]
 
-   Vorbereitung proportionales Draggen; es wird der proportionale
-   Anteil bezogen auf die Gesamtbreite in Promille berechnet.
+/* [Description]
 
+   Preparation proportional dragging, and it is calculated based on the
+   proportional share of the total width in parts per thousand.
 */
 {
     pRuler_Imp->nTotalDist = GetMargin2();
@@ -2630,7 +2528,7 @@ void SvxRuler::PrepareProportional_Impl(RulerType eType)
       case RULER_TYPE_MARGIN1:
       case RULER_TYPE_BORDER:
         {
-            DBG_ASSERT(pColumnItem, "kein ColumnItem");
+            DBG_ASSERT(pColumnItem, "no ColumnItem");
 
             pRuler_Imp->SetPercSize(pColumnItem->Count());
 
@@ -2747,15 +2645,14 @@ void SvxRuler::PrepareProportional_Impl(RulerType eType)
 
 void SvxRuler::EvalModifier()
 
-/*
-   [Beschreibung]
+/* [Description]
 
-   Modifier Draggen auswerten
+   Eval Drag Modifier
 
-   Shift: Linear verschieben
-   Control: Proportional verschieben
-   Shift+Control: Tabelle: nur aktuelle Zeile
-   alt: Bemassungspfeile (n.i.) //!!
+   Shift: move linear
+   Control: move proportional
+   Shift+Control: Table: only current line
+   Alt: dimension arrows (not implemented) //!!
 
 */
 
@@ -2787,18 +2684,16 @@ void SvxRuler::EvalModifier()
            GetDragType()!=RULER_TYPE_MARGIN2)
             nDragType = DRAG_OBJECT_ACTLINE_ONLY;
         break;
-        // alt: Bemassungspfeile
+        // ALT: Dimension arrows
     }
 }
 
 
 void SvxRuler::Click()
 
-/*
-   [Beschreibung]
-
-   Ueberladener Handler SV; setzt Tab per Dispatcheraufruf
+/* [Description]
 
+   Overloaded handler SV; sets Tab per dispatcher call
 */
 
 {
@@ -2852,16 +2747,15 @@ void SvxRuler::Click()
 
 BOOL SvxRuler::CalcLimits
 (
- long &nMax1,                                   // zu setzenden Minimalwert
- long &nMax2,                                   // zu setzenden Maximalwert
+ long &nMax1,                                   // minimum value to be set
+ long &nMax2,                                   // minimum value to be set
  BOOL
 ) const
-/*
-   [Beschreibung]
 
-   Defaultimplementierung der virtuellen Funktion; kann die Applikation
-   ueberladen, um eine eigene Grenzwertbehandlung zu implementieren.
-   Die Werte sind auf die Seite bezogen.
+/* [Description]
+
+   Default implementation of the virtual function; the application can be
+   overloaded to implement customized limits. The values are based on the page.
 */
 {
     nMax1 = LONG_MIN;
@@ -2872,12 +2766,10 @@ BOOL SvxRuler::CalcLimits
 
 void SvxRuler::CalcMinMax()
 
-/*
-   [Beschreibung]
-
-   Berechnet die Grenzwerte fuers Draggen; diese sind in Pixeln
-   relativ zum Seitenrand
+/* [Description]
 
+   Calculates the limits for dragging; which are in pixels relative to the
+   page edge
 */
 
 {
@@ -2887,8 +2779,8 @@ void SvxRuler::CalcMinMax()
     switch(GetDragType())
     {
       case RULER_TYPE_MARGIN1:
-        {        // linker Rand umgebender Frame
-            // DragPos - NOf zwischen links - rechts
+        {        // left edge of the surrounding Frame
+            // DragPos - NOf between left - right
             pRuler_Imp->lMaxLeftLogic = GetLeftMin();
             nMaxLeft=ConvertSizePixel(pRuler_Imp->lMaxLeftLogic);
 
@@ -2910,7 +2802,8 @@ void SvxRuler::CalcMinMax()
             else if(pRuler_Imp->bIsTableRows)
             {
                 //top border is not moveable when table rows are displayed
-                // protection of content means the margin is not moveable - it's just a page break inside of a cell
+                // protection of content means the margin is not moveable
+                // - it's just a page break inside of a cell
                 if(bHorz && !pRuler_Imp->aProtectItem.IsCntntProtected())
                 {
                     nMaxLeft = pBorders[0].nMinPos + lNullPix;
@@ -2926,7 +2819,6 @@ void SvxRuler::CalcMinMax()
             else
             {
                 if(nDragType & DRAG_OBJECT_SIZE_PROPORTIONAL)
-                   //nDragType & DRAG_OBJECT_SIZE_LINEAR)
                 {
                     nMaxRight=lNullPix+CalcPropMaxRight();
                 }
@@ -2961,7 +2853,7 @@ void SvxRuler::CalcMinMax()
                     else
                         nMaxRight +=GetRightIndent() -
                             Max(GetFirstLineIndent(), GetLeftIndent());
-                    // den linken Tabellen-Rand nicht ueber den Seitenrand ziehen
+                    // Do not drag the left table edge over the edge of the page
                     if(pLRSpaceItem&&pColumnItem->IsTable())
                     {
                         long nTmp=ConvertSizePixel(pLRSpaceItem->GetLeft());
@@ -2973,7 +2865,7 @@ void SvxRuler::CalcMinMax()
             break;
         }
       case RULER_TYPE_MARGIN2:
-     {        // rechter Rand umgebender Frame
+     {        // right edge of the surrounding Frame
         pRuler_Imp->lMaxRightLogic =
             pMinMaxItem ?
                 GetPageWidth() - GetRightMax() : GetPageWidth();
@@ -3025,7 +2917,7 @@ void SvxRuler::CalcMinMax()
         else
         {
             nMaxLeft = lMinFrame + lNullPix;
-            if(IsActLastColumn() || pColumnItem->Count() < 2 ) //Falls letzte Spalte aktiv
+            if(IsActLastColumn() || pColumnItem->Count() < 2 ) //If last active column
             {
                 if(bRTL)
                 {
@@ -3053,7 +2945,7 @@ void SvxRuler::CalcMinMax()
         break;
     }
     case RULER_TYPE_BORDER:
-    {                // Tabelle, Spalten (Modifier)
+    {                // Table, column (Modifier)
         const USHORT nIdx = GetDragAryPos();
         switch(GetDragSize())
         {
@@ -3182,7 +3074,7 @@ void SvxRuler::CalcMinMax()
                         nMaxLeft += nDragOffset;
 
                         // nMaxRight
-                        // linear / proprotional verschieben
+                        // linear / proprotional move
                         if(DRAG_OBJECT_SIZE_PROPORTIONAL & nDragType||
                            (DRAG_OBJECT_SIZE_LINEAR & nDragType) )
                         {
@@ -3196,7 +3088,7 @@ void SvxRuler::CalcMinMax()
                         else
                         {
                             if(nRightCol==USHRT_MAX)
-                            { // letzte Spalte
+                            { // last column
                                 nMaxRight = GetMargin2() + lNullPix;
                                 if(IsActLastColumn())
                                 {
@@ -3273,7 +3165,7 @@ void SvxRuler::CalcMinMax()
           case RULER_DRAGSIZE_2:
             {
                 nMaxLeft = lNullPix + pBorders[nIdx].nPos;
-                if(nIdx == pColumnItem->Count()-2) { // letzte Spalte
+                if(nIdx == pColumnItem->Count()-2) { // last column
                     nMaxRight = GetMargin2() + lNullPix;
                     if(pColumnItem->IsLastAct()) {
                         nMaxRight -=
@@ -3318,7 +3210,7 @@ void SvxRuler::CalcMinMax()
                             pBorders[pColumnItem->GetActColumn()-1].nWidth;
                     nMaxRight = lNullPix + GetMargin2();
 
-                    // zusammem draggen
+                    // Dragging along
                     if((INDENT_FIRST_LINE - INDENT_GAP) != nIdx &&
                        (nDragType & DRAG_OBJECT_LEFT_INDENT_ONLY) !=
                        DRAG_OBJECT_LEFT_INDENT_ONLY)
@@ -3338,7 +3230,7 @@ void SvxRuler::CalcMinMax()
                             pBorders[pColumnItem->GetActColumn()-1].nWidth;
                     nMaxRight = lNullPix + GetRightIndent() - lMinFrame;
 
-                    // zusammem draggen
+                    // Dragging along
                     if((INDENT_FIRST_LINE - INDENT_GAP) != nIdx &&
                        (nDragType & DRAG_OBJECT_LEFT_INDENT_ONLY) !=
                        DRAG_OBJECT_LEFT_INDENT_ONLY)
@@ -3393,8 +3285,8 @@ void SvxRuler::CalcMinMax()
     }
     case RULER_TYPE_TAB:                // Tabs (Modifier)
         /*
-           links = NOf + Max(LAR, EZ)
-           rechts = NOf + RAR
+           left = NOf + Max(LAR, EZ)
+           right = NOf + RAR
            */
         nMaxLeft = bRTL ? lNullPix + GetRightIndent()
                             : lNullPix + Min(GetFirstLineIndent(), GetLeftIndent());
@@ -3421,18 +3313,16 @@ void SvxRuler::CalcMinMax()
 
 long SvxRuler::StartDrag()
 
-/*
-   [Beschreibung]
+/* [Description]
 
-   Beginn eines Drag-Vorgangs (SV-Handler); wertet Modifier aus
-   und berechnet Grenzwerte
+   Beginning of a drag operation (SV-handler) evaluates modifier and
+   calculated values
 
-   [Querverweise]
+   [Cross-reference]
 
    <SvxRuler::EvalModifier()>
    <SvxRuler::CalcMinMax()>
    <SvxRuler::EndDrag()>
-
 */
 
 {
@@ -3448,8 +3338,8 @@ long SvxRuler::StartDrag()
     if(bOk) {
         lInitialDragPos = GetDragPos();
         switch(GetDragType()) {
-        case RULER_TYPE_MARGIN1:        // linker Rand umgebender Frame
-        case RULER_TYPE_MARGIN2:        // rechter Rand umgebender Frame
+        case RULER_TYPE_MARGIN1:        // left edge of the surrounding Frame
+        case RULER_TYPE_MARGIN2:        // right edge of the surrounding Frame
             if((bHorz && pLRSpaceItem) || (!bHorz && pULSpaceItem))
             {
                 if(pColumnItem)
@@ -3460,7 +3350,7 @@ long SvxRuler::StartDrag()
             else
                 bOk = FALSE;
             break;
-        case RULER_TYPE_BORDER:                // Tabelle, Spalten (Modifier)
+        case RULER_TYPE_BORDER:                // Table, column (Modifier)
             if(pColumnItem)
             {
                 nDragOffset = pColumnItem->IsTable()? 0 :
@@ -3471,11 +3361,11 @@ long SvxRuler::StartDrag()
             else
                 nDragOffset = 0;
             break;
-        case RULER_TYPE_INDENT: {                // Absatzeinzuege (Modifier)
+        case RULER_TYPE_INDENT: {                // Paragraph indents (Modifier)
             if( bContentProtected )
                 return FALSE;
             USHORT nIndent = INDENT_LEFT_MARGIN;
-            if((nIndent) == GetDragAryPos() + INDENT_GAP) {        // Linker Absatzeinzug
+            if((nIndent) == GetDragAryPos() + INDENT_GAP) {  // Left paragraph indent
                 pIndents[0] = pIndents[INDENT_FIRST_LINE];
                 pIndents[0].nStyle |= RULER_STYLE_DONTKNOW;
                 EvalModifier();
@@ -3505,11 +3395,10 @@ long SvxRuler::StartDrag()
 
 
 void  SvxRuler::Drag()
-/*
-   [Beschreibung]
 
-   SV-Draghandler
+/* [Description]
 
+   SV-Draghandler
 */
 {
     if(IsDragCanceled())
@@ -3518,18 +3407,18 @@ void  SvxRuler::Drag()
         return;
     }
     switch(GetDragType()) {
-    case RULER_TYPE_MARGIN1:        // linker Rand umgebender Frame
+    case RULER_TYPE_MARGIN1:        // left edge of the surrounding Frame
         DragMargin1();
         pRuler_Imp->lLastLMargin=GetMargin1();
         break;
-    case RULER_TYPE_MARGIN2:        // rechter Rand umgebender Frame
+    case RULER_TYPE_MARGIN2:        // right edge of the surrounding Frame
         DragMargin2();
         pRuler_Imp->lLastRMargin = GetMargin2();
         break;
-    case RULER_TYPE_INDENT:         // Absatzeinzuege
+    case RULER_TYPE_INDENT:         // Paragraph indents
         DragIndents();
         break;
-    case RULER_TYPE_BORDER:         // Tabelle, Spalten
+    case RULER_TYPE_BORDER:         // Table, columns
         if(pColumnItem)
             DragBorders();
         else if(pObjectItem)
@@ -3545,14 +3434,12 @@ void  SvxRuler::Drag()
 
 
 void SvxRuler::EndDrag()
-/*
-   [Beschreibung]
 
-   SV-Handler; wird beim Beenden des Draggens gerufen.
-   Stoesst die Aktualisierung der Daten der Applikation an, indem
-   durch Aufruf der jeweiligen Apply...()- Methoden die Daten an die
-   Applikation geschickt werden.
+/* [Description]
 
+   SV-handler; is called when ending the dragging. Triggers the updating of data
+   on the application, by calling the respective Apply...() methods to send the
+   data to the application.
 */
 {
     const BOOL bUndo = IsDragCanceled();
@@ -3562,8 +3449,8 @@ void SvxRuler::EndDrag()
     if(!bUndo)
         switch(GetDragType())
         {
-          case RULER_TYPE_MARGIN1:   // linker, oberer Rand umgebender Frame
-          case RULER_TYPE_MARGIN2:   // rechter, unterer Rand umgebender Frame
+          case RULER_TYPE_MARGIN1:   // upper left edge of the surrounding Frame
+          case RULER_TYPE_MARGIN2:   // lower right edge of the surrounding Frame
             {
                 if(!pColumnItem || !pColumnItem->IsTable())
                     ApplyMargins();
@@ -3575,7 +3462,7 @@ void SvxRuler::EndDrag()
 
             }
             break;
-          case RULER_TYPE_BORDER:                // Tabelle, Spalten
+          case RULER_TYPE_BORDER:                // Table, columns
             if(lInitialDragPos != lPos ||
                 (pRuler_Imp->bIsTableRows && bHorz)) //special case - the null offset is changed here
             {
@@ -3589,7 +3476,7 @@ void SvxRuler::EndDrag()
                     ApplyObject();
             }
             break;
-          case RULER_TYPE_INDENT:                // Absatzeinzuege
+          case RULER_TYPE_INDENT:                // Paragraph indents
             if(lInitialDragPos != lPos)
                 ApplyIndents();
             SetIndents(INDENT_COUNT, pIndents+INDENT_GAP);
@@ -3610,22 +3497,19 @@ void SvxRuler::EndDrag()
         {
             pCtrlItem[i]->ClearCache();
             pCtrlItem[i]->GetBindings().Invalidate(pCtrlItem[i]->GetId());
-            //      pCtrlItem[i]->UnBind();
-//          pCtrlItem[i]->ReBind();
         }
 }
 
 
 void SvxRuler::ExtraDown()
 
-/*
-   [Beschreibung]
+/* [Description]
 
-   Ueberladene SV-Methode; setzt den neuen Typ fuer den Defaulttabulator.
+   Overloaded SV method, sets the new type for the Default tab.
 */
 
 {
-    // Tabulator Typ umschalten
+    // Switch Tab Type
     if(pTabStopItem &&
         (nFlags & SVXRULER_SUPPORT_TABS) ==        SVXRULER_SUPPORT_TABS) {
         ++nDefTabType;
@@ -3638,19 +3522,15 @@ void SvxRuler::ExtraDown()
 
 
 void SvxRuler::Notify(SfxBroadcaster&, const SfxHint& rHint)
-/*
-
-   [Beschreibung]
 
-   Benachrichtigung durch die Bindings, dass die Statusaktualisierung
-   beendet ist.
-   Das Lineal aktualisiert seine Darstellung und meldet sich bei den
-   Bindings wieder ab.
+/* [Description]
 
+   Report through the bindings that the status update is completed. The ruler
+   updates its appearance and gets registered again in the bindings.
 */
 
 {
-    // Aktualisierung anstossen
+    // start update
     if(bActive &&
         rHint.Type() == TYPE(SfxSimpleHint) &&
      ((SfxSimpleHint&) rHint ).GetId() == SFX_HINT_UPDATEDONE ) {
@@ -3664,11 +3544,9 @@ void SvxRuler::Notify(SfxBroadcaster&, const SfxHint& rHint)
 
 IMPL_LINK_INLINE_START( SvxRuler, MenuSelect, Menu *, pMenu )
 
-/*
-   [Beschreibung]
-
-   Handler des Kontextmenues fuer das Umschalten der Masseinheit
+/* [Description]
 
+   Handler of the context menus for switching the unit of measurement
 */
 
 {
@@ -3680,11 +3558,9 @@ IMPL_LINK_INLINE_END( SvxRuler, MenuSelect, Menu *, pMenu )
 
 IMPL_LINK( SvxRuler, TabMenuSelect, Menu *, pMenu )
 
-/*
-   [Beschreibung]
-
-   Handler des Tabulatormenues fuer das Setzen des Typs
+/* [Description]
 
+   Handler of the tab menu for setting the type
 */
 
 {
@@ -3705,11 +3581,9 @@ IMPL_LINK( SvxRuler, TabMenuSelect, Menu *, pMenu )
 
 void SvxRuler::Command( const CommandEvent& rCEvt )
 
-/*
-   [Beschreibung]
-
-   Mauskontextmenue fuer das Umschalten der Masseinheit
+/* [Description]
 
+   Mouse context menu for switching the unit of measurement
 */
 
 {
@@ -3739,7 +3613,7 @@ void SvxRuler::Command( const CommandEvent& rCEvt )
                                  String(ResId(RID_SVXSTR_RULER_START+i, DIALOG_MGR())),
                                  Image(aDev.GetBitmap(Point(), aSz), Color(COL_WHITE)));
                 aMenu.CheckItem(i+1, i == pTabs[pRuler_Imp->nIdx+TAB_GAP].nStyle);
-                aDev.SetOutputSize(aSz); // device loeschen
+                aDev.SetOutputSize(aSz); // delete device
             }
             aMenu.Execute( this, rCEvt.GetMousePosPixel() );
         }
@@ -3784,7 +3658,7 @@ USHORT SvxRuler::GetActRightColumn(
 {
     if( nAct == USHRT_MAX )
         nAct = pColumnItem->GetActColumn();
-    else nAct++; //Damit man die ActDrag uebergeben kann
+    else nAct++; //To be able to pass on the ActDrag
 
     BOOL bConsiderHidden = !bForceDontConsiderHidden &&
         !( nDragType & DRAG_OBJECT_ACTLINE_ONLY );
@@ -3840,9 +3714,8 @@ long SvxRuler::CalcPropMaxRight(USHORT nCol) const
 
     if(!(nDragType & DRAG_OBJECT_SIZE_LINEAR))
     {
-
-        // ausgehend vom rechten Rand die Mindestbreiten
-        // aller betroffenen Spalten abziehen
+        // Remove the minimum width for all affected columns
+        // starting from the right edge
         long _nMaxRight = GetMargin2()-GetMargin1();
 
         long lFences=0;
@@ -3881,7 +3754,7 @@ long SvxRuler::CalcPropMaxRight(USHORT nCol) const
         else
         {
             USHORT nActCol;
-            if(nCol==USHRT_MAX) //CalcMinMax fuer LeftMargin
+            if(nCol==USHRT_MAX) //CalcMinMax for LeftMargin
             {
                 lOldPos=GetMargin1();
             }
diff --git a/svx/source/dialog/swframeexample.cxx b/svx/source/dialog/swframeexample.cxx
index 7fb95aa0ad6c..5f79d8937f96 100644
--- a/svx/source/dialog/swframeexample.cxx
+++ b/svx/source/dialog/swframeexample.cxx
@@ -72,7 +72,7 @@ SvxSwFrameExample::~SvxSwFrameExample()
 void SvxSwFrameExample::InitColors_Impl( void )
 {
     const StyleSettings& rSettings = GetSettings().GetStyleSettings();
-    m_aBgCol = Color( rSettings.GetWindowColor() );                             // old: COL_WHITE
+    m_aBgCol = Color( rSettings.GetWindowColor() );
 
     BOOL bHC = rSettings.GetHighContrastMode();
 
@@ -82,9 +82,9 @@ void SvxSwFrameExample::InitColors_Impl( void )
 
     m_aTxtCol = bHC?
         svtools::ColorConfig().GetColorValue(svtools::FONTCOLOR).nColor :
-        Color( COL_GRAY );      // old: COL_GRAY
+        Color( COL_GRAY );
     m_aPrintAreaCol = bHC? m_aTxtCol : Color( COL_GRAY );
-    m_aBorderCol = m_aTxtCol;                                                   // old: COL_BLACK;
+    m_aBorderCol = m_aTxtCol;
     m_aBlankCol = bHC? m_aTxtCol : Color( COL_LIGHTGRAY );
     m_aBlankFrameCol = bHC? m_aTxtCol : Color( COL_GRAY );
 }
@@ -99,10 +99,6 @@ void SvxSwFrameExample::DataChanged( const DataChangedEvent& rDCEvt )
 
 void SvxSwFrameExample::InitAllRects_Impl()
 {
-//    const Size aSz(GetOutputSizePixel());
-
-    // Seite
-//    aPage.SetSize(Size(aSz.Width() - 3, aSz.Height() - 3));
     aPage.SetSize( GetOutputSizePixel() );
 
     ULONG nOutWPix = aPage.GetWidth();
@@ -145,22 +141,22 @@ void SvxSwFrameExample::InitAllRects_Impl()
     }
     aPagePrtArea = Rectangle(Point(nLBorder, nTBorder), Point((nOutWPix - 1) - nRBorder, (nOutHPix - 1) - nBBorder));
 
-    // Beispiel-Text: Vorbereiten fuer die Textausgabe
-    // Eine Textzeile
+    // Example text: Preparing for the text output
+    // A line of text
     aTextLine = aPagePrtArea;
     aTextLine.SetSize(Size(aTextLine.GetWidth(), 2));
     aTextLine.Left()    += nLTxtBorder;
     aTextLine.Right()   -= nRTxtBorder;
     aTextLine.Move(0, nTTxtBorder);
 
-    // Rechteck um Absatz incl. Raender
+    // Rectangle to edges including paragraph
     USHORT nLines = (USHORT)((aPagePrtArea.GetHeight() / 2 - nTTxtBorder - nBTxtBorder)
              / (aTextLine.GetHeight() + 2));
     aPara = aPagePrtArea;
     aPara.SetSize(Size(aPara.GetWidth(),
         (aTextLine.GetHeight() + 2) * nLines + nTTxtBorder + nBTxtBorder));
 
-    // Rechteck um Absatz ohne Raender
+    // Rectangle around paragraph without borders
     aParaPrtArea = aPara;
     aParaPrtArea.Left()     += nLTxtBorder;
     aParaPrtArea.Right()    -= nRTxtBorder;
@@ -192,14 +188,14 @@ void SvxSwFrameExample::InitAllRects_Impl()
         }
     }
 
-    // Innerer Frame fuer am Frame verankerte Rahmen
+    // Inner Frame anchored at the Frame
     aFrameAtFrame = aPara;
     aFrameAtFrame.Left() += 9;
     aFrameAtFrame.Right() -= 5;
     aFrameAtFrame.Bottom() += 5;
     aFrameAtFrame.SetPos(Point(aFrameAtFrame.Left() + 2, (aPagePrtArea.Bottom() - aFrameAtFrame.GetHeight()) / 2 + 5));
 
-    // Groesse des zu positionierenden Rahmens
+    // Size of the frame to be positioned
     if (nAnchor != TextContentAnchorType_AS_CHARACTER)
     {
         ULONG nLFBorder = nAnchor == TextContentAnchorType_AT_PAGE ? nLBorder : nLTxtBorder;
@@ -478,15 +474,10 @@ void SvxSwFrameExample::Paint(const Rectangle&)
 {
     InitAllRects_Impl();
 
-    // Schatten zeichnen
-//    Rectangle aShadow(aPage);
-//    aShadow += Point(3, 3);
-//    DrawRect_Impl(aShadow, Color(COL_GRAY), aTransColor);
-
-    // Seite zeichnen
+    // Draw page
     DrawRect_Impl( aPage, m_aBgCol, m_aBorderCol );
 
-    // PrintArea zeichnen
+    // Draw PrintArea
     Rectangle aRect = DrawInnerFrame_Impl( aPagePrtArea, m_aTransColor, m_aPrintAreaCol );
 
     if (nAnchor == TextContentAnchorType_AT_FRAME)
@@ -495,8 +486,7 @@ void SvxSwFrameExample::Paint(const Rectangle&)
     long lXPos    = 0;
     long lYPos    = 0;
 
-    // Horizontale Ausrichtung
-    //
+    // Horizontal alignment
     if (nAnchor != TextContentAnchorType_AS_CHARACTER)
     {
         switch (nHAlign)
@@ -525,8 +515,7 @@ void SvxSwFrameExample::Paint(const Rectangle&)
     else
        lXPos = aRect.Right() + 2;
 
-    // Vertikale Ausrichtung
-    //
+    // Vertical Alignment
     if (nAnchor != TextContentAnchorType_AS_CHARACTER)
     {
         switch (nVAlign)
@@ -534,7 +523,7 @@ void SvxSwFrameExample::Paint(const Rectangle&)
             case VertOrientation::BOTTOM:
             case VertOrientation::LINE_BOTTOM:
             {
-                // OD 12.11.2003 #i22341#
+                // #i22341#
                 if ( nVRel != RelOrientation::TEXT_LINE )
                 {
                     lYPos = aRect.Bottom() - aFrmSize.Height() + 1;
@@ -553,7 +542,7 @@ void SvxSwFrameExample::Paint(const Rectangle&)
             }
             case VertOrientation::NONE:
             {
-                // OD 12.11.2003 #i22341#
+                // #i22341#
                 if ( nVRel != RelOrientation::CHAR && nVRel != RelOrientation::TEXT_LINE )
                     lYPos = aRect.Top() + aRelPos.Y();
                 else
@@ -561,7 +550,7 @@ void SvxSwFrameExample::Paint(const Rectangle&)
                 break;
             }
             default:
-                // OD 12.11.2003 #i22341#
+                // #i22341#
                 if ( nVRel != RelOrientation::TEXT_LINE )
                 {
                     lYPos = aRect.Top();
@@ -589,10 +578,6 @@ void SvxSwFrameExample::Paint(const Rectangle&)
                 lYPos = aRect.Bottom() - aFrmSize.Height() + 1;
                 break;
 
-/*          case VertOrientation::NONE:
-            case VertOrientation::BOTTOM:
-            case VertOrientation::CHAR_TOP:
-            case VertOrientation::LINE_TOP:*/
             default:
                 lYPos = aRect.Top() - aRelPos.Y();
                 break;
@@ -616,7 +601,7 @@ void SvxSwFrameExample::Paint(const Rectangle&)
     if (aFrmRect.Bottom() > pOuterFrame->Bottom())
         aFrmRect.Move(0, pOuterFrame->Bottom() - aFrmRect.Bottom());
 
-    // Testabsatz zeichnen
+    // Draw Test paragraph
     const long nTxtLineHeight = aTextLine.GetHeight();
     Rectangle aTxt(aTextLine);
     sal_Int32 nStep;
@@ -641,12 +626,11 @@ void SvxSwFrameExample::Paint(const Rectangle&)
 
     if (nAnchor != TextContentAnchorType_AS_CHARACTER)
     {
-        // Text simulieren
-        //
+        // Simulate text
         const long nOldR = aTxt.Right();
         const long nOldL = aTxt.Left();
 
-        // OD 12.11.2003 #i22341#
+        // #i22341#
         const bool bIgnoreWrap = nAnchor == TextContentAnchorType_AT_CHARACTER &&
                            ( nHRel == RelOrientation::CHAR || nVRel == RelOrientation::CHAR ||
                              nVRel == RelOrientation::TEXT_LINE );
@@ -685,7 +669,7 @@ void SvxSwFrameExample::Paint(const Rectangle&)
 
         if (nAnchor != TextContentAnchorType_AT_FRAME && aTxt.Bottom() > aParaPrtArea.Bottom())
         {
-            // Text wurde durch Rahmen verdraengt, daher Para-Hoehe anpassen
+            // Text has been replaced by frame, so adjust parameters height
             ULONG nDiff = aTxt.Bottom() - aParaPrtArea.Bottom();
             aParaPrtArea.Bottom() += nDiff;
             aPara.Bottom() += nDiff;
@@ -704,10 +688,10 @@ void SvxSwFrameExample::Paint(const Rectangle&)
         DrawRect_Impl(aDrawObj, m_aBlankCol, m_aBlankFrameCol );
     }
 
-    // Rechteck zeichnen, zu dem der Rahmen ausgerichtet wird:
+    // Draw rectangle on which the frame is aligned:
     DrawRect_Impl(aRect, m_aTransColor, m_aAlignColor);
 
-    // Frame anzeigen
+    // Frame View
     BOOL bDontFill = (nAnchor == TextContentAnchorType_AT_CHARACTER && aFrmRect.IsOver(aAutoCharFrame)) ? TRUE : bTrans;
     DrawRect_Impl( aFrmRect, bDontFill? m_aTransColor : m_aBgCol, m_aFrameColor );
 }
diff --git a/svx/source/dialog/swframeposstrings.src b/svx/source/dialog/swframeposstrings.src
index 3c9788fa8c9e..6867b0919bdc 100644
--- a/svx/source/dialog/swframeposstrings.src
+++ b/svx/source/dialog/swframeposstrings.src
@@ -236,7 +236,7 @@ Resource RID_SVXSW_FRAMEPOSITIONS
     {
         Text [ en-US ] = "Row" ;
     };
-    // OD 05.01.2004 #i22341#
+    // #i22341#
     String STR_REL_LINE
     {
         Text [ en-US ] = "Line of text" ;
diff --git a/svx/source/engine3d/camera3d.cxx b/svx/source/engine3d/camera3d.cxx
index 40aa705d7467..657ee04e5442 100644
--- a/svx/source/engine3d/camera3d.cxx
+++ b/svx/source/engine3d/camera3d.cxx
@@ -31,12 +31,6 @@
 #include <svx/camera3d.hxx>
 #include <tools/stream.hxx>
 
-/*************************************************************************
-|*
-|* Konstruktor
-|*
-\************************************************************************/
-
 Camera3D::Camera3D(const basegfx::B3DPoint& rPos, const basegfx::B3DPoint& rLookAt,
                    double fFocalLen, double fBankAng) :
     aResetPos(rPos),
@@ -52,24 +46,12 @@ Camera3D::Camera3D(const basegfx::B3DPoint& rPos, const basegfx::B3DPoint& rLook
     SetFocalLength(fFocalLen);
 }
 
-/*************************************************************************
-|*
-|* Default-Konstruktor
-|*
-\************************************************************************/
-
 Camera3D::Camera3D()
 {
     basegfx::B3DPoint aVector3D(0.0 ,0.0 ,1.0);
     Camera3D(aVector3D, basegfx::B3DPoint());
 }
 
-/*************************************************************************
-|*
-|* Konstruktor
-|*
-\************************************************************************/
-
 void Camera3D::Reset()
 {
     SetVPD(0);
@@ -79,11 +61,7 @@ void Camera3D::Reset()
     SetFocalLength(fResetFocalLength);
 }
 
-/*************************************************************************
-|*
-|* Defaultwerte fuer Reset setzen
-|*
-\************************************************************************/
+// Set default values for reset
 
 void Camera3D::SetDefaults(const basegfx::B3DPoint& rPos, const basegfx::B3DPoint& rLookAt,
                             double fFocalLen, double fBankAng)
@@ -94,11 +72,7 @@ void Camera3D::SetDefaults(const basegfx::B3DPoint& rPos, const basegfx::B3DPoin
     fResetBankAngle     = fBankAng;
 }
 
-/*************************************************************************
-|*
-|* ViewWindow setzen und PRP anpassen
-|*
-\************************************************************************/
+// Set ViewWindow and adjust PRP
 
 void Camera3D::SetViewWindow(double fX, double fY, double fW, double fH)
 {
@@ -107,12 +81,6 @@ void Camera3D::SetViewWindow(double fX, double fY, double fW, double fH)
         SetFocalLength(fFocalLength);
 }
 
-/*************************************************************************
-|*
-|* Kameraposition setzen
-|*
-\************************************************************************/
-
 void Camera3D::SetPosition(const basegfx::B3DPoint& rNewPos)
 {
     if ( rNewPos != aPosition )
@@ -124,12 +92,6 @@ void Camera3D::SetPosition(const basegfx::B3DPoint& rNewPos)
     }
 }
 
-/*************************************************************************
-|*
-|* Blickpunkt setzen
-|*
-\************************************************************************/
-
 void Camera3D::SetLookAt(const basegfx::B3DPoint& rNewLookAt)
 {
     if ( rNewLookAt != aLookAt )
@@ -140,12 +102,6 @@ void Camera3D::SetLookAt(const basegfx::B3DPoint& rNewLookAt)
     }
 }
 
-/*************************************************************************
-|*
-|* Position und Blickpunkt setzen
-|*
-\************************************************************************/
-
 void Camera3D::SetPosAndLookAt(const basegfx::B3DPoint& rNewPos,
                                const basegfx::B3DPoint& rNewLookAt)
 {
@@ -160,12 +116,6 @@ void Camera3D::SetPosAndLookAt(const basegfx::B3DPoint& rNewPos,
     }
 }
 
-/*************************************************************************
-|*
-|* seitlichen Neigungswinkel setzen
-|*
-\************************************************************************/
-
 void Camera3D::SetBankAngle(double fAngle)
 {
     basegfx::B3DVector aDiff(aPosition - aLookAt);
@@ -177,7 +127,7 @@ void Camera3D::SetBankAngle(double fAngle)
         aPrj.setY(-1.0);
     }
     else
-    {   // aPrj = Projektion von aDiff auf die XZ-Ebene
+    {   // aPrj = Projection from aDiff on the XZ-plane
         aPrj.setY(0.0);
 
         if ( aDiff.getY() < 0.0 )