Date: prev next · Thread: first prev next last
2011 Archives by date, by thread · List index


Hi,
Translated German comments in libs-core/svx/source/dialog.
Made a few other fixes (removed out commented code) along the way.

You can commit the patch under the terms of MPL 1.1 / GPLv3+ / LGPLv3+
triple license.

/Albert
diff --git a/svx/source/dialog/_bmpmask.cxx b/svx/source/dialog/_bmpmask.cxx
index f27de94..ad0b1b0 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 dbf9eeb..f14b741 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 6937000..df7d2af 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 986e73a..6f410b3 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 b4eae2d..1cbe9ba 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 314fef7..74b8183 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 ed05b16..b42dda0 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 51dbd51..fb6b963 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 d66c2c9..75c9502 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 af7f8d0..aa8fb0c 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 5c23584..39c6758 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 a23c311..67a2c1c 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 6efc91d..56322b6 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 02f1829..8079009 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 876b4d6..adbb64c 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 d2223ba..98c815a 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 b9a4060..4533b25 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 c970269..8f2a0cb 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 089bb4d..ee074a3 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 25d12c7..4cc2102 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 5e372fa..2628486 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 69d141a..580c431 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 f2b3ec7..534e504 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 8edde7b..b8c1ecb 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 2c6afa5..47c08a9 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 61824bb..4c61801 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, long
     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 19a91a1..7e27de2 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 9d24138..28d9aba 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 e3bf589..102aefa 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 c988f8c..1e3edb7 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 85101aa..a1628d9 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 101130b..3381bc1 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 b30ca44..524a7f9 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 e1dbcbb..940c047 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 4a5be0d..4ee4874 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 6e21578..a4cbc70 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 d3aaffb..356e87e 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 f6950d1..9f25bb5 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 bc3534b..759e8d1 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 a9aff08..fcb0e0f 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 5455e73..60e616c 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 2753de8..639a9c1 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 )
diff --git a/svx/source/inc/charmapacc.hxx b/svx/source/inc/charmapacc.hxx
index 2c3b3fd..89ae259 100644
--- a/svx/source/inc/charmapacc.hxx
+++ b/svx/source/inc/charmapacc.hxx
@@ -27,6 +27,7 @@
  ************************************************************************/
 
 #include <osl/mutex.hxx>
+#include <tools/list.hxx>
 #include <tools/color.hxx>
 #include <tools/string.hxx>
 #include <vcl/image.hxx>
diff --git a/svx/source/inc/fmpgeimp.hxx b/svx/source/inc/fmpgeimp.hxx
index 489aeff..640f967 100644
--- a/svx/source/inc/fmpgeimp.hxx
+++ b/svx/source/inc/fmpgeimp.hxx
@@ -37,6 +37,7 @@
 #include <com/sun/star/lang/XServiceInfo.hpp>
 #include <com/sun/star/container/XMap.hpp>
 
+#include <tools/list.hxx>
 #include <tools/link.hxx>
 #include <comphelper/uno3.hxx>
 #include <cppuhelper/weakref.hxx>
diff --git a/svx/source/tbxctrls/colrctrl.cxx b/svx/source/tbxctrls/colrctrl.cxx
index e02741d..f077845 100644
--- a/svx/source/tbxctrls/colrctrl.cxx
+++ b/svx/source/tbxctrls/colrctrl.cxx
@@ -31,6 +31,8 @@
 
 #include <svx/dialogs.hrc>
 
+
+#include <tools/list.hxx>
 #include <sfx2/viewsh.hxx>
 #include <sfx2/objsh.hxx>
 #include <sfx2/dispatch.hxx>
diff --git a/svx/source/unodraw/unomod.cxx b/svx/source/unodraw/unomod.cxx
index f4e8a52..be28dad 100644
--- a/svx/source/unodraw/unomod.cxx
+++ b/svx/source/unodraw/unomod.cxx
@@ -35,6 +35,7 @@
 #include <com/sun/star/drawing/XShape.hpp>
 #include <osl/mutex.hxx>
 #include <vcl/svapp.hxx>
+#include <tools/list.hxx>
 #include <svl/itemprop.hxx>
 #include <svtools/unoevent.hxx>
 #include <comphelper/sequence.hxx>
diff --git a/svx/source/unodraw/unoprov.cxx b/svx/source/unodraw/unoprov.cxx
index e049133..2c85070 100644
--- a/svx/source/unodraw/unoprov.cxx
+++ b/svx/source/unodraw/unoprov.cxx
@@ -934,7 +934,7 @@ UINT32 UHashMap::getId( const OUString& rCompareString )
 SvxUnoPropertyMapProvider aSvxMapProvider;
 
 EXTERN_C
-#if defined( PM2 )
+#if defined( PM2 ) && !defined( CSET )
 int _stdcall
 #else
 #ifdef WNT

Context


Privacy Policy | Impressum (Legal Info) | Copyright information: Unless otherwise specified, all text and images on this website are licensed under the Creative Commons Attribution-Share Alike 3.0 License. This does not include the source code of LibreOffice, which is licensed under the Mozilla Public License (MPLv2). "LibreOffice" and "The Document Foundation" are registered trademarks of their corresponding registered owners or are in actual use as trademarks in one or more countries. Their respective logos and icons are also subject to international copyright laws. Use thereof is explained in our trademark policy.