translation and cleanup of comments in sd/source/ui/view/

Change-Id: I988c0545600185c6b09131d27fb8480efddd947f

39 files changed, 756 insertions, 1756 deletions

diff --git a/sd/source/ui/view/DocumentRenderer.cxx b/sd/source/ui/view/DocumentRenderer.cxx
index 83fda372a0cc..b250e8a71eaf 100644
--- a/sd/source/ui/view/DocumentRenderer.cxx
+++ b/sd/source/ui/view/DocumentRenderer.cxx
@@ -1984,7 +1984,7 @@ private:
                 continue;
 
             MapMode aMap (rInfo.maMap);
-            // Kann sich die Seitengroesse geaendert haben?
+            // is it possible that the page size changed?
             const Size aPageSize = pPage->GetSize();
 
             if (mpOptions->IsPageSize())
@@ -2014,9 +2014,10 @@ private:
 
             long aPageWidth   = aPageSize.Width() - pPage->GetLftBorder() - pPage->GetRgtBorder();
             long aPageHeight  = aPageSize.Height() - pPage->GetUppBorder() - pPage->GetLwrBorder();
-            // Bugfix zu 44530:
-            // Falls implizit umgestellt wurde (Landscape/Portrait)
-            // wird dies beim Kacheln, bzw. aufteilen (Poster) beruecksichtigt
+            // Bugfix for 44530:
+            // if it was implicitly changed (Landscape/Portrait),
+            // this is considered for tiling, respectively for the splitting up
+            // (Poster)
             if( ( rInfo.maPrintSize.Width() > rInfo.maPrintSize.Height()
                     && aPageWidth < aPageHeight )
                 || ( rInfo.maPrintSize.Width() < rInfo.maPrintSize.Height()
diff --git a/sd/source/ui/view/Outliner.cxx b/sd/source/ui/view/Outliner.cxx
index b2ab27dd03af..508a1b63f3a8 100644
--- a/sd/source/ui/view/Outliner.cxx
+++ b/sd/source/ui/view/Outliner.cxx
@@ -126,12 +126,6 @@ private:
 
 
 
-/*************************************************************************
-|*
-|* Ctor
-|*
-\************************************************************************/
-
 Outliner::Outliner( SdDrawDocument* pDoc, sal_uInt16 nMode )
     : SdrOutliner( &pDoc->GetItemPool(), nMode ),
       mpImpl(new Implementation()),
@@ -410,12 +404,9 @@ sal_Bool Outliner::SpellNextDocument (void)
 }
 
 
-/*************************************************************************
-|*
-|* Spelling: naechstes TextObjekt pruefen
-|*
-\************************************************************************/
-
+/**
+ * check next text object
+ */
 ::svx::SpellPortions Outliner::GetNextSpellSentence (void)
 {
     ::svx::SpellPortions aResult;
@@ -1385,12 +1376,9 @@ void Outliner::EnterEditMode (sal_Bool bGrabFocus)
 
 
 
-/*************************************************************************
-|*
-|* SpellChecker: Error-LinkHdl
-|*
-\************************************************************************/
-
+/**
+ * SpellChecker: Error link handler
+ */
 IMPL_LINK_INLINE_START( Outliner, SpellError, void *, nLang )
 {
     mbError = true;
diff --git a/sd/source/ui/view/drbezob.cxx b/sd/source/ui/view/drbezob.cxx
index 6aa095b98cc7..4abd08f6631f 100644
--- a/sd/source/ui/view/drbezob.cxx
+++ b/sd/source/ui/view/drbezob.cxx
@@ -155,7 +155,7 @@ void BezierObjectBar::GetAttrState(SfxItemSet& rSet)
             switch (eSegm)
             {
                 case SDRPATHSEGMENT_DONTCARE: rSet.InvalidateItem(SID_BEZIER_CONVERT); break;
-                case SDRPATHSEGMENT_LINE    : rSet.Put(SfxBoolItem(SID_BEZIER_CONVERT,sal_False)); break; // Button reingedrueckt = Kurve
+                case SDRPATHSEGMENT_LINE    : rSet.Put(SfxBoolItem(SID_BEZIER_CONVERT,sal_False)); break; // Button down = curve
                 case SDRPATHSEGMENT_CURVE   : rSet.Put(SfxBoolItem(SID_BEZIER_CONVERT,sal_True));  break;
                 default: break;
             }
diff --git a/sd/source/ui/view/drtxtob1.cxx b/sd/source/ui/view/drtxtob1.cxx
index 4163ff1dcd02..2d6b18aba829 100644
--- a/sd/source/ui/view/drtxtob1.cxx
+++ b/sd/source/ui/view/drtxtob1.cxx
@@ -148,7 +148,7 @@ void TextObjectBar::Execute( SfxRequest &rReq )
                     {
                         SfxItemSet aAttr( pStyleSheet->GetItemSet() );
                         SfxItemSet aTmpSet( pOLV->GetOutliner()->GetParaAttribs( (sal_uInt16) nPara ) );
-                        aAttr.Put( aTmpSet, sal_False ); // sal_False= InvalidItems nicht als Default, sondern als "Loecher" betrachten
+                        aAttr.Put( aTmpSet, sal_False ); // sal_False= InvalidItems is not default, handle it as "holes"
                         const SvxULSpaceItem& rItem = (const SvxULSpaceItem&) aAttr.Get( EE_PARA_ULSPACE );
                         SvxULSpaceItem* pNewItem = (SvxULSpaceItem*) rItem.Clone();
 
diff --git a/sd/source/ui/view/drviews1.cxx b/sd/source/ui/view/drviews1.cxx
index 10c5c62bb383..e74f82c81413 100644
--- a/sd/source/ui/view/drviews1.cxx
+++ b/sd/source/ui/view/drviews1.cxx
@@ -1009,7 +1009,7 @@ sal_Bool DrawViewShell::SwitchPage(sal_uInt16 nSelectedPage)
 
             SdPage* pMaster = GetDoc()->GetMasterSdPage(nSelectedPage, mePageKind);
 
-            if( !pMaster )              // Falls es diese Page nicht geben sollte
+            if( !pMaster )              // if this page should not exist
                 pMaster = GetDoc()->GetMasterSdPage(0, mePageKind);
 
             sal_uInt16 nNum = pMaster->GetPageNum();
diff --git a/sd/source/ui/view/drviews3.cxx b/sd/source/ui/view/drviews3.cxx
index 2a736627a211..77a1c2acdcf2 100644
--- a/sd/source/ui/view/drviews3.cxx
+++ b/sd/source/ui/view/drviews3.cxx
@@ -90,16 +90,13 @@ using ::com::sun::star::frame::XController;
 
 namespace sd {
 
-/*************************************************************************
-|*
-|* SfxRequests fuer Controller bearbeiten
-|*
-\************************************************************************/
-
+/**
+ * handle SfxRequests for controller
+ */
 void  DrawViewShell::ExecCtrl(SfxRequest& rReq)
 {
-    // waehrend einer Diashow wird nichts ausser dem Seitenwechsel und dem
-    // Sprung zur Bookmark ausgefuehrt!
+    // except a page switch and jumps to bookmarks, nothing is executed during
+    // a slide show
     if( HasCurrentFunction(SID_PRESENTATION) &&
         rReq.GetSlot() != SID_SWITCHPAGE &&
         rReq.GetSlot() != SID_JUMPTOMARK)
@@ -236,7 +233,7 @@ void  DrawViewShell::ExecCtrl(SfxRequest& rReq)
                 }
             }
 
-            // Default-Layer der Page einschalten
+            // turn on default layer of page
             mpDrawView->SetActiveLayer( String( SdResId(STR_LAYER_LAYOUT) ) );
 
             ChangeEditMode(EM_PAGE, mbIsLayerModeActive);
@@ -313,9 +310,7 @@ void  DrawViewShell::ExecCtrl(SfxRequest& rReq)
         }
         case SID_OBJECTRESIZE:
         {
-            /******************************************************************
-            * Der Server moechte die Clientgrosse verandern
-            ******************************************************************/
+            // The server likes to change the client size
             OSL_ASSERT (GetViewShell()!=NULL);
             SfxInPlaceClient* pIPClient = GetViewShell()->GetIPClient();
 
@@ -374,7 +369,7 @@ void  DrawViewShell::ExecCtrl(SfxRequest& rReq)
                         p3DWin->DocumentReload();
                 }
 
-                // Normale Weiterleitung an ViewFrame zur Ausfuehrung
+                // normal forwarding to ViewFrame for execution
                 GetViewFrame()->ExecuteSlot(rReq);
 
                 // From here on we must cope with this object and the frame already being
@@ -466,15 +461,10 @@ void  DrawViewShell::ExecCtrl(SfxRequest& rReq)
     }
 }
 
-/*************************************************************************
-|*
-|* SfxRequests fuer Lineale bearbeiten
-|*
-\************************************************************************/
 
 void  DrawViewShell::ExecRuler(SfxRequest& rReq)
 {
-    // waehrend einer Diashow wird nichts ausgefuehrt!
+    // nothing is executed during a slide show!
     if(HasCurrentFunction(SID_PRESENTATION))
         return;
 
@@ -750,16 +740,12 @@ void  DrawViewShell::ExecRuler(SfxRequest& rReq)
         }
     }
     if ( pUndoGroup )
-        // Undo Gruppe dem Undo Manager uebergeben
+        // give the undo group to the undo manager
         GetViewFrame()->GetObjectShell()->GetUndoManager()->
                                             AddUndoAction(pUndoGroup);
 }
 
-/*************************************************************************
-|*
-|* Statuswerte der Lineale bestimmen
-|*
-\************************************************************************/
+
 void  DrawViewShell::GetRulerState(SfxItemSet& rSet)
 {
     Point aOrigin;
@@ -868,7 +854,7 @@ void  DrawViewShell::GetRulerState(SfxItemSet& rSet)
 
                     rSet.DisableItem( SID_RULER_OBJECT );
 
-                    // Seitenraender werden gelocked
+                    // lock page margins
                     aProtect.SetSizeProtect( sal_True );
                     aProtect.SetPosProtect( sal_True );
                 }
@@ -914,15 +900,10 @@ void  DrawViewShell::GetRulerState(SfxItemSet& rSet)
     rSet.Put( aProtect );
 }
 
-/*************************************************************************
-|*
-|* SfxRequests fuer StatusBar bearbeiten
-|*
-\************************************************************************/
 
 void  DrawViewShell::ExecStatusBar(SfxRequest& rReq)
 {
-    // waehrend einer Diashow wird nichts ausgefuehrt!
+    // nothing is executed during a slide show!
     if(HasCurrentFunction(SID_PRESENTATION))
         return;
 
@@ -944,12 +925,9 @@ void  DrawViewShell::ExecStatusBar(SfxRequest& rReq)
     }
 }
 
-/*************************************************************************
-|*
-|* Status der Snap-Objekt-Eintraege im Popup setzen
-|*
-\************************************************************************/
-
+/**
+ * set state of snap object entries in popup
+ */
 void  DrawViewShell::GetSnapItemState( SfxItemSet &rSet )
 {
     SdrPageView* pPV;
diff --git a/sd/source/ui/view/drviews4.cxx b/sd/source/ui/view/drviews4.cxx
index c3511c9e86cb..e360345f9016 100644
--- a/sd/source/ui/view/drviews4.cxx
+++ b/sd/source/ui/view/drviews4.cxx
@@ -71,11 +71,6 @@ namespace sd {
 using namespace ::com::sun::star::uno;
 using namespace ::com::sun::star::drawing;
 
-/*************************************************************************
-|*
-|* aktuelle Seite loeschen
-|*
-\************************************************************************/
 
 void DrawViewShell::DeleteActualPage()
 {
@@ -96,11 +91,6 @@ void DrawViewShell::DeleteActualPage()
     }
 }
 
-/*************************************************************************
-|*
-|* aktuelle Ebene loeschen
-|*
-\************************************************************************/
 
 void DrawViewShell::DeleteActualLayer()
 {
@@ -108,7 +98,7 @@ void DrawViewShell::DeleteActualLayer()
     const String&  rName  = GetLayerTabControl()->GetPageText(GetLayerTabControl()->GetCurPageId());
     String         aString(SdResId(STR_ASK_DELETE_LAYER));
 
-    // Platzhalter ersetzen
+    // replace placeholder
     sal_uInt16 nPos = aString.Search(sal_Unicode('$'));
     aString.Erase(nPos, 1);
     aString.Insert(rName, nPos);
@@ -118,22 +108,16 @@ void DrawViewShell::DeleteActualLayer()
         const SdrLayer* pLayer = rAdmin.GetLayer(rName, sal_False);
         mpDrawView->DeleteLayer( pLayer->GetName() );
 
-        // damit TabBar und Window neu gezeichnet werden;
-        // sollte spaeter wie beim Aendern der Layerfolge durch einen
-        // Hint von Joe angestossen werden
+        /* in order to redraw TabBar and Window; should be initiated later on by
+           a hint from Joe (as by a change if the layer order). */
         // ( View::Notify() --> ViewShell::ResetActualLayer() )
 
-        mbIsLayerModeActive = false;    // damit ChangeEditMode() ueberhaupt was tut
+        mbIsLayerModeActive = false;    // so that ChangeEditMode() does something
         ChangeEditMode(GetEditMode(), true);
     }
 }
 
 
-/*************************************************************************
-|*
-|* Keyboard event
-|*
-\************************************************************************/
 
 sal_Bool DrawViewShell::KeyInput (const KeyEvent& rKEvt, ::sd::Window* pWin)
 {
@@ -213,12 +197,9 @@ sal_Bool DrawViewShell::KeyInput (const KeyEvent& rKEvt, ::sd::Window* pWin)
     return bRet;
 }
 
-/*************************************************************************
-|*
-|* Vom Lineal ausgehenden Drag (Hilflinien, Ursprung) beginnen
-|*
-\************************************************************************/
-
+/**
+ * Start with Drag from ruler (helper lines, origin)
+ */
 void DrawViewShell::StartRulerDrag (
     const Ruler& rRuler,
     const MouseEvent& rMEvt)
@@ -252,11 +233,6 @@ void DrawViewShell::StartRulerDrag (
     }
 }
 
-/*************************************************************************
-|*
-|* MouseButtonDown event
-|*
-\************************************************************************/
 
 void DrawViewShell::MouseButtonDown(const MouseEvent& rMEvt,
     ::sd::Window* pWin)
@@ -282,11 +258,6 @@ void DrawViewShell::MouseButtonDown(const MouseEvent& rMEvt,
     }
 }
 
-/*************************************************************************
-|*
-|* MouseMove event
-|*
-\************************************************************************/
 
 
 void DrawViewShell::MouseMove(const MouseEvent& rMEvt, ::sd::Window* pWin)
@@ -397,11 +368,6 @@ void DrawViewShell::MouseMove(const MouseEvent& rMEvt, ::sd::Window* pWin)
 }
 
 
-/*************************************************************************
-|*
-|* MouseButtonUp event
-|*
-\************************************************************************/
 
 void DrawViewShell::MouseButtonUp(const MouseEvent& rMEvt, ::sd::Window* pWin)
 {
@@ -441,11 +407,6 @@ void DrawViewShell::MouseButtonUp(const MouseEvent& rMEvt, ::sd::Window* pWin)
     }
 }
 
-/*************************************************************************
-|*
-|* Command event
-|*
-\************************************************************************/
 
 void DrawViewShell::Command(const CommandEvent& rCEvt, ::sd::Window* pWin)
 {
@@ -501,38 +462,38 @@ void DrawViewShell::Command(const CommandEvent& rCEvt, ::sd::Window* pWin)
         else if( rCEvt.GetCommand() == COMMAND_CONTEXTMENU && !bNativeShow &&
                  pWin != NULL && !mpDrawView->IsAction() && !SD_MOD()->GetWaterCan() )
         {
-            sal_uInt16 nSdResId = 0;          // ResourceID fuer Popup-Menue
+            sal_uInt16 nSdResId = 0;          // ResourceID for popup menu
             sal_Bool bGraphicShell = this->ISA(GraphicViewShell);
 
-            // Ist ein Fangobjekt unter dem Mauszeiger?
+            // is there a snap object under the cursor?
             SdrPageView* pPV;
             Point   aMPos = pWin->PixelToLogic( maMousePos );
             sal_uInt16  nHitLog = (sal_uInt16) GetActiveWindow()->PixelToLogic(
                 Size(FuPoor::HITPIX, 0 ) ).Width();
             sal_uInt16  nHelpLine;
-            // fuer Klebepunkt
+            // for glue points
             SdrObject*  pObj = NULL;
             sal_uInt16      nPickId = 0;
-            // fuer Feldbefehl
+            // for field command
             OutlinerView* pOLV = mpDrawView->GetTextEditOutlinerView();
             const SvxFieldItem* pFldItem = NULL;
             if( pOLV )
                 pFldItem = pOLV->GetFieldAtSelection();
 
-            // Hilfslinie
+            // helper line
             if ( mpDrawView->PickHelpLine( aMPos, nHitLog, *GetActiveWindow(), nHelpLine, pPV) )
             {
                 nSdResId = RID_DRAW_SNAPOBJECT_POPUP;
                 ShowSnapLineContextMenu(*pPV, nHelpLine, rCEvt.GetMousePosPixel());
                 return;
             }
-            // Klebepunkt unter dem Mauszeiger markiert?
+            // is glue point under cursor marked?
             else if( mpDrawView->PickGluePoint( aMPos, pObj, nPickId, pPV ) &&
                      mpDrawView->IsGluePointMarked( pObj, nPickId ) )
             {
                 nSdResId = RID_DRAW_GLUEPOINT_POPUP;
             }
-            // Feldbefehl ?
+            // field command?
             else if( pFldItem && (pFldItem->GetField()->ISA( SvxDateField ) ||
                                  pFldItem->GetField()->ISA( SvxExtTimeField ) ||
                                  pFldItem->GetField()->ISA( SvxExtFileField ) ||
@@ -559,7 +520,7 @@ void DrawViewShell::Command(const CommandEvent& rCEvt, ::sd::Window* pWin)
                 if( pField )
                 {
                     SvxFieldItem aFieldItem( *pField, EE_FEATURE_FIELD );
-                    // Feld selektieren, so dass es beim Insert geloescht wird
+                    // select field, so that it will be deleted on insert
                     ESelection aSel = pOLV->GetSelection();
                     sal_Bool bSel = sal_True;
                     if( aSel.nStartPos == aSel.nEndPos )
@@ -571,7 +532,7 @@ void DrawViewShell::Command(const CommandEvent& rCEvt, ::sd::Window* pWin)
 
                     pOLV->InsertField( aFieldItem );
 
-                    // Selektion wird wieder in den Ursprungszustand gebracht
+                    // reset selection back to original state
                     if( !bSel )
                         aSel.nEndPos--;
                     pOLV->SetSelection( aSel );
@@ -581,7 +542,7 @@ void DrawViewShell::Command(const CommandEvent& rCEvt, ::sd::Window* pWin)
             }
             else
             {
-                // ist etwas selektiert?
+                // is something selected?
                 if (mpDrawView->AreObjectsMarked() &&
                     mpDrawView->GetMarkedObjectList().GetMarkCount() == 1 )
                 {
@@ -740,7 +701,7 @@ void DrawViewShell::Command(const CommandEvent& rCEvt, ::sd::Window* pWin)
                     }
                 }
 
-                // Mehrfachselektion
+                // multiple selection
                 else if (mpDrawView->AreObjectsMarked() &&
                     mpDrawView->GetMarkedObjectList().GetMarkCount() > 1 )
                 {
@@ -748,7 +709,7 @@ void DrawViewShell::Command(const CommandEvent& rCEvt, ::sd::Window* pWin)
                                                 RID_DRAW_MULTISELECTION_POPUP;
                 }
 
-                // nichts selektiert
+                // nothing selected
                 else
                 {
                     nSdResId = bGraphicShell ? RID_GRAPHIC_NOSEL_POPUP :
@@ -801,11 +762,6 @@ void DrawViewShell::Command(const CommandEvent& rCEvt, ::sd::Window* pWin)
     }
 }
 
-/*************************************************************************
-|*
-|* Linealmarkierungen anzeigen
-|*
-\************************************************************************/
 
 void DrawViewShell::ShowMousePosInfo(const Rectangle& rRect,
     ::sd::Window* pWin)
@@ -857,7 +813,7 @@ void DrawViewShell::ShowMousePosInfo(const Rectangle& rRect,
             mpVerticalRuler->SetLines(nCnt, pVLines);
     }
 
-    // StatusBar Koordinatenanzeige
+    // display with coordinates in StatusBar
     OSL_ASSERT (GetViewShell()!=NULL);
     if ( !GetViewShell()->GetUIActiveClient() )
     {
@@ -866,7 +822,7 @@ void DrawViewShell::ShowMousePosInfo(const Rectangle& rRect,
                                    SID_ATTR_SIZE, SID_ATTR_SIZE,
                                    0L);
 
-//        GetStatusBarState(aSet);  nicht performant bei gedrueckter Modifiertaste!!
+//        GetStatusBarState(aSet); not fast by pressed modify key!!
 
         aSet.Put( SfxStringItem( SID_CONTEXT, mpDrawView->GetStatusText() ) );
 
diff --git a/sd/source/ui/view/drviews5.cxx b/sd/source/ui/view/drviews5.cxx
index c87d25b38b18..36485615dc37 100644
--- a/sd/source/ui/view/drviews5.cxx
+++ b/sd/source/ui/view/drviews5.cxx
@@ -69,24 +69,18 @@ static const int TABCONTROL_INITIAL_SIZE = 350;
 static const int PAPER_SHADOW_EXT_PIXEL = 2;
 
 
-/*************************************************************************
-|*
-|* Wird gerufen, wenn sich das Model aendert
-|*
-\************************************************************************/
 
 void DrawViewShell::ModelHasChanged()
 {
     Invalidate();
-    // Damit der Navigator auch einen aktuellen Status bekommt
+    // that the navigator also gets an up to date state
     GetViewFrame()->GetBindings().Invalidate( SID_NAVIGATOR_STATE, sal_True, sal_False );
 
     SfxBoolItem aItem( SID_3D_STATE, sal_True );
     GetViewFrame()->GetDispatcher()->Execute(
         SID_3D_STATE, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD, &aItem, 0L );
 
-    // jetzt den von der Drawing Engine neu erzeugten TextEditOutliner
-    // initialisieren
+    // now initialize the TextEditOutliner which was newly created by the draw engine
     ::Outliner* pOutliner     = mpDrawView->GetTextEditOutliner();
     if (pOutliner)
     {
@@ -144,28 +138,25 @@ void DrawViewShell::ArrangeGUIElements (void)
 
     if ( mbZoomOnPage && !bInPlaceActive && !bClientActive )
     {
-        // bei Split immer erstes Fenster resizen
+        // with split, always resize first window
         //af pWindow = mpContentWindow.get();
         SfxRequest aReq(SID_SIZE_PAGE, 0, GetDoc()->GetItemPool());
         ExecuteSlot( aReq );
     }
 }
 
-/*************************************************************************
-|*
-|* Daten der FrameView auf die aktuelle View uebertragen
-|*
-\************************************************************************/
-
+/**
+ * Apply data of the FrameView on the current view
+ */
 void DrawViewShell::ReadFrameViewData(FrameView* pView)
 {
     ModifyGuard aGuard( GetDoc() );
 
-    // Diese Option wird am Model eingestellt
+    // this option has to be adjust at the model
     GetDoc()->SetPickThroughTransparentTextFrames(
              SD_MOD()->GetSdOptions(GetDoc()->GetDocumentType())->IsPickThrough());
 
-    // Initialisierungen der Zeichen-(Bildschirm-)Attribute
+    // initialization of the Character-(Screen-) attribute
     if (HasRuler() != pView->HasRuler())
         SetRuler( pView->HasRuler() );
 
@@ -304,7 +295,7 @@ void DrawViewShell::ReadFrameViewData(FrameView* pView)
     ChangeEditMode(eNewEditMode, bNewLayerMode);
     SwitchPage(nSelectedPage);
 
-    // DrawMode fuer 'Normales' Fenster wiederherstellen
+    // restore DrawMode for 'normal' window
     if(GetActiveWindow()->GetDrawMode() != pView->GetDrawMode())
       GetActiveWindow()->SetDrawMode(pView->GetDrawMode());
 
@@ -314,20 +305,18 @@ void DrawViewShell::ReadFrameViewData(FrameView* pView)
         GetViewFrame()->GetDispatcher()->Execute( SID_FM_DESIGN_MODE, SFX_CALLMODE_SYNCHRON | SFX_CALLMODE_RECORD, &aDesignModeItem, 0L );
     }
 
-    // Muss am Ende gerufen werden, da ein WriteFrameViewData() ausgeloest wird
+    // has to be called in the end, because it executes a WriteFrameViewData()
     if (mpDrawView->IsFrameDragSingles() != pView->IsFrameDragSingles() )
         mpDrawView->SetFrameDragSingles( pView->IsFrameDragSingles() );
 }
 
-/*************************************************************************
-|*
-|* Daten der aktuellen View auf die FrameView uebertragen
-|*
-\************************************************************************/
 
+/**
+ * Apply data of the current view on the FrameView
+ */
 void DrawViewShell::WriteFrameViewData()
 {
-    // Zeichen-(Bildschirm-)Attribute an FrameView merken
+    // store character-(screen-) attribute of FrameView
     mpFrameView->SetRuler( HasRuler() );
     mpFrameView->SetGridCoarse( mpDrawView->GetGridCoarse() );
     mpFrameView->SetGridFine( mpDrawView->GetGridFine() );
@@ -402,33 +391,24 @@ void DrawViewShell::WriteFrameViewData()
     if ( mpFrameView->GetActiveLayer() != mpDrawView->GetActiveLayer() )
         mpFrameView->SetActiveLayer( mpDrawView->GetActiveLayer() );
 
-    // DrawMode fuer 'Normales' Fenster merken
+    // store DrawMode for 'normal' window
     if(mpFrameView->GetDrawMode() != GetActiveWindow()->GetDrawMode())
       mpFrameView->SetDrawMode(GetActiveWindow()->GetDrawMode());
 }
 
 
 
-/*************************************************************************
-|*
-|* PrePaint-Method
-|*
-\************************************************************************/
-
 void DrawViewShell::PrePaint()
 {
     mpDrawView->PrePaint();
 }
 
-/*************************************************************************
-|*
-|* Paint-Methode: das Ereignis wird vom Fenster pWin an
-|* die Viewshell und die aktuelle Funktion weitergeleitet
-|*
-|* Anmerkung: pWin==NULL, wenn Paint() vom ShowWindow gerufen wird!
-|*
-\************************************************************************/
-
+/**
+ * The event is forwarded to the Viewshell and the current function by the
+ * window pWin.
+ *
+ * Remark: pWin==NULL, if Paint() is called from ShowWindow!
+ */
 void DrawViewShell::Paint(const Rectangle& rRect, ::sd::Window* pWin)
 {
     // Fill var FillColor here to have it available on later call
@@ -462,12 +442,9 @@ void DrawViewShell::Paint(const Rectangle& rRect, ::sd::Window* pWin)
     }
 }
 
-/*************************************************************************
-|*
-|* Zoom-Faktor fuer InPlace einstellen
-|*
-\************************************************************************/
-
+/**
+ * adjust zoom factor for InPlace
+ */
 void DrawViewShell::SetZoomFactor(const Fraction& rZoomX, const Fraction& rZoomY)
 {
     ViewShell::SetZoomFactor(rZoomX, rZoomY);
@@ -476,11 +453,6 @@ void DrawViewShell::SetZoomFactor(const Fraction& rZoomX, const Fraction& rZoomY
     GetActiveWindow()->SetWinViewPos(aOrigin);
 }
 
-/*************************************************************************
-|*
-|* Seite wird gehided
-|*
-\************************************************************************/
 
 void DrawViewShell::HidePage()
 {
diff --git a/sd/source/ui/view/drviews6.cxx b/sd/source/ui/view/drviews6.cxx
index 0ab058b20448..5116d1b53c05 100644
--- a/sd/source/ui/view/drviews6.cxx
+++ b/sd/source/ui/view/drviews6.cxx
@@ -63,15 +63,12 @@
 
 namespace sd {
 
-/*************************************************************************
-|*
-|* SfxRequests fuer FontWork bearbeiten
-|*
-\************************************************************************/
-
+/**
+ * handle SfxRequests for FontWork
+ */
 void DrawViewShell::ExecFormText(SfxRequest& rReq)
 {
-    // waehrend einer Diashow wird nichts ausgefuehrt!
+    // nothing is executed during a slide show!
     if(HasCurrentFunction(SID_PRESENTATION))
         return;
 
@@ -104,7 +101,7 @@ void DrawViewShell::ExecFormText(SfxRequest& rReq)
                                    GetValue());
 
             if(HasCurrentFunction(SID_BEZIER_EDIT))
-            {   // ggf. die richtige Editfunktion aktivieren
+            {   // activate the right edit function if necessary
                 GetViewFrame()->GetDispatcher()->Execute(SID_SWITCH_POINTEDIT,
                                     SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD);
             }
@@ -114,12 +111,9 @@ void DrawViewShell::ExecFormText(SfxRequest& rReq)
     }
 }
 
-/*************************************************************************
-|*
-|* Statuswerte fuer FontWork zurueckgeben
-|*
-\************************************************************************/
-
+/**
+ * Return state values for FontWork
+ */
 void DrawViewShell::GetFormTextState(SfxItemSet& rSet)
 {
     const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList();
@@ -137,7 +131,7 @@ void DrawViewShell::GetFormTextState(SfxItemSet& rSet)
     if ( pObj == NULL || !pObj->ISA(SdrTextObj) ||
         !((SdrTextObj*) pObj)->HasText() )
     {
-// automatisches Auf/Zuklappen des FontWork-Dialog; erstmal deaktiviert
+// automatic open/close the FontWork-Dialog; first deactivate it
 
         rSet.DisableItem(XATTR_FORMTXTSTYLE);
         rSet.DisableItem(XATTR_FORMTXTADJUST);
@@ -163,15 +157,10 @@ void DrawViewShell::GetFormTextState(SfxItemSet& rSet)
     }
 }
 
-/*************************************************************************
-|*
-|* SfxRequests fuer Animator bearbeiten
-|*
-\************************************************************************/
 
 void DrawViewShell::ExecAnimationWin( SfxRequest& rReq )
 {
-    // waehrend einer Diashow wird nichts ausgefuehrt!
+    // nothing is executed during a slide show!
     if (HasCurrentFunction(SID_PRESENTATION))
         return;
 
@@ -206,20 +195,17 @@ void DrawViewShell::ExecAnimationWin( SfxRequest& rReq )
     }
 }
 
-/*************************************************************************
-|*
-|* Statuswerte fuer Animator zurueckgeben
-|*
-|* nValue == 0 -> Kein Button
-|* nValue == 1 -> Button 'uebernehmen'
-|* nValue == 2 -> Button 'einzeln uebernehmen'
-|* nValue == 3 -> Buttons 'uebernehmen' und 'einzeln uebernehmen'
-|*
-\************************************************************************/
-
+/**
+ * Return status values for animator
+ *
+ * nValue == 0 -> No button
+ * nValue == 1 -> Button 'accept'
+ * nValue == 2 -> Button 'accept individually'
+ * nValue == 3 -> Buttons 'accept' and 'accept individually'
+ */
 void DrawViewShell::GetAnimationWinState( SfxItemSet& rSet )
 {
-    // Hier koennten Buttons etc. disabled werden
+    // here we could disable buttons etc.
     sal_uInt16 nValue;
 
     const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList();
@@ -229,15 +215,15 @@ void DrawViewShell::GetAnimationWinState( SfxItemSet& rSet )
         nValue = 0;
     else if( nMarkCount > 1 )
         nValue = 3;
-    else // 1 Objekt
+    else // 1 Object
     {
         const SdrObject* pObj = rMarkList.GetMark( 0 )->GetMarkedSdrObj();
         sal_uInt32 nInv = pObj->GetObjInventor();
         sal_uInt16 nId  = pObj->GetObjIdentifier();
-        // 1 selektiertes Gruppenobjekt
+        // 1 selected group object
         if( nInv == SdrInventor && nId == OBJ_GRUP )
             nValue = 3;
-        else if( nInv == SdrInventor && nId == OBJ_GRAF ) // Anim. GIF ?
+        else if( nInv == SdrInventor && nId == OBJ_GRAF ) // Animated GIF ?
         {
             sal_uInt16 nCount = 0;
 
@@ -254,15 +240,10 @@ void DrawViewShell::GetAnimationWinState( SfxItemSet& rSet )
     rSet.Put( SfxUInt16Item( SID_ANIMATOR_STATE, nValue ) );
 }
 
-/*************************************************************************
-|*
-|* Statuswerte fuer SfxChildWindows setzen
-|*
-\************************************************************************/
 
 void DrawViewShell::SetChildWindowState( SfxItemSet& rSet )
 {
-    // Stati der SfxChild-Windows (Animator, Fontwork etc.)
+    // State of SfxChild-Windows (Animator, Fontwork etc.)
     if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_FONTWORK ) )
     {
         sal_uInt16 nId = SvxFontWorkChildWindow::GetChildWindowId();
@@ -316,15 +297,12 @@ void DrawViewShell::SetChildWindowState( SfxItemSet& rSet )
 }
 
 
-/*************************************************************************
-|*
-|* SfxRequests fuer Pipette bearbeiten
-|*
-\************************************************************************/
-
+/**
+ * Handle SfxRequests for pipette
+ */
 void DrawViewShell::ExecBmpMask( SfxRequest& rReq )
 {
-    // waehrend einer Diashow wird nichts ausgefuehrt!
+    // nothing is executed during a slide show!
     if (HasCurrentFunction(SID_PRESENTATION))
         return;
 
@@ -425,12 +403,9 @@ void DrawViewShell::GetBmpMaskState( SfxItemSet& rSet )
     rSet.Put( SfxBoolItem( SID_BMPMASK_EXEC, bEnable ) );
 }
 
-/*************************************************************************
-|*
-|* SfxRequests fuer temporaere Funktionen
-|*
-\************************************************************************/
-
+/**
+ * SfxRequests for temporary functions
+ */
 void DrawViewShell::FuTemp04(SfxRequest& rReq)
 {
     sal_uInt16 nSId = rReq.GetSlot();
@@ -600,10 +575,11 @@ void DrawViewShell::FuTemp04(SfxRequest& rReq)
 
         case SID_CONVERT_TO_3D_LATHE_FAST:
         {
-            // Der Aufruf ist ausreichend. Die Initialisierung per Start3DCreation und CreateMirrorPolygons
-            // ist nicht mehr noetig, falls der Parameter sal_True uebergeben wird. Dann wird sofort und
-            // ohne Benutzereingriff ein gekippter Rotationskoerper mit einer Achse links neben dem
-            // Umschliessenden Rechteck der slektierten Objekte gezeichnet.
+            /* The call is enough. The initialization via Start3DCreation and
+               CreateMirrorPolygons is no longer needed if the parameter
+               sal_True is provided. Then a tilted rotary body with an axis left
+               besides the bounding rectangle of the selected objects is drawn
+               immediately and without user interaction.  */
             mpDrawView->SdrEndTextEdit();
             if(GetActiveWindow())
                 GetActiveWindow()->EnterWait();
diff --git a/sd/source/ui/view/drviews7.cxx b/sd/source/ui/view/drviews7.cxx
index b7ef1009238b..64100504a41f 100644
--- a/sd/source/ui/view/drviews7.cxx
+++ b/sd/source/ui/view/drviews7.cxx
@@ -204,11 +204,6 @@ IMPL_LINK( DrawViewShell, ClipboardChanged, TransferableDataHelper*, pDataHelper
     return 0;
 }
 
-/*************************************************************************
-|*
-|* Status (Enabled/Disabled) von Menue-SfxSlots setzen
-|*
-\************************************************************************/
 
 void DrawViewShell::GetMenuState( SfxItemSet &rSet )
 {
@@ -238,10 +233,10 @@ void DrawViewShell::GetMenuState( SfxItemSet &rSet )
     //format paintbrush
     FuFormatPaintBrush::GetMenuState( *this, rSet );
 
-    // Stati der SfxChild-Windows (Animator, Fontwork etc.)
+    // State of SfxChild-Windows (Animator, Fontwork etc.)
     SetChildWindowState( rSet );
 
-    // Images der Toolboxen mappen (nur Zoom)
+    // map images of toolboxes (only zoom)
     UpdateToolboxImages( rSet, sal_False );
 
     if(HasCurrentFunction())
@@ -250,10 +245,10 @@ void DrawViewShell::GetMenuState( SfxItemSet &rSet )
 
         rSet.Put( SfxBoolItem( nSId, sal_True ) );
 
-        // Bewirkt ein uncheck eines simulierten Slots
+        // will cause a uncheck of a simulated slot
         sal_uInt16 nId = GetIdBySubId( nSId );
 
-        // Images der Toolboxen mappen
+        // map images of the toolboxes
         UpdateToolboxImages( rSet );
 
         if( nId != SID_ZOOM_TOOLBOX &&
@@ -389,7 +384,7 @@ void DrawViewShell::GetMenuState( SfxItemSet &rSet )
         }
     }
 
-    // Starten der Praesentation moeglich?
+    // is it possible to start the presentation?
     if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_PRESENTATION ) ||
         SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_REHEARSE_TIMINGS ) )
     {
@@ -411,7 +406,7 @@ void DrawViewShell::GetMenuState( SfxItemSet &rSet )
         }
     }
 
-    // Klebepunkte
+    // glue points
     if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_GLUE_EDITMODE ) ||
         SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_GLUE_INSERT_POINT ) ||
         SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_GLUE_PERCENT ) ||
@@ -427,14 +422,14 @@ void DrawViewShell::GetMenuState( SfxItemSet &rSet )
         SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_GLUE_VERTALIGN_TOP ) ||
         SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_GLUE_VERTALIGN_BOTTOM ) )
     {
-        // Prozent
+        // percent
         TRISTATE eState = mpDrawView->IsMarkedGluePointsPercent();
         if( eState == STATE_DONTKNOW )
             rSet.InvalidateItem( SID_GLUE_PERCENT );
         else
             rSet.Put( SfxBoolItem( SID_GLUE_PERCENT, eState == STATE_CHECK ) );
 
-        // Bei Prozent hat Alignment keinen Effekt
+        // alignment has no effect by percent
         if( eState == STATE_CHECK )
         {
             rSet.DisableItem( SID_GLUE_HORZALIGN_CENTER );
@@ -446,41 +441,41 @@ void DrawViewShell::GetMenuState( SfxItemSet &rSet )
         }
         else
         {
-            // Horizontale Ausrichtung
+            // horizontal alignment
             sal_uInt16 nHorz = mpDrawView->GetMarkedGluePointsAlign( sal_False );
             rSet.Put( SfxBoolItem( SID_GLUE_HORZALIGN_CENTER, nHorz == SDRHORZALIGN_CENTER ) );
             rSet.Put( SfxBoolItem( SID_GLUE_HORZALIGN_LEFT,   nHorz == SDRHORZALIGN_LEFT ) );
             rSet.Put( SfxBoolItem( SID_GLUE_HORZALIGN_RIGHT,  nHorz == SDRHORZALIGN_RIGHT ) );
-            // Vertikale Ausrichtung
+            // vertical alignment
             sal_uInt16 nVert = mpDrawView->GetMarkedGluePointsAlign( sal_True );
             rSet.Put( SfxBoolItem( SID_GLUE_VERTALIGN_CENTER, nVert == SDRVERTALIGN_CENTER ) );
             rSet.Put( SfxBoolItem( SID_GLUE_VERTALIGN_TOP,    nVert == SDRVERTALIGN_TOP ) );
             rSet.Put( SfxBoolItem( SID_GLUE_VERTALIGN_BOTTOM, nVert == SDRVERTALIGN_BOTTOM ) );
         }
 
-        // Punkt einfuegen
+        // insert point
         rSet.Put( SfxBoolItem( SID_GLUE_INSERT_POINT, mpDrawView->IsInsGluePointMode() ) );
 
-        // Autrittsrichtung
-        // Links
+        // Escape direction
+        // left
         eState = mpDrawView->IsMarkedGluePointsEscDir( SDRESC_LEFT );
         if( eState == STATE_DONTKNOW )
             rSet.InvalidateItem( SID_GLUE_ESCDIR_LEFT );
         else
             rSet.Put( SfxBoolItem( SID_GLUE_ESCDIR_LEFT, eState == STATE_CHECK ) );
-        // Rechts
+        // right
         eState = mpDrawView->IsMarkedGluePointsEscDir( SDRESC_RIGHT );
         if( eState == STATE_DONTKNOW )
             rSet.InvalidateItem( SID_GLUE_ESCDIR_RIGHT );
         else
             rSet.Put( SfxBoolItem( SID_GLUE_ESCDIR_RIGHT, eState == STATE_CHECK ) );
-        // Oben
+        // top
         eState = mpDrawView->IsMarkedGluePointsEscDir( SDRESC_TOP );
         if( eState == STATE_DONTKNOW )
             rSet.InvalidateItem( SID_GLUE_ESCDIR_TOP );
         else
             rSet.Put( SfxBoolItem( SID_GLUE_ESCDIR_TOP, eState == STATE_CHECK ) );
-        // Unten
+        // bottom
         eState = mpDrawView->IsMarkedGluePointsEscDir( SDRESC_BOTTOM );
         if( eState == STATE_DONTKNOW )
             rSet.InvalidateItem( SID_GLUE_ESCDIR_BOTTOM );
@@ -530,11 +525,11 @@ void DrawViewShell::GetMenuState( SfxItemSet &rSet )
         rSet.DisableItem( SID_OBJECT_GRADIENT );
     }
 
-    // Morphen ggf. disablen
+    // disable morphing if necessary
     if ( !mpDrawView->IsMorphingAllowed() )
         rSet.DisableItem( SID_POLYGON_MORPHING );
 
-    // Vectorize ggf. disablen
+    // disable vectorizing if necessary
     if ( !mpDrawView->IsVectorizeAllowed() )
         rSet.DisableItem( SID_VECTORIZE );
 
@@ -546,7 +541,7 @@ void DrawViewShell::GetMenuState( SfxItemSet &rSet )
     if ( !bConvertToPathPossible &&
          !mpDrawView->IsCrookAllowed( mpDrawView->IsCrookNoContortion() ) )
     {
-        // Implizite Wandlung in Kurve nicht moeglich
+        // implicit transformation into curve not possible
         rSet.DisableItem(SID_OBJECT_CROOK_ROTATE);
         rSet.DisableItem(SID_OBJECT_CROOK_SLANT);
         rSet.DisableItem(SID_OBJECT_CROOK_STRETCH);
@@ -588,7 +583,7 @@ void DrawViewShell::GetMenuState( SfxItemSet &rSet )
     {
         if( pPageView && pPageView->GetObjList()->GetObjCount() == 0 )
         {
-            // Sollte disabled sein, wenn kein Objekt auf der Zeichenflaeche ist:
+            // should be disabled if there is no object on the draw area:
             rSet.DisableItem( SID_SELECTALL );
             rSet.DisableItem( SID_SIZE_ALL );
         }
@@ -738,7 +733,7 @@ void DrawViewShell::GetMenuState( SfxItemSet &rSet )
     if (meEditMode == EM_PAGE)
     {
         /**********************************************************************
-        * Seiten-Modus
+        * page mode
         **********************************************************************/
         rSet.Put(SfxBoolItem(SID_PAGEMODE, sal_True));
         rSet.Put(SfxBoolItem(SID_MASTERPAGE, sal_False));
@@ -749,7 +744,7 @@ void DrawViewShell::GetMenuState( SfxItemSet &rSet )
         if (mePageKind == PK_STANDARD &&
             rSet.GetItemState(SID_TITLE_MASTERPAGE) == SFX_ITEM_AVAILABLE)
         {
-            // Gibt es eine Seite mit dem AutoLayout "Titel"?
+            // Is there a page with the AutoLayout "Title"?
             sal_Bool bDisable = sal_True;
             sal_uInt16 i = 0;
             sal_uInt16 nCount = GetDoc()->GetSdPageCount(PK_STANDARD);
@@ -791,7 +786,7 @@ void DrawViewShell::GetMenuState( SfxItemSet &rSet )
         rSet.Put(SfxBoolItem(SID_MASTERPAGE, sal_True));
 
         /**********************************************************************
-        * Hintergrundseiten-Modus
+        * Background page mode
         **********************************************************************/
         if (mePageKind == PK_STANDARD)
         {
@@ -810,24 +805,24 @@ void DrawViewShell::GetMenuState( SfxItemSet &rSet )
                     sal_uInt16 i = 0;
                     sal_uInt16 nCount = GetDoc()->GetSdPageCount(PK_STANDARD);
 
-                    // Referenziert eine Seite mit dem AutoLayout "Titel" die
-                    // aktuelle MasterPage?
+                    // Is there a reference to the current master page from a page
+                    // with the AutoLayout "Title"?
                     while (i < nCount && !bCheck && bDisable)
                     {
                         SdPage* pPage = GetDoc()->GetSdPage(i, PK_STANDARD);
 
-                        // Seite referenziert aktuelle MasterPage
+                        // page does reference the current master page
                         if (pPage->GetAutoLayout() == AUTOLAYOUT_TITLE)
                         {
-                            // Eine Seite hat das AutoLayout "Titel"
+                            // a page does have a AutoLayout "Title"
                             bDisable = sal_False;
 
                             SdPage& rRefMPage = (SdPage&)(pPage->TRG_GetMasterPage());
 
                             if(&rRefMPage == pMPage)
                             {
-                                // Eine Seite mit dem AutoLayout "Titel"
-                                // referenziert die aktuelle MasterPage
+                                // a page with the AutoLayout "Title" does reference
+                                // the current master page
                                 bCheck = sal_True;
                             }
                         }
@@ -866,11 +861,11 @@ void DrawViewShell::GetMenuState( SfxItemSet &rSet )
         }
     }
 
-    // Status der Lineale setzen
+    // set state of the ruler
     if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_RULER ) )
         rSet.Put( SfxBoolItem( SID_RULER, HasRuler() ) );
 
-    // nicht die letzte Seite oder eine Masterpage loeschen
+    // do not delete the last page or a master page
     if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_DELETE_PAGE )
         || SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_DELETE_MASTER_PAGE ) )
     {
@@ -887,7 +882,7 @@ void DrawViewShell::GetMenuState( SfxItemSet &rSet )
         }
     }
 
-    // darf der aktuelle Layer geloescht werden?
+    // is it allowed to delete the current layer?
     if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_DELETE_LAYER ) )
     {
         sal_uInt16        nCurrentLayer = GetLayerTabControl()->GetCurPageId();
@@ -913,9 +908,8 @@ void DrawViewShell::GetMenuState( SfxItemSet &rSet )
     {
         OutlinerView* pOlView = mpDrawView->GetTextEditOutlinerView();
 
-        // Sonderbehandlung f�r SID_OUTLINE_BULLET wenn Objekte
-        // mit unterschiedlichen arten von NumBullet Items markiert
-        // sind
+        // special treatment of for SID_OUTLINE_BULLET if objects with different
+        // kinds of NumBullets are marked
         sal_Bool bHasOutliner = sal_False;
         sal_Bool bHasOther    = sal_False;
         for(sal_uLong nNum = 0; nNum < nMarkCount; nNum++)
@@ -973,7 +967,7 @@ void DrawViewShell::GetMenuState( SfxItemSet &rSet )
         rSet.DisableItem( SID_ZOOM_TOOLBOX );
     }
 
-    // Zoom-Stati
+    // Zoom-State
     if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_ZOOM_IN ) ||
         SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_ZOOM_OUT )||
         SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_ZOOM_PANNING ) )
@@ -1017,7 +1011,7 @@ void DrawViewShell::GetMenuState( SfxItemSet &rSet )
         }
     }
 
-    // EditText aktiv
+    // EditText active
     if (GetViewShellBase().GetViewShellManager()->GetShell(RID_DRAW_TEXT_TOOLBOX) != NULL)
     {
         sal_uInt16 nCurrentSId = SID_ATTR_CHAR;
@@ -1033,7 +1027,7 @@ void DrawViewShell::GetMenuState( SfxItemSet &rSet )
 
         rSet.Put( SfxBoolItem( nCurrentSId, sal_True ) );
 
-        // Kurzform von UpdateToolboxImages()
+        // Short version of UpdateToolboxImages()
         rSet.Put( TbxImageItem( SID_DRAWTBX_TEXT, nCurrentSId ) );
     }
 
@@ -1105,7 +1099,7 @@ void DrawViewShell::GetMenuState( SfxItemSet &rSet )
         rSet.DisableItem( SID_OBJECT_CROOK_SLANT );
         rSet.DisableItem( SID_OBJECT_CROOK_STRETCH );
 
-        // Alle objekterzeugenden Werkzeuge disablen
+        // Disable all object-creating tools
         rSet.ClearItem( SID_ATTR_CHAR );
         rSet.DisableItem( SID_ATTR_CHAR );
         rSet.ClearItem( SID_ATTR_CHAR_VERTICAL );
@@ -1277,7 +1271,7 @@ void DrawViewShell::GetMenuState( SfxItemSet &rSet )
         rSet.DisableItem(SID_3D_PYRAMID);
     }
 
-    // Sind die Module verfuegbar?
+    // are the modules available?
 
     if (!SvtModuleOptions().IsCalc())
     {
@@ -1296,7 +1290,7 @@ void DrawViewShell::GetMenuState( SfxItemSet &rSet )
     rtl::Reference< sd::SlideShow > xSlideshow( SlideShow::GetSlideShow( GetViewShellBase() ) );
     if( (xSlideshow.is() && xSlideshow->isRunning() && (xSlideshow->getAnimationMode() != ANIMATIONMODE_PREVIEW) ) || GetDocSh()->IsPreview() )
     {
-        // Eigene Slots
+        // Own Slots
         rSet.DisableItem( SID_PRESENTATION );
         rSet.DisableItem( SID_ZOOM_IN );
         rSet.DisableItem( SID_ZOOM_OUT );
@@ -1642,7 +1636,7 @@ void DrawViewShell::GetModeSwitchingMenuState (SfxItemSet &rSet)
 
     if (GetDocSh()->GetCreateMode() == SFX_CREATE_MODE_EMBEDDED)
     {
-        // Outplace-Edit: Kein Umschalten erlauben
+        // Outplace-Edit: do not allow switch
         rSet.ClearItem( SID_OUTLINEMODE );
         rSet.DisableItem( SID_OUTLINEMODE );
 
diff --git a/sd/source/ui/view/drviews8.cxx b/sd/source/ui/view/drviews8.cxx
index ab297b7fbfad..f4dfc30161bd 100644
--- a/sd/source/ui/view/drviews8.cxx
+++ b/sd/source/ui/view/drviews8.cxx
@@ -71,12 +71,9 @@
 
 namespace sd {
 
-/*************************************************************************
-|*
-|* SfxRequests fuer temporaere Funktionen
-|*
-\************************************************************************/
-
+/**
+ * SfxRequests for temporary functions
+ */
 void DrawViewShell::FuTemp01(SfxRequest& rReq)
 {
     switch(rReq.GetSlot())
@@ -230,7 +227,7 @@ void DrawViewShell::FuTemp01(SfxRequest& rReq)
         {
             SetCurrentFunction( FuPage::Create( this, GetActiveWindow(), mpDrawView, GetDoc(), rReq ) );
             Cancel();
-            rReq.Ignore (); // es werden eigenstaendige macros generiert !!
+            rReq.Ignore (); // we generate independent macros !!
         }
         break;
 
@@ -239,7 +236,7 @@ void DrawViewShell::FuTemp01(SfxRequest& rReq)
         {
             mbZoomOnPage = sal_False;
             SetCurrentFunction( FuZoom::Create(this, GetActiveWindow(), mpDrawView, GetDoc(), rReq) );
-            // Beendet sich selbst, kein Cancel() notwendig!
+            // finishes itself, no Cancel() needed!
             Invalidate( SID_ZOOM_TOOLBOX );
             rReq.Ignore ();
         }
@@ -251,7 +248,7 @@ void DrawViewShell::FuTemp01(SfxRequest& rReq)
             SetCurrentFunction( FuDisplayOrder::Create(this, GetActiveWindow(), mpDrawView, GetDoc(), rReq) );
             Invalidate( SID_POSITION );
             rReq.Ignore ();
-            // Beendet sich selbst, kein Cancel() notwendig!
+            // finishes itself, no Cancel() needed!
         }
         break;
 
@@ -279,7 +276,7 @@ void DrawViewShell::FuTemp01(SfxRequest& rReq)
         break;
 
         case SID_CAPTUREPOINT:
-            // negative Werte um Aufruf aus Menue zu signalisieren
+            // negative value to signal call from menu
             maMousePos = Point(-1,-1);
         case SID_SET_SNAPITEM:
         {
@@ -423,20 +420,15 @@ void DrawViewShell::FuTemp01(SfxRequest& rReq)
 
         default:
         {
-            // switch Anweisung wegen CLOOKS aufgeteilt. Alle case-Anweisungen die
-            // eine Fu???? -Funktion aufrufen, sind in die Methode FuTemp01 (drviews8),
-            // FuTemp02 (drviewsb) gewandert.
+            // Switch statement splitted because of CLOOKS. All case-statements
+            // which call a Fu???? - function, are gone into FuTemp01
+            // (drviews8), FuTemp02 (drviewsb).
             FuTemp02(rReq);
         }
         break;
     }
 }
 
-/*************************************************************************
-|*
-|* Scanner-Event
-|*
-\************************************************************************/
 
 void DrawViewShell::ScannerEvent( const ::com::sun::star::lang::EventObject& )
 {
diff --git a/sd/source/ui/view/drviews9.cxx b/sd/source/ui/view/drviews9.cxx
index 493a3dfc34ae..243b2016ae42 100644
--- a/sd/source/ui/view/drviews9.cxx
+++ b/sd/source/ui/view/drviews9.cxx
@@ -59,15 +59,10 @@
 
 namespace sd {
 
-/*************************************************************************
-|*
-|* SfxRequests fuer Gallery bearbeiten
-|*
-\************************************************************************/
 
 void DrawViewShell::ExecGallery(SfxRequest& rReq)
 {
-    // waehrend einer Diashow wird nichts ausgefuehrt!
+    // nothing is executed during a slide show!
     if(HasCurrentFunction(SID_PRESENTATION))
         return;
 
@@ -82,27 +77,26 @@ void DrawViewShell::ExecGallery(SfxRequest& rReq)
         {
             GetDocSh()->SetWaitCursor( sal_True );
 
-            // Graphik einfuegen
+            // insert graphic
             if (nFormats & SGA_FORMAT_GRAPHIC)
             {
                 Graphic aGraphic = pGal->GetGraphic();
 
-                // Ggf. Groesse reduzieren
+                // reduce size if necessary
                 Window aWindow (GetActiveWindow());
                 aWindow.SetMapMode(aGraphic.GetPrefMapMode());
                 Size aSizePix = aWindow.LogicToPixel(aGraphic.GetPrefSize());
                 aWindow.SetMapMode( MapMode(MAP_100TH_MM) );
                 Size aSize = aWindow.PixelToLogic(aSizePix);
 
-                // Groesse ggf. auf Seitengroesse begrenzen
+                // constrain size to page size if necessary
                 SdrPage* pPage = mpDrawView->GetSdrPageView()->GetPage();
                 Size aPageSize = pPage->GetSize();
                 aPageSize.Width() -= pPage->GetLftBorder() + pPage->GetRgtBorder();
                 aPageSize.Height() -= pPage->GetUppBorder() + pPage->GetLwrBorder();
 
 
-                // Falls Grafik zu gross, wird die Grafik
-                // in die Seite eingepasst
+                // if the graphic is to big, we fit it into the page
                 if ( ( ( aSize.Height() > aPageSize.Height() ) || ( aSize.Width()   > aPageSize.Width() ) ) &&
                     aSize.Height() && aPageSize.Height() )
                 {
@@ -111,7 +105,7 @@ void DrawViewShell::ExecGallery(SfxRequest& rReq)
                     float fWinWH =  (float)aPageSize.Width() /
                                     (float)aPageSize.Height();
 
-                    // Grafik an Pagesize anpassen (skaliert)
+                    // adjust graphic to page size (scales)
                     if ((fGrfWH != 0.F) && (fGrfWH < fWinWH))
                     {
                         aSize.Width() = (long)(aPageSize.Height() * fGrfWH);
@@ -125,7 +119,7 @@ void DrawViewShell::ExecGallery(SfxRequest& rReq)
                 }
 
 
-                // Ausgaberechteck fuer Grafik setzen
+                // set output rectangle for graphic
                 Point aPnt ((aPageSize.Width()  - aSize.Width())  / 2,
                             (aPageSize.Height() - aSize.Height()) / 2);
                 aPnt += Point(pPage->GetLftBorder(), pPage->GetUppBorder());
@@ -137,9 +131,7 @@ void DrawViewShell::ExecGallery(SfxRequest& rReq)
 
                 if ( mpDrawView->AreObjectsMarked() )
                 {
-                    /******************************************************
-                    * Ist ein leeres Graphik-Objekt vorhanden?
-                    ******************************************************/
+                    // is there a empty graphic object?
                     const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList();
 
                     if (rMarkList.GetMarkCount() == 1)
@@ -153,10 +145,7 @@ void DrawViewShell::ExecGallery(SfxRequest& rReq)
 
                             if( pGrafObj->IsEmptyPresObj() )
                             {
-                                /******************************************
-                                * Das leere Graphik-Objekt bekommt eine neue
-                                * Graphik
-                                ******************************************/
+                                // the empty graphic object gets a new graphic
                                 bInsertNewObject = sal_False;
 
                                 SdrGrafObj* pNewGrafObj = (SdrGrafObj*) pGrafObj->Clone();
@@ -184,7 +173,7 @@ void DrawViewShell::ExecGallery(SfxRequest& rReq)
                     mpDrawView->InsertObjectAtView(pGrafObj, *pPV, SDRINSERT_SETDEFLAYER);
                 }
 
-                // Soll nur ein Link benutzt werden?
+                // should we just use a link?
                 if( pGrafObj && pGal->IsLinkage() )
                     pGrafObj->SetGraphicLink( pGal->GetURL().GetMainURL( INetURLObject::NO_DECODE ), pGal->GetFilterName() );
             }
@@ -201,33 +190,24 @@ void DrawViewShell::ExecGallery(SfxRequest& rReq)
 }
 
 
-/*************************************************************************
-|*
-|* Statuswerte fuer Gallery zurueckgeben
-|*
-\************************************************************************/
 
 void DrawViewShell::GetGalleryState(SfxItemSet& )
 {
 }
 
-/*************************************************************************
-|*
-|* Makros fuer die Attributeinstellungen bearbeiten
-|*
-\************************************************************************/
-
-//
-// die vorgehensweise fuer die attributaenderung ist praktisch ueberall identisch
-// 1. bisherige attribute auslesen
-// 2. parameter aus dem basic-set auslesen
-// 3. gewaehltes item aus dem attribut-set loeschen
-// 4. neues attribut-item erzeugen
-// 5. item in den set eintragen
-//
+/**
+ * Edit macros for attribute configuration
+ */
+
+/* the work flow to adjust the attributes is nearly everywhere the same
+   1. read existing attributes
+   2. read parameter from the basic-set
+   3. delete selected item from the attribute-set
+   4. create new attribute-item
+   5. insert item into set      */
 void DrawViewShell::AttrExec (SfxRequest &rReq)
 {
-    // waehrend einer Diashow wird nichts ausgefuehrt!
+    // nothing is executed during a slide show!
     if(HasCurrentFunction(SID_PRESENTATION))
         return;
 
@@ -241,7 +221,7 @@ void DrawViewShell::AttrExec (SfxRequest &rReq)
 
     switch (rReq.GetSlot ())
     {
-        // neuen fuellstil setzen
+        // set new fill-style
         case SID_SETFILLSTYLE :
             if (pArgs)
                 if (pArgs->Count () == 1)
@@ -263,7 +243,7 @@ void DrawViewShell::AttrExec (SfxRequest &rReq)
 #endif
             break;
 
-        // linienstil neu bestimmen
+        // determine new line style
         case SID_SETLINESTYLE :
             if (pArgs)
                 if (pArgs->Count () == 1)
@@ -285,7 +265,7 @@ void DrawViewShell::AttrExec (SfxRequest &rReq)
 #endif
             break;
 
-        // linienbreite setzen
+        // set line width
         case SID_SETLINEWIDTH :
             if (pArgs)
                 if (pArgs->Count () == 1)
@@ -512,7 +492,7 @@ void DrawViewShell::AttrExec (SfxRequest &rReq)
 #endif
             break;
 
-        // einstellungen fuer farbverlauf
+        // configuration for gradients
         case SID_GRADIENT :
             if (pArgs)
                 if (pArgs->Count () == 8)
@@ -589,7 +569,7 @@ void DrawViewShell::AttrExec (SfxRequest &rReq)
 #endif
             break;
 
-        // einstellungen fuer schraffur
+        // configuration for hatch
         case SID_HATCH :
             if (pArgs)
                 if (pArgs->Count () == 4)
@@ -764,12 +744,9 @@ void DrawViewShell::AttrExec (SfxRequest &rReq)
     delete pAttr;
 }
 
-/*************************************************************************
-|*
-|* Makros fuer die Attributeinstellungen bearbeiten
-|*
-\************************************************************************/
-
+/**
+ * Edit macros for attribute configuration
+ */
 void DrawViewShell::AttrState (SfxItemSet& rSet)
 {
     SfxWhichIter     aIter (rSet);
diff --git a/sd/source/ui/view/drviewsa.cxx b/sd/source/ui/view/drviewsa.cxx
index 135b198c237b..5ecde162c967 100644
--- a/sd/source/ui/view/drviewsa.cxx
+++ b/sd/source/ui/view/drviewsa.cxx
@@ -112,11 +112,6 @@ void SAL_CALL ScannerEventListener::disposing( const ::com::sun::star::lang::Eve
         mpParent->ScannerEvent( rEventObject );
 }
 
-/*************************************************************************
-|*
-|* Standard-Konstruktor
-|*
-\************************************************************************/
 
 DrawViewShell::DrawViewShell( SfxViewFrame* pFrame, ViewShellBase& rViewShellBase, ::Window* pParentWindow, PageKind ePageKind, FrameView* pFrameViewArgument )
 : ViewShell (pFrame, pParentWindow, rViewShellBase)
@@ -132,11 +127,6 @@ DrawViewShell::DrawViewShell( SfxViewFrame* pFrame, ViewShellBase& rViewShellBas
     doShow();
 }
 
-/*************************************************************************
-|*
-|* Destruktor
-|*
-\************************************************************************/
 
 DrawViewShell::~DrawViewShell()
 {
@@ -200,12 +190,9 @@ DrawViewShell::~DrawViewShell()
     delete [] mpSlotArray;
 }
 
-/*************************************************************************
-|*
-|* gemeinsamer Initialisierungsanteil der beiden Konstruktoren
-|*
-\************************************************************************/
-
+/**
+ * common part of both constructors
+ */
 void DrawViewShell::Construct(DrawDocShell* pDocSh, PageKind eInitialPageKind)
 {
     mpActualPage = 0;
@@ -220,11 +207,11 @@ void DrawViewShell::Construct(DrawDocShell* pDocSh, PageKind eInitialPageKind)
 
     OSL_ASSERT (GetViewShell()!=NULL);
 
-    // Array fuer Slot-/ImageMapping:
-    // Gerader Eintrag: Haupt-/ToolboxSlot
-    // Ungerader Eintrag: gemappter Slot
-    // Achtung: Anpassen von GetIdBySubId() !!!
-    // Reihenfolge (insbesondere Zoom) darf nicht geaendert werden !!!
+    /* array for slot-/image mapping:
+       even entry: main-/toolbox slot
+       odd entry:  mapped slot
+       Attention: adjust GetIdBySubId() !!!
+       Do not change order (especial zoom) !!! */
     mpSlotArray = new sal_uInt16[ SLOTARRAY_COUNT ];
     mpSlotArray[ 0 ]  = SID_OBJECT_CHOOSE_MODE;
     mpSlotArray[ 1 ]  = SID_OBJECT_ROTATE;
@@ -256,15 +243,15 @@ void DrawViewShell::Construct(DrawDocShell* pDocSh, PageKind eInitialPageKind)
     GetDoc()->CreateFirstPages();
 
     mpDrawView = new DrawView(pDocSh, GetActiveWindow(), this);
-    mpView = mpDrawView;             // Pointer der Basisklasse ViewShell
-    mpDrawView->SetSwapAsynchron(sal_True); // Asynchrones Laden von Graphiken
+    mpView = mpDrawView;             // Pointer of base class ViewShell
+    mpDrawView->SetSwapAsynchron(sal_True); // Asynchronous load of graphics
 
     // We do not read the page kind from the frame view anymore so we have
     // to set it in order to resync frame view and this view.
     mpFrameView->SetPageKind(eInitialPageKind);
     mePageKind = eInitialPageKind;
     meEditMode = EM_PAGE;
-    DocumentType eDocType = GetDoc()->GetDocumentType(); // RTTI fasst hier noch nicht
+    DocumentType eDocType = GetDoc()->GetDocumentType(); // RTTI does not work here
     switch (mePageKind)
     {
         case PK_STANDARD:
@@ -294,14 +281,14 @@ void DrawViewShell::Construct(DrawDocShell* pDocSh, PageKind eInitialPageKind)
 
     mpDrawView->SetWorkArea(Rectangle(Point() - aVisAreaPos - aPageOrg, aSize));
 
-    // Objekte koennen max. so gross wie die ViewSize werden
+    // objects can not grow bigger than ViewSize
     GetDoc()->SetMaxObjSize(aSize);
 
-    // Split-Handler fuer TabControls
+    // Split-Handler for TabControls
     maTabControl.SetSplitHdl( LINK( this, DrawViewShell, TabSplitHdl ) );
 
-    // Damit der richtige EditMode von der FrameView komplett eingestellt
-    // werden kann, wird hier ein aktuell anderer gewaehlt (kleiner Trick)
+    /* In order to set the correct EditMode of the FrameView, we select another
+       one (small trick).  */
     if (mpFrameView->GetViewShEditMode(mePageKind) == EM_PAGE)
     {
         meEditMode = EM_MASTERPAGE;
@@ -311,7 +298,7 @@ void DrawViewShell::Construct(DrawDocShell* pDocSh, PageKind eInitialPageKind)
         meEditMode = EM_PAGE;
     }
 
-    // Einstellungen der FrameView uebernehmen
+    // Use configuration of FrameView
     ReadFrameViewData(mpFrameView);
 
     if( eDocType == DOCUMENT_TYPE_DRAW )
@@ -328,7 +315,7 @@ void DrawViewShell::Construct(DrawDocShell* pDocSh, PageKind eInitialPageKind)
             GetActiveWindow()->SetHelpId( CMD_SID_NOTESMODE );
             GetActiveWindow()->SetUniqueId( CMD_SID_NOTESMODE );
 
-            // AutoLayouts muessen erzeugt sein
+            // AutoLayouts have to be created
             GetDoc()->StopWorkStartupDelay();
         }
         else if (mePageKind == PK_HANDOUT)
@@ -337,7 +324,7 @@ void DrawViewShell::Construct(DrawDocShell* pDocSh, PageKind eInitialPageKind)
             GetActiveWindow()->SetHelpId( CMD_SID_HANDOUTMODE );
             GetActiveWindow()->SetUniqueId( CMD_SID_HANDOUTMODE );
 
-            // AutoLayouts muessen erzeugt sein
+            // AutoLayouts have to be created
             GetDoc()->StopWorkStartupDelay();
         }
         else
@@ -348,7 +335,7 @@ void DrawViewShell::Construct(DrawDocShell* pDocSh, PageKind eInitialPageKind)
         }
     }
 
-    // Selektionsfunktion starten
+    // start selection function
     SfxRequest aReq(SID_OBJECT_SELECT, 0, GetDoc()->GetItemPool());
     FuPermanent(aReq);
     mpDrawView->SetFrameDragSingles(sal_True);
@@ -446,24 +433,20 @@ bool DrawViewShell::RelocateToParentWindow (::Window* pParentWindow)
 
 
 
-/*************************************************************************
-|*
-|* pruefe ob linienzuege gezeichnet werden muessen
-|*
-\************************************************************************/
+/**
+ * check if we have to draw a polyline
+ */
 
 /*
-    linienzuege werden ueber makros als folge von
+    Polylines are represented by makros as a sequence of:
         MoveTo (x, y)
-        LineTo (x, y)   [oder BezierTo (x, y)]
+        LineTo (x, y)   [or BezierTo (x, y)]
         LineTo (x, y)
             :
-    dargestellt. einen endbefehl fuer die linienzuege
-    gibt es nicht, also muessen alle befehle in den
-    requests nach LineTo (BezierTo) abgetestet und die
-    punktparameter gesammelt werden.
-    der erste nicht-LineTo fuehrt dann dazu, dass aus
-    den gesammelten punkten der linienzug erzeugt wird
+    There is no end command for polylines. Therefore, we have to test all
+    commands in the requests for LineTo (BezierTo) and we have to gather
+    the point-parameter. The first not-LineTo leads to the creation of the
+    polyline from the gathered points.
 */
 
 void DrawViewShell::CheckLineTo(SfxRequest& rReq)
@@ -482,12 +465,9 @@ void DrawViewShell::CheckLineTo(SfxRequest& rReq)
     rReq.Ignore ();
 }
 
-/*************************************************************************
-|*
-|* veraendere die seitemparameter, wenn SID_PAGESIZE oder SID_PAGEMARGIN
-|*
-\************************************************************************/
-
+/**
+ * Change page parameter if SID_PAGESIZE or SID_PAGEMARGIN
+ */
 void DrawViewShell::SetupPage (Size &rSize,
                                  long nLeft,
                                  long nRight,
@@ -502,9 +482,7 @@ void DrawViewShell::SetupPage (Size &rSize,
 
     for (i = 0; i < nPageCnt; i++)
     {
-        /**********************************************************************
-        * Erst alle MasterPages bearbeiten
-        **********************************************************************/
+        // first, handle all master pages
         SdPage *pPage = GetDoc()->GetMasterSdPage(i, mePageKind);
 
         if( pPage )
@@ -537,9 +515,7 @@ void DrawViewShell::SetupPage (Size &rSize,
 
     for (i = 0; i < nPageCnt; i++)
     {
-        /**********************************************************************
-        * Danach alle Pages bearbeiten
-        **********************************************************************/
+        // then, handle all pages
         SdPage *pPage = GetDoc()->GetSdPage(i, mePageKind);
 
         if( pPage )
@@ -598,22 +574,17 @@ void DrawViewShell::SetupPage (Size &rSize,
 
     GetViewFrame()->GetBindings().Invalidate(SID_RULER_NULL_OFFSET);
 
-    // auf (neue) Seitengroesse zoomen
+    // zoom onto (new) page size
     GetViewFrame()->GetDispatcher()->Execute(SID_SIZE_PAGE,
                         SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD);
 }
 
-/*************************************************************************
-|*
-|* Statuswerte der Statusbar zurueckgeben
-|*
-\************************************************************************/
 
 void DrawViewShell::GetStatusBarState(SfxItemSet& rSet)
 {
-    // Zoom-Item
-    // Hier sollte der entsprechende Wert (Optimal ?, Seitenbreite oder
-    // Seite) mit Hilfe des ZoomItems weitergegeben werden !!!
+    /* Zoom-Item
+       Here we should propagate the corresponding value (Optimal ?, page width
+       or page) with the help of the ZoomItems !!!   */
     if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_ATTR_ZOOM ) )
     {
         if (GetDocSh()->IsUIActive() || (SlideShow::IsRunning(GetViewShellBase())) )
@@ -630,7 +601,7 @@ void DrawViewShell::GetStatusBarState(SfxItemSet& rSet)
             else
                 pZoomItem = new SvxZoomItem( SVX_ZOOM_PERCENT, nZoom );
 
-            // Bereich einschraenken
+            // constrain area
             sal_uInt16 nZoomValues = SVX_ZOOM_ENABLE_ALL;
             SdrPageView* pPageView = mpDrawView->GetSdrPageView();
 
@@ -686,7 +657,7 @@ void DrawViewShell::GetStatusBarState(SfxItemSet& rSet)
     aPos.X() = Fraction(aPos.X()) / aUIScale;
     aPos.Y() = Fraction(aPos.Y()) / aUIScale;
 
-    // Position- und Groesse-Items
+    // position- and size items
     if ( mpDrawView->IsAction() )
     {
         Rectangle aRect;
diff --git a/sd/source/ui/view/drviewsb.cxx b/sd/source/ui/view/drviewsb.cxx
index a2f524ac7819..850c4432e608 100644
--- a/sd/source/ui/view/drviewsb.cxx
+++ b/sd/source/ui/view/drviewsb.cxx
@@ -64,12 +64,9 @@
 
 namespace sd {
 
-/*************************************************************************
-|*
-|* SfxRequests fuer temporaere Funktionen
-|*
-\************************************************************************/
-
+/**
+ * SfxRequests for temporary functions
+ */
 void DrawViewShell::FuTemp02(SfxRequest& rReq)
 {
     sal_uInt16 nSId = rReq.GetSlot();
@@ -111,7 +108,7 @@ void DrawViewShell::FuTemp02(SfxRequest& rReq)
                 {
                     pDlg->SetHelpId( SD_MOD()->GetSlotPool()->GetSlot( SID_INSERTLAYER )->GetCommand() );
 
-                    // Ueberpruefung auf schon vorhandene Namen
+                    // test for already existing names
                     sal_Bool bLoop = sal_True;
                     while( bLoop && pDlg->Execute() == RET_OK )
                     {
@@ -121,7 +118,7 @@ void DrawViewShell::FuTemp02(SfxRequest& rReq)
                         if( rLayerAdmin.GetLayer( aLayerName, sal_False )
                             || aLayerName.Len()==0 )
                         {
-                            // Name ist schon vorhanden
+                            // name already exists
                             WarningBox aWarningBox (
                                 GetParentWindow(),
                                 WinBits( WB_OK ),
@@ -131,7 +128,7 @@ void DrawViewShell::FuTemp02(SfxRequest& rReq)
                         else
                             bLoop = sal_False;
                     }
-                    if( bLoop ) // wurde abgebrochen
+                    if( bLoop ) // was canceled
                     {
                         delete pDlg;
 
@@ -242,7 +239,7 @@ void DrawViewShell::FuTemp02(SfxRequest& rReq)
 
 
             const SfxItemSet* pArgs = rReq.GetArgs();
-            // darf der Layer geloescht werden ?
+            // is it allowed to delete the layer?
             bool bDelete = true;
 
             String aLayoutLayer ( SdResId(STR_LAYER_LAYOUT) );
@@ -276,7 +273,7 @@ void DrawViewShell::FuTemp02(SfxRequest& rReq)
                 {
                     pDlg->SetHelpId( SD_MOD()->GetSlotPool()->GetSlot( SID_MODIFYLAYER )->GetCommand() );
 
-                    // Ueberpruefung auf schon vorhandene Namen
+                    // test for already existing names
                     sal_Bool    bLoop = sal_True;
                     sal_uInt16  nRet = 0;
                     while( bLoop && ( (nRet = pDlg->Execute()) == RET_OK ) )
@@ -287,7 +284,7 @@ void DrawViewShell::FuTemp02(SfxRequest& rReq)
                         if( (rLayerAdmin.GetLayer( aLayerName, sal_False ) &&
                              aLayerName != aOldLayerName) || aLayerName.Len()==0 )
                         {
-                            // Name ist schon vorhanden
+                            // name already exists
                             WarningBox aWarningBox (
                                 GetParentWindow(),
                                 WinBits( WB_OK ),
@@ -555,7 +552,7 @@ void DrawViewShell::FuTemp02(SfxRequest& rReq)
                                     pOldFldItem->GetField()->ISA( SvxAuthorField ) ||
                                     pOldFldItem->GetField()->ISA( SvxPageField ) ) )
                 {
-                    // Feld selektieren, so dass es beim Insert geloescht wird
+                    // select field, then it will be deleted when inserting
                     ESelection aSel = pOLV->GetSelection();
                     if( aSel.nStartPos == aSel.nEndPos )
                         aSel.nEndPos++;
@@ -698,9 +695,9 @@ void DrawViewShell::FuTemp02(SfxRequest& rReq)
 
         default:
         {
-            // switch Anweisung wegen CLOOKS aufgeteilt. Alle case-Anweisungen die
-            // eine Fu???? -Funktion aufrufen, sind in die Methode FuTemp03 (drviewsb)
-            // gewandert.
+            /* switch construct was split because of CLOOKS. All cases which
+               call a Fu??? function were moved to the method FuTemp03
+               (drviewsb).   */
             FuTemp03(rReq);
         }
         break;
@@ -838,7 +835,7 @@ void DrawViewShell::ModifyLayer (
 
         if (!bIsVisible)
         {
-            // Unsichtbare Layer werden anders dargestellt
+            // invisible layers are presented differnt
             nBits = TPB_SPECIAL;
         }
 
diff --git a/sd/source/ui/view/drviewsc.cxx b/sd/source/ui/view/drviewsc.cxx
index 6ccbb96262a9..6694393fa7fa 100644
--- a/sd/source/ui/view/drviewsc.cxx
+++ b/sd/source/ui/view/drviewsc.cxx
@@ -54,15 +54,12 @@
 #include "brkdlg.hrc"
 namespace sd {
 
-#define MIN_ACTIONS_FOR_DIALOG  5000    // bei mehr als 1600 Metaobjekten
-                                        // wird beim Aufbrechen ein Dialog
-                                        // angezeigt.
-/*************************************************************************
-|*
-|* SfxRequests fuer temporaere Funktionen
-|*
-\************************************************************************/
+#define MIN_ACTIONS_FOR_DIALOG  5000    ///< if there are more meta objects, we show a dialog during the break up
 
+
+/**
+ * SfxRequests for temporary functions
+ */
 void DrawViewShell::FuTemp03(SfxRequest& rReq)
 {
     sal_uInt16 nSId = rReq.GetSlot();
@@ -339,7 +336,7 @@ void DrawViewShell::FuTemp03(SfxRequest& rReq)
                 const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList();
                 sal_uLong nAnz=rMarkList.GetMarkCount();
 
-                // Summe der Metaobjekte aller sel. Metafiles erm.
+                // determine the sum of meta objects of all selected meta files
                 sal_uLong nCount = 0;
                 for(sal_uLong nm=0; nm<nAnz; nm++)
                 {
@@ -366,11 +363,10 @@ void DrawViewShell::FuTemp03(SfxRequest& rReq)
                     }
                 }
 
-                // anhand der erm. Summe entscheiden ob mit
-                // oder ohne Dialog aufgebrochen wird.
+                // decide with the sum of all meta objects if we should show a dialog
                 if(nCount < MIN_ACTIONS_FOR_DIALOG)
                 {
-                    // ohne Dialog aufbrechen
+                    // nope, no dialog
                     mpDrawView->DoImportMarkedMtf();
                 }
                 else
@@ -634,13 +630,9 @@ void DrawViewShell::FuTemp03(SfxRequest& rReq)
     };
 };
 
-/*************************************************************************
-|*
-|* Liefert die globale/Haupt-ID zurueck, also die ID, ueber die die
-|* Toolbox ausgeloest wird
-|*
-\************************************************************************/
-
+/**
+ * Returns the global/main ID, i.e. the ID, which is used to execute the toolbox
+ */
 sal_uInt16 DrawViewShell::GetIdBySubId( sal_uInt16 nSId )
 {
     sal_uInt16 nMappedSId = 0;
@@ -834,13 +826,9 @@ sal_uInt16 DrawViewShell::GetIdBySubId( sal_uInt16 nSId )
     return( nMappedSId );
 }
 
-/*************************************************************************
-|*
-|* Fuellt das SlotArray, um das aktuelle Mapping des ToolboxSlots zu
-|* bekommen
-|*
-\************************************************************************/
-
+/**
+ * Fills the SlotArray in order to get the current mapping of the ToolboxSlots
+ */
 void DrawViewShell::MapSlot( sal_uInt16 nSId )
 {
     sal_uInt16 nMappedSId = GetIdBySubId( nSId );
@@ -852,12 +840,9 @@ void DrawViewShell::MapSlot( sal_uInt16 nSId )
     }
 }
 
-/*************************************************************************
-|*
-|* Ermoeglicht ueber das SlotArray ein ImageMapping
-|*
-\************************************************************************/
-
+/**
+ * Allows a ImageMapping via SlotArray
+ */
 void DrawViewShell::UpdateToolboxImages( SfxItemSet &rSet, sal_Bool bPermanent )
 {
     if( !bPermanent )
@@ -883,11 +868,6 @@ void DrawViewShell::UpdateToolboxImages( SfxItemSet &rSet, sal_Bool bPermanent )
     }
 }
 
-/*************************************************************************
-|*
-|* Gibt den gemappten Slot zurueck
-|*
-\************************************************************************/
 
 sal_uInt16 DrawViewShell::GetMappedSlot( sal_uInt16 nSId )
 {
@@ -896,22 +876,18 @@ sal_uInt16 DrawViewShell::GetMappedSlot( sal_uInt16 nSId )
     if( nId != USHRT_MAX )
         nSlot = mpSlotArray[ nId+1 ];
 
-    // Wenn der Slot noch auf sich selbst gemapped ist, muss 0 zurueck-
-    // gegeben werden, da sonst der Slot immer wieder selbst executet
-    // wird. Im Array ist der Slot selbst initial vorhanden, damit das
-    // Image richtig angezeigt wird.
+    /* If the slot is mapped to itself, we have to return 0. Otherwise the slot
+       would be executed over and over again. The slot is initial available in
+       the array in order to show the image correct.  */
     if( nSId == nSlot )
         return( 0 );
 
     return( nSlot );
 }
 
-/*************************************************************************
-|*
-|* Gibt die Nummer des HauptSlots im SlotArray zurueck
-|*
-\************************************************************************/
-
+/**
+ * @returns number of the main slot in the slot array
+ */
 sal_uInt16 DrawViewShell::GetArrayId( sal_uInt16 nSId )
 {
     for( sal_uInt16 i = 0; i < SLOTARRAY_COUNT; i += 2 )
@@ -924,11 +900,6 @@ sal_uInt16 DrawViewShell::GetArrayId( sal_uInt16 nSId )
 }
 
 
-/*************************************************************************
-|*
-|* IMap-Dlg updaten
-|*
-\************************************************************************/
 
 void DrawViewShell::UpdateIMapDlg( SdrObject* pObj )
 {
@@ -954,7 +925,7 @@ void DrawViewShell::UpdateIMapDlg( SdrObject* pObj )
 
         SvxIMapDlgChildWindow::UpdateIMapDlg( aGraphic, pIMap, pTargetList, pObj );
 
-        // TargetListe kann von uns wieder geloescht werden
+        // We can delete the target list
         if ( pTargetList )
         {
             for ( size_t i = 0, n = pTargetList->size(); i < n; ++i )
diff --git a/sd/source/ui/view/drviewsd.cxx b/sd/source/ui/view/drviewsd.cxx
index fdaf55f24f8a..a3c52e34ec38 100644
--- a/sd/source/ui/view/drviewsd.cxx
+++ b/sd/source/ui/view/drviewsd.cxx
@@ -45,12 +45,9 @@
 
 namespace sd {
 
-/*************************************************************************
-|*
-|* SfxRequests fuer Navigator bearbeiten
-|*
-\************************************************************************/
-
+/**
+ * handle SfxRequests for navigator
+ */
 void DrawViewShell::ExecNavigatorWin( SfxRequest& rReq )
 {
     CheckLineTo (rReq);
@@ -94,21 +91,21 @@ void DrawViewShell::ExecNavigatorWin( SfxRequest& rReq )
                 {
                     case PAGE_FIRST:
                     {
-                        // Sprung zu erster Seite
+                        // jump to first page
                         SwitchPage(0);
                     }
                     break;
 
                     case PAGE_LAST:
                     {
-                        // Sprung zu letzter Seite
+                        // jumpt to last page
                         SwitchPage(GetDoc()->GetSdPageCount(mpActualPage->GetPageKind()) - 1);
                     }
                     break;
 
                     case PAGE_NEXT:
                     {
-                        // Sprung zu naechster Seite
+                        // jump to next page
                         sal_uInt16 nSdPage = (mpActualPage->GetPageNum() - 1) / 2;
 
                         if (nSdPage < GetDoc()->GetSdPageCount(mpActualPage->GetPageKind()) - 1)
@@ -120,7 +117,7 @@ void DrawViewShell::ExecNavigatorWin( SfxRequest& rReq )
 
                     case PAGE_PREVIOUS:
                     {
-                        // Sprung zu vorheriger Seite
+                        // jump to previous page
                         sal_uInt16 nSdPage = (mpActualPage->GetPageNum() - 1) / 2;
 
                         if (nSdPage > 0)
@@ -163,11 +160,6 @@ void DrawViewShell::ExecNavigatorWin( SfxRequest& rReq )
     }
 }
 
-/*************************************************************************
-|*
-|* Statuswerte fuer Navigator zurueckgeben
-|*
-\************************************************************************/
 
 void DrawViewShell::GetNavigatorWinState( SfxItemSet& rSet )
 {
@@ -209,7 +201,7 @@ void DrawViewShell::GetNavigatorWinState( SfxItemSet& rSet )
         nLastPage = GetDoc()->GetSdPageCount( mePageKind ) - 1;
     }
 
-    // erste Seite / vorherige Seite
+    // first page / previous page
     if( nCurrentPage == nFirstPage )
     {
         nState |= NAVBTN_FIRST_DISABLED;
@@ -223,7 +215,7 @@ void DrawViewShell::GetNavigatorWinState( SfxItemSet& rSet )
         nState |= NAVBTN_FIRST_ENABLED | NAVBTN_PREV_ENABLED;
     }
 
-    // letzte Seite / naechste Seite
+    // last page / next page
     if( nCurrentPage == nLastPage )
     {
         nState |= NAVBTN_LAST_DISABLED;
diff --git a/sd/source/ui/view/drviewse.cxx b/sd/source/ui/view/drviewse.cxx
index e17192ce3da8..969ac97cf826 100644
--- a/sd/source/ui/view/drviewse.cxx
+++ b/sd/source/ui/view/drviewse.cxx
@@ -101,11 +101,7 @@ using namespace ::com::sun::star::presentation;
 
 namespace sd {
 
-/*************************************************************************
-|*
-|* Permanente Funktionen
-|*
-\************************************************************************/
+// Permanent Functions
 
 void ImpAddPrintableCharactersToTextEdit(SfxRequest& rReq, ::sd::View* pView)
 {
@@ -141,7 +137,7 @@ void ImpAddPrintableCharactersToTextEdit(SfxRequest& rReq, ::sd::View* pView)
 
 void DrawViewShell::FuPermanent(SfxRequest& rReq)
 {
-    // Waehrend einer Native-Diashow wird nichts ausgefuehrt!
+    // We do not execute a thing during a native slide show
 
     if (SlideShow::IsRunning(GetViewShellBase()))
         return;
@@ -229,7 +225,7 @@ void DrawViewShell::FuPermanent(SfxRequest& rReq)
         rBind.Update(nOldSId);
     }
 
-    // Slot wird gemapped (ToolboxImages/-Slots)
+    // map Slot (ToolboxImages/-Slots)
     MapSlot( nSId );
 
     switch ( nSId )
@@ -315,7 +311,7 @@ void DrawViewShell::FuPermanent(SfxRequest& rReq)
 
             if( nSlotId == SID_OBJECT_ROTATE )
             {
-                // togle rotation
+                // toggle rotation
                 if( nOldSId == nSlotId )
                 {
                     nSlotId = SID_OBJECT_SELECT;
@@ -339,7 +335,7 @@ void DrawViewShell::FuPermanent(SfxRequest& rReq)
                                       String(SdResId(STR_ASK_FOR_CONVERT_TO_BEZIER) )
                                       ).Execute() == RET_YES )
                     {
-                        // Implizite Wandlung in Bezier
+                        // implicit transformation into bezier
                         WaitObject aWait( (Window*)GetActiveWindow() );
                         mpDrawView->ConvertMarkedToPathObj(sal_False);
                     }
@@ -376,7 +372,7 @@ void DrawViewShell::FuPermanent(SfxRequest& rReq)
                                       String(SdResId(STR_ASK_FOR_CONVERT_TO_BEZIER) )
                                       ).Execute() == RET_YES )
                     {
-                        // Implizite Wandlung in Bezier
+                        // implicit transformation into bezier
                         WaitObject aWait( (Window*)GetActiveWindow() );
                         mpDrawView->ConvertMarkedToPathObj(sal_False);
                     }
@@ -560,8 +556,8 @@ void DrawViewShell::FuPermanent(SfxRequest& rReq)
         SetHelpId( GetCurrentFunction()->GetSlotID() );
     }
 
-    // Shell wird invalidiert, schneller als einzeln (laut MI)
-    // Jetzt explizit der letzte Slot incl. Update()
+    // invalidate shell, is faster than every individually (says MI)
+    // now explicit the last slot incl. Update()
     Invalidate();
 
     // CTRL-SID_OBJECT_SELECT -> select first draw object if none is selected yet
@@ -631,18 +627,13 @@ void DrawViewShell::FuPermanent(SfxRequest& rReq)
 // service routine for Undo/Redo implementation
 extern SfxUndoManager* ImpGetUndoManagerFromViewShell(DrawViewShell& rDViewShell);
 
-/*************************************************************************
-|*
-|* SfxRequests fuer Support-Funktionen
-|*
-\************************************************************************/
 
 void DrawViewShell::FuSupport(SfxRequest& rReq)
 {
     if( rReq.GetSlot() == SID_STYLE_FAMILY && rReq.GetArgs())
         GetDocSh()->SetStyleFamily(((SfxUInt16Item&)rReq.GetArgs()->Get( SID_STYLE_FAMILY )).GetValue());
 
-    // Waehrend einer Native-Diashow wird nichts ausgefuehrt!
+    // We do not execute a thing during a native slide show
     if(SlideShow::IsRunning(GetViewShellBase()) &&
         (rReq.GetSlot() != SID_PRESENTATION_END &&
          rReq.GetSlot() != SID_SIZE_PAGE))
@@ -655,7 +646,7 @@ void DrawViewShell::FuSupport(SfxRequest& rReq)
 
     sal_uInt16 nSId = rReq.GetSlot();
 
-    // Slot wird evtl. gemapped (ToolboxImages/-Slots)
+    // maybe we map the slot (ToolboxImages/-Slots)
     MapSlot( nSId );
 
     switch ( nSId )
@@ -667,7 +658,7 @@ void DrawViewShell::FuSupport(SfxRequest& rReq)
         }
         break;
 
-        // Slots der ToolboxController gemapped ausfuehren
+        // execute slots of ToolboxController mapped
         case SID_OBJECT_CHOOSE_MODE:
         case SID_POSITION:
         case SID_OBJECT_ALIGN:
@@ -718,7 +709,7 @@ void DrawViewShell::FuSupport(SfxRequest& rReq)
             mpDrawView->SetFrameDragSingles(!mpDrawView->IsFrameDragSingles());
 
             /******************************************************************
-            * ObjectBar einschalten
+            * turn ObjectBar on
             ******************************************************************/
             if( dynamic_cast< FuSelection* >( GetCurrentFunction().get() ) || dynamic_cast< FuConstructBezierPolygon* >( GetCurrentFunction().get() ) )
             {
@@ -911,7 +902,7 @@ void DrawViewShell::FuSupport(SfxRequest& rReq)
         case SID_NOTES_MASTERPAGE:    // BASIC
         case SID_HANDOUT_MASTERPAGE:  // BASIC
         {
-            // AutoLayouts muessen fertig sein
+            // AutoLayouts needs to be finished
             GetDoc()->StopWorkStartupDelay();
 
             const SfxItemSet* pReqArgs = rReq.GetArgs();
@@ -934,7 +925,7 @@ void DrawViewShell::FuSupport(SfxRequest& rReq)
                 if (nSId == SID_TITLE_MASTERPAGE ||
                     nSId == SID_SLIDE_MASTERPAGE)
                 {
-                    // Gibt es eine Seite mit dem AutoLayout "Titel"?
+                    // Is there a page with the AutoLayout "Title"?
                     sal_Bool bFound = sal_False;
                     sal_uInt16 i = 0;
                     sal_uInt16 nCount = GetDoc()->GetSdPageCount(PK_STANDARD);
@@ -958,7 +949,7 @@ void DrawViewShell::FuSupport(SfxRequest& rReq)
                     }
                 }
 
-                // Default-Layer der MasterPage einschalten
+                // turn on default layer of MasterPage
                 mpDrawView->SetActiveLayer( String( SdResId(STR_LAYER_BCKGRNDOBJ) ) );
 
                 ChangeEditMode(EM_MASTERPAGE, mbIsLayerModeActive);
@@ -1159,8 +1150,8 @@ void DrawViewShell::FuSupport(SfxRequest& rReq)
         }
         break;
 
-        // Namensverwirrung: SID_SIZE_OPTIMAL -> Zoom auf selektierte Objekte
-        // --> Wird als Objektzoom im Programm angeboten
+        // name confusion: SID_SIZE_OPTIMAL -> Zoom onto selected objects
+        // --> Is offered as object zoom in program
         case SID_SIZE_OPTIMAL:  // BASIC
         {
             mbZoomOnPage = sal_False;
@@ -1189,8 +1180,8 @@ void DrawViewShell::FuSupport(SfxRequest& rReq)
         }
         break;
 
-        // Namensverwirrung: SID_SIZE_ALL -> Zoom auf alle Objekte
-        // --> Wird als Optimal im Programm angeboten
+        // name confusion: SID_SIZE_ALL -> Zoom onto all objects
+        // --> Is offered as optimal in program
         case SID_SIZE_ALL:  // BASIC
         {
             mbZoomOnPage = sal_False;
@@ -1232,7 +1223,7 @@ void DrawViewShell::FuSupport(SfxRequest& rReq)
 
             if (mpZoomList->IsPreviousPossible())
             {
-                // Vorheriges ZoomRect einstellen
+                // set previous ZoomRect
                 SetZoomRect(mpZoomList->GetPreviousZoomRect());
             }
             rReq.Done ();
@@ -1249,7 +1240,7 @@ void DrawViewShell::FuSupport(SfxRequest& rReq)
 
             if (mpZoomList->IsNextPossible())
             {
-                // Naechstes ZoomRect einstellen
+                // set next ZoomRect
                 SetZoomRect(mpZoomList->GetNextZoomRect());
             }
             rReq.Done ();
@@ -1487,11 +1478,6 @@ void DrawViewShell::FuSupportRotate(SfxRequest &rReq)
     }
 }
 
-/*************************************************************************
-|*
-|* URL-Feld einfuegen
-|*
-\************************************************************************/
 
 void DrawViewShell::InsertURLField(const String& rURL, const String& rText,
                                      const String& rTarget, const Point* pPos)
@@ -1551,11 +1537,6 @@ void DrawViewShell::InsertURLField(const String& rURL, const String& rText,
     }
 }
 
-/*************************************************************************
-|*
-|* URL-Button einfuegen
-|*
-\************************************************************************/
 
 void DrawViewShell::InsertURLButton(const String& rURL, const String& rText,
                                       const String& rTarget, const Point* pPos)
diff --git a/sd/source/ui/view/drviewsf.cxx b/sd/source/ui/view/drviewsf.cxx
index 2bd3b4eeac5a..aa5ced7823f0 100644
--- a/sd/source/ui/view/drviewsf.cxx
+++ b/sd/source/ui/view/drviewsf.cxx
@@ -63,17 +63,14 @@ using namespace ::com::sun::star;
 
 namespace sd {
 
-/*************************************************************************
-|*
-|* Status von Controller-SfxSlots setzen
-|*
-\************************************************************************/
-
+/**
+ * Set state of controller SfxSlots
+ */
 void DrawViewShell::GetCtrlState(SfxItemSet &rSet)
 {
     if (rSet.GetItemState(SID_RELOAD) != SFX_ITEM_UNKNOWN)
     {
-        // "Letzte Version" vom SFx en/disablen lassen
+        // let "last version" of SFx en/disable
         GetViewFrame()->GetSlotState (SID_RELOAD, NULL, &rSet);
     }
 
@@ -181,7 +178,7 @@ void DrawViewShell::GetCtrlState(SfxItemSet &rSet)
     }
     rSet.Put( SfxBoolItem( SID_READONLY_MODE, mbReadOnly ) );
 
-    // Ausgabequalitaet
+    // output quality
     if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_OUTPUT_QUALITY_COLOR ) ||
         SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_OUTPUT_QUALITY_GRAYSCALE ) ||
         SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_OUTPUT_QUALITY_BLACKWHITE ) ||
@@ -265,11 +262,6 @@ void DrawViewShell::GetCtrlState(SfxItemSet &rSet)
 }
 
 
-/*************************************************************************
-|*
-|* Status der Attribut-Items
-|*
-\************************************************************************/
 
 void DrawViewShell::GetAttrState( SfxItemSet& rSet )
 {
@@ -398,8 +390,8 @@ void DrawViewShell::GetAttrState( SfxItemSet& rSet )
 
             case SID_STYLE_NEW_BY_EXAMPLE:
             {
-                // PseudoStyleSheets koennen nicht 'by Example' erzeugt werden;
-                // normale StyleSheets brauchen dafuer ein selektiertes Objekt
+                // It is not possible to create PseudoStyleSheets 'by Example';
+                // normal style sheets need a selected object for that
                 ISfxTemplateCommon* pTemplCommon = SFX_APP()->GetCurrentTemplateCommon(GetViewFrame()->GetBindings());
                 if (pTemplCommon)
                 {
@@ -415,9 +407,8 @@ void DrawViewShell::GetAttrState( SfxItemSet& rSet )
                         }
                     }
                 }
-                // falls (noch) kein Gestalter da ist, muessen wir uns auf den
-                // View-Zustand zurueckziehen; eine aktuell eingestellte Familie
-                // kann nicht beruecksichtigt werden
+                // if there is no (yet) a designer, we have to go back into the
+                // view state; an actual set family can not be considered
                 else
                 {
                     if (!mpDrawView->AreObjectsMarked())
@@ -452,11 +443,11 @@ void DrawViewShell::GetAttrState( SfxItemSet& rSet )
 
     rSet.Put( aAllSet, sal_False );
 
-    // Flaechen und/oder Linienattribute wurden geaendert
+    // there were changes at area and/or line attributes
     if( bAttr && pSet )
     {
-        // Wenn die View selektierte Objekte besitzt, muessen entspr. Items
-        // von SFX_ITEM_DEFAULT (_ON) auf SFX_ITEM_DISABLED geaendert werden
+        // if the view owns selected objects, corresponding items have to be
+        // changed from SFX_ITEM_DEFAULT (_ON) to SFX_ITEM_DISABLED
         if( mpDrawView->AreObjectsMarked() )
         {
             SfxWhichIter aNewIter( *pSet, XATTR_LINE_FIRST, XATTR_FILL_LAST );
@@ -477,11 +468,6 @@ void DrawViewShell::GetAttrState( SfxItemSet& rSet )
 }
 
 
-/*************************************************************************
-|*
-|* Text der Selektion zurueckgeben
-|*
-\************************************************************************/
 
 String DrawViewShell::GetSelectionText(sal_Bool bCompleteWords)
 {
@@ -509,11 +495,6 @@ String DrawViewShell::GetSelectionText(sal_Bool bCompleteWords)
     return (aStrSelection);
 }
 
-/*************************************************************************
-|*
-|* Ist etwas selektiert?
-|*
-\************************************************************************/
 
 sal_Bool DrawViewShell::HasSelection(sal_Bool bText) const
 {
diff --git a/sd/source/ui/view/drviewsg.cxx b/sd/source/ui/view/drviewsg.cxx
index eee39f0ba3ef..3de6c84f636a 100644
--- a/sd/source/ui/view/drviewsg.cxx
+++ b/sd/source/ui/view/drviewsg.cxx
@@ -48,7 +48,7 @@ namespace sd {
 
 void DrawViewShell::ExecIMap( SfxRequest& rReq )
 {
-    // waehrend einer Diashow wird nichts ausgefuehrt!
+    // during a slide show, nothing is executed!
     if(HasCurrentFunction(SID_PRESENTATION) )
         return;
 
@@ -103,15 +103,10 @@ void DrawViewShell::GetIMapState( SfxItemSet& rSet )
     rSet.Put( SfxBoolItem( SID_IMAP_EXEC, bDisable ) );
 }
 
-/*************************************************************************
-|*
-|*  Execute-Methode der Optionsleiste
-|*
-\************************************************************************/
 
 void DrawViewShell::ExecOptionsBar( SfxRequest& rReq )
 {
-    // waehrend einer Diashow wird nichts ausgefuehrt!
+    // during a slide show, nothing is executed!
     if(HasCurrentFunction(SID_PRESENTATION))
         return;
 
@@ -127,8 +122,8 @@ void DrawViewShell::ExecOptionsBar( SfxRequest& rReq )
         break;
 
 
-        // Raster- / Hilfslinien-Optionen
-        case SID_GRID_VISIBLE: // noch nicht hier !
+        // Grid- / Help lines option
+        case SID_GRID_VISIBLE: // not here yet!
         {
             pOptions->SetGridVisible( !mpDrawView->IsGridVisible() );
         }
@@ -140,7 +135,7 @@ void DrawViewShell::ExecOptionsBar( SfxRequest& rReq )
         }
         break;
 
-        case SID_HELPLINES_VISIBLE: // noch nicht hier !
+        case SID_HELPLINES_VISIBLE: // not here yet!
         {
             pOptions->SetHelplines( !mpDrawView->IsHlplVisible() );
         }
@@ -212,7 +207,7 @@ void DrawViewShell::ExecOptionsBar( SfxRequest& rReq )
     {
         pOptions->StoreConfig();
 
-        // Speichert die Konfiguration SOFORT
+        // Saves the configuration IMMEDIATELY
         // SFX_APP()->SaveConfiguration();
         WriteFrameViewData();
 
@@ -226,11 +221,6 @@ void DrawViewShell::ExecOptionsBar( SfxRequest& rReq )
 }
 
 
-/*************************************************************************
-|*
-|*  State-Methode der Optionsleiste
-|*
-\************************************************************************/
 
 void DrawViewShell::GetOptionsBarState( SfxItemSet& rSet )
 {
diff --git a/sd/source/ui/view/drviewsh.cxx b/sd/source/ui/view/drviewsh.cxx
index fc2f47b143bf..f7fcb2a5df9f 100644
--- a/sd/source/ui/view/drviewsh.cxx
+++ b/sd/source/ui/view/drviewsh.cxx
@@ -47,11 +47,6 @@ namespace sd {
 
 #define TABCONTROL_INITIAL_SIZE     500
 
-/*************************************************************************
-|*
-|* Sprung zu Bookmark
-|*
-\************************************************************************/
 
 sal_Bool DrawViewShell::GotoBookmark(const String& rBookmark)
 {
@@ -66,9 +61,8 @@ sal_Bool DrawViewShell::GotoBookmark(const String& rBookmark)
     return bRet;
 }
 
-/*************************************************************************
-|*
-|* Bereich sichtbar machen (Bildausschnitt scrollen)
+/**
+ * Make area visible (scroll part of picture)
 |*
 \************************************************************************/
 
@@ -88,20 +82,20 @@ void DrawViewShell::MakeVisible(const Rectangle& rRect, ::Window& rWin)
     sal_Bool bZoomAllowed(sal_False);
     Size aLogicSize(rRect.GetSize());
 
-    // Sichtbarer Bereich
+    // visible area
     Size aVisSizePixel(rWin.GetOutputSizePixel());
     Rectangle aVisArea(rWin.PixelToLogic(Rectangle(Point(0,0), aVisSizePixel)));
     Size aVisAreaSize(aVisArea.GetSize());
 
     if(!aVisArea.IsInside(rRect) && !SlideShow::IsRunning( GetViewShellBase() ) )
     {
-        // Objekt liegt nicht komplett im sichtbaren Bereich
+        // object is not entirely in visible area
         sal_Int32 nFreeSpaceX(aVisAreaSize.Width() - aLogicSize.Width());
         sal_Int32 nFreeSpaceY(aVisAreaSize.Height() - aLogicSize.Height());
 
         if(bZoomAllowed && (nFreeSpaceX < 0 || nFreeSpaceY < 0))
         {
-            // Objekt passt nicht in sichtbaren Bereich -> auf Objektgroesse zoomen
+            // object does not fit into visible area -> zoom to object size
             SetZoomRect(rRect);
         }
         else
diff --git a/sd/source/ui/view/drviewsi.cxx b/sd/source/ui/view/drviewsi.cxx
index ab9cc791e105..c64484fa5dd3 100644
--- a/sd/source/ui/view/drviewsi.cxx
+++ b/sd/source/ui/view/drviewsi.cxx
@@ -59,12 +59,9 @@ namespace sd {
 
 #define ITEMVALUE(ItemSet,Id,Cast)  ((const Cast&)(ItemSet).Get(Id)).GetValue()
 
-/*************************************************************************
-|*
-|* SfxRequests fuer EffekteWindow bearbeiten
-|*
-\************************************************************************/
-
+/**
+ * Handle SfxRequests for EffekteWindow
+ */
 void DrawViewShell::ExecEffectWin( SfxRequest& rReq )
 {
     CheckLineTo (rReq);
@@ -101,11 +98,6 @@ void DrawViewShell::ExecEffectWin( SfxRequest& rReq )
     }
 }
 
-/*************************************************************************
-|*
-|* 3D - Assign / Update
-|*
-\************************************************************************/
 void DrawViewShell::Update3DWindow()
 {
     sal_uInt16 nId = Svx3DChildWindow::GetChildWindowId();
@@ -139,25 +131,25 @@ void DrawViewShell::AssignFrom3DWindow()
                     0, 0);
                 p3DWin->GetAttr( aSet );
 
-                // Eigene UNDO-Klammerung auch um die Wandlung in 3D
+                // own UNDO-compounding also around transformation in 3D
                 GetView()->BegUndo(String(SdResId(STR_UNDO_APPLY_3D_FAVOURITE)));
 
                 if(GetView()->IsConvertTo3DObjPossible())
                 {
-                    // Nur TextAttribute zuweisen
+                    // assign only text-attribute
                     SfxItemSet aTextSet( GetDoc()->GetPool(),
                         EE_ITEMS_START, EE_ITEMS_END, 0 );
                     aTextSet.Put( aSet, sal_False );
                     GetView()->SetAttributes( aTextSet );
 
-                    // Text in 3D umwandeln
+                    // transform text into 3D
                     sal_uInt16 nSId = SID_CONVERT_TO_3D;
                     SfxBoolItem aItem( nSId, sal_True );
                     GetViewFrame()->GetDispatcher()->Execute(
                         nSId, SFX_CALLMODE_SYNCHRON | SFX_CALLMODE_RECORD, &aItem, 0L );
 
-                    // Feststellen, ob ein FILL_Attribut gesetzt ist.
-                    // Falls nicht, Fuellattribut hart setzen
+                    // Determine if a FILL attribute is set.
+                    // If not, hard set a fill attribut
                     XFillStyle eFillStyle = ITEMVALUE( aSet, XATTR_FILLSTYLE, XFillStyleItem );
                     if(eFillStyle == XFILL_NONE)
                         aSet.Put(XFillStyleItem (XFILL_SOLID));
@@ -170,10 +162,10 @@ void DrawViewShell::AssignFrom3DWindow()
                     aSet.ClearItem(SDRATTR_3DOBJ_DEPTH);
                 }
 
-                // Attribute zuweisen
+                // assign attribute
                 GetView()->Set3DAttributes( aSet );
 
-                // Ende UNDO
+                // end UNDO
                 GetView()->EndUndo();
             }
             else
@@ -184,7 +176,7 @@ void DrawViewShell::AssignFrom3DWindow()
                 aInfoBox.Execute();
             }
 
-            // Focus zurueckholen
+            // get focus back
             GetActiveWindow()->GrabFocus();
         }
     }
diff --git a/sd/source/ui/view/drviewsj.cxx b/sd/source/ui/view/drviewsj.cxx
index 4adee9e9a632..4be97a05403f 100644
--- a/sd/source/ui/view/drviewsj.cxx
+++ b/sd/source/ui/view/drviewsj.cxx
@@ -53,12 +53,9 @@ using namespace com::sun::star;
 
 namespace sd {
 
-/*************************************************************************
-|*
-|* Status (Enabled/Disabled) von Menue-SfxSlots setzen
-|*
-\************************************************************************/
-
+/**
+ * Set state (Enabled/Disabled) of Menu-SfxSlots
+ */
 void DrawViewShell::GetMenuStateSel( SfxItemSet &rSet )
 {
     // Status of menu entries (Buttons,...)
@@ -134,16 +131,15 @@ void DrawViewShell::GetMenuStateSel( SfxItemSet &rSet )
                 rSet.DisableItem(SID_COMPRESS_GRAPHIC);
             }
 
-            // Wenn es sich um kein Gruppenobjekt oder 3D-Objekt handelt
-            // wird "Gruppe betreten" disabled
+            /* If it is not a group object or 3D object, we disable "enter
+               group". */
             if( !( ( pObj->ISA( SdrObjGroup ) && nInv == SdrInventor ) ||
                 (pObj->ISA (E3dPolyScene) || pObj->ISA (E3dScene) /*|| pObj->ISA (E3dCompoundObject) */) ) )
             {
                 rSet.DisableItem( SID_ENTER_GROUP );
             }
 
-            // Wenn es sich um kein Gruppenobjekt handelt
-            // wird "Gruppierung aufheben" disabled
+            // If it is not a group object, we disable "ungroup"
             if (!(pObj->ISA(SdrObjGroup) && nInv == SdrInventor))
             {
                 rSet.DisableItem(SID_UNGROUP);
@@ -168,11 +164,11 @@ void DrawViewShell::GetMenuStateSel( SfxItemSet &rSet )
                 nId == OBJ_PATHLINE ||
                 nId == OBJ_FREELINE ))
             {
-                //rSet.DisableItem( SID_ATTRIBUTES_AREA ); // wieder raus!
+                //rSet.DisableItem( SID_ATTRIBUTES_AREA ); // remove again!
                 rSet.DisableItem( SID_ATTR_FILL_STYLE );
             }
-            if( (!pObj->ISA( SdrPathObj ) && !aInfoRec.bCanConvToPath) || pObj->ISA( SdrObjGroup ) ) // Solange es JOE fehlerhaft behandelt!
-            { // JOE: Ein Gruppenobjekt kann eben u.U. in ein PathObj gewandelt werden
+            if( (!pObj->ISA( SdrPathObj ) && !aInfoRec.bCanConvToPath) || pObj->ISA( SdrObjGroup ) ) // As long as JOE handles it incorrectly!
+            { // JOE: a group object may can be converted into a PathObj
                 rSet.DisableItem( SID_LINEEND_POLYGON );
             }
             if(nInv == SdrInventor &&
@@ -293,7 +289,7 @@ void DrawViewShell::GetMenuStateSel( SfxItemSet &rSet )
         rSet.DisableItem(SID_POLY_INTERSECT);
         rSet.DisableItem( SID_CONNECT );
     }
-    // Mehrfachselektion
+    // multi-selection
     else if( nMarkCount > 1 )
     {
         // distribure dialog for 3+n objects
@@ -302,7 +298,7 @@ void DrawViewShell::GetMenuStateSel( SfxItemSet &rSet )
 
         rSet.DisableItem( SID_LINEEND_POLYGON );
         rSet.DisableItem( SID_ENTER_GROUP );
-        // Jetzt muessen Namen fuer Objekte eindeutig sein
+        // Now names for objects have to be unique
         rSet.DisableItem( SID_NAME_GROUP );
         // #i68101#
         rSet.DisableItem( SID_OBJECT_TITLE_DESCRIPTION );
@@ -457,7 +453,7 @@ void DrawViewShell::GetMenuStateSel( SfxItemSet &rSet )
             rSet.DisableItem( SID_UNGROUP );
         }
     }
-    // kein Objekt selektiert
+    // select no object
     else
     {
         rSet.DisableItem( SID_ENTER_GROUP );
diff --git a/sd/source/ui/view/drvwshrg.cxx b/sd/source/ui/view/drvwshrg.cxx
index 45919ff92ad2..384ffa0e803b 100644
--- a/sd/source/ui/view/drvwshrg.cxx
+++ b/sd/source/ui/view/drvwshrg.cxx
@@ -57,11 +57,9 @@ using namespace sd;
 
 namespace sd {
 
-/*************************************************************************
-|*
-|* SFX-Slotmap und Standardinterface deklarieren
-|*
-\************************************************************************/
+/**
+ * Declare SFX-Slotmap and Standardinterface
+ */
 
 
 SFX_IMPL_INTERFACE(DrawViewShell, SfxShell, SdResId(STR_DRAWVIEWSHELL))
diff --git a/sd/source/ui/view/frmview.cxx b/sd/source/ui/view/frmview.cxx
index 080e668c584e..cc563af5f3f7 100644
--- a/sd/source/ui/view/frmview.cxx
+++ b/sd/source/ui/view/frmview.cxx
@@ -51,11 +51,6 @@ using ::rtl::OUString;
 
 namespace sd {
 
-/*************************************************************************
-|*
-|* Ctor
-|*
-\************************************************************************/
 
 FrameView::FrameView(SdDrawDocument* pDrawDoc, FrameView* pFrameView /* = NULK */)
   : SdrView(pDrawDoc, (OutputDevice*) NULL),
@@ -82,9 +77,7 @@ FrameView::FrameView(SdDrawDocument* pDrawDoc, FrameView* pFrameView /* = NULK *
 
         if ( pDocShell )
         {
-            /**********************************************************************
-            * Das Dokument wurde geladen, ist eine FrameView vorhanden?
-            **********************************************************************/
+            // document is loaded, is there a FrameView?
             sal_uLong nSdViewShellCount = 0;
             ViewShellBase* pBase = NULL;
             SfxViewShell* pSfxViewSh = NULL;
@@ -139,9 +132,7 @@ FrameView::FrameView(SdDrawDocument* pDrawDoc, FrameView* pFrameView /* = NULK *
 
     if (pFrameView)
     {
-        /**********************************************************************
-        * FrameView mit der FrameView der DocShell initialisieren
-        **********************************************************************/
+        // initialize FrameView with the FrameView of the DocShell
         SetRuler( pFrameView->HasRuler() );
         SetGridCoarse( pFrameView->GetGridCoarse() );
         SetGridFine( pFrameView->GetGridFine() );
@@ -210,9 +201,7 @@ FrameView::FrameView(SdDrawDocument* pDrawDoc, FrameView* pFrameView /* = NULK *
     }
     else
     {
-        /**********************************************************************
-        * FrameView mit den Applikationsdaten initialisieren
-        **********************************************************************/
+        // initialize FrameView with the application data
         maVisibleLayers.SetAll();
         maPrintableLayers.SetAll();
         SetGridCoarse( Size( 1000, 1000 ) );
@@ -261,22 +250,12 @@ FrameView::FrameView(SdDrawDocument* pDrawDoc, FrameView* pFrameView /* = NULK *
 
 }
 
-/*************************************************************************
-|*
-|* Dtor
-|*
-\************************************************************************/
 
 FrameView::~FrameView()
 {
 }
 
 
-/*************************************************************************
-|*
-|* Verbindung herstellen
-|*
-\************************************************************************/
 
 void FrameView::Connect()
 {
@@ -284,11 +263,6 @@ void FrameView::Connect()
 }
 
 
-/*************************************************************************
-|*
-|* Verbindung loesen
-|*
-\************************************************************************/
 
 void FrameView::Disconnect()
 {
@@ -303,12 +277,9 @@ void FrameView::Disconnect()
     }
 }
 
-/*************************************************************************
-|*
-|* Update mit Daten der SdOptions
-|*
-\************************************************************************/
-
+/**
+ * Update with data from the specified SdOptions
+ */
 void FrameView::Update(SdOptions* pOptions)
 {
     if (pOptions)
@@ -355,12 +326,9 @@ void FrameView::Update(SdOptions* pOptions)
 }
 
 
-/*************************************************************************
-|*
-|* EditMode (Page oder MasterPage) des Arbeitsmodus setzen
-|*
-\************************************************************************/
-
+/**
+ * Set EditMode (Page or MasterPage) of working mode
+ */
 void FrameView::SetViewShEditMode(EditMode eMode, PageKind eKind)
 {
     if (eKind == PK_STANDARD)
@@ -378,12 +346,9 @@ void FrameView::SetViewShEditMode(EditMode eMode, PageKind eKind)
 }
 
 
-/*************************************************************************
-|*
-|* EditMode (Page oder MasterPage) des Arbeitsmodus zurueckgeben
-|*
-\************************************************************************/
-
+/**
+ * Return EditMode (Page or MasterPage) of working mode
+ */
 EditMode FrameView::GetViewShEditMode(PageKind eKind)
 {
     EditMode eMode = EM_PAGE;
diff --git a/sd/source/ui/view/grviewsh.cxx b/sd/source/ui/view/grviewsh.cxx
index 1f7264bf2fd6..fd36400f7031 100644
--- a/sd/source/ui/view/grviewsh.cxx
+++ b/sd/source/ui/view/grviewsh.cxx
@@ -30,11 +30,6 @@ namespace sd {
 
 static const int TABCONTROL_INITIAL_SIZE = 350;
 
-/*************************************************************************
-|*
-|* Standard-Konstruktor
-|*
-\************************************************************************/
 
 GraphicViewShell::GraphicViewShell (
     SfxViewFrame* pFrame,
diff --git a/sd/source/ui/view/outlnvs2.cxx b/sd/source/ui/view/outlnvs2.cxx
index a514bb20ead7..d98589a1e3cd 100644
--- a/sd/source/ui/view/outlnvs2.cxx
+++ b/sd/source/ui/view/outlnvs2.cxx
@@ -70,11 +70,9 @@ namespace sd {
 
 /************************************************************************/
 
-/*************************************************************************
-|*
-|* SfxRequests for temporary functions
-|*
-\************************************************************************/
+/**
+ * SfxRequests for temporary functions
+ */
 
 void OutlineViewShell::FuTemporary(SfxRequest &rReq)
 {
diff --git a/sd/source/ui/view/outlnvsh.cxx b/sd/source/ui/view/outlnvsh.cxx
index 9e182c5a754a..1da13815f082 100644
--- a/sd/source/ui/view/outlnvsh.cxx
+++ b/sd/source/ui/view/outlnvsh.cxx
@@ -102,13 +102,9 @@ namespace sd {
 /************************************************************************/
 
 
-/*************************************************************************
-|*
-|* Declare SFX-Slotmap and standard interface
-|*
-\************************************************************************/
-
-
+/**
+ * Declare SFX-Slotmap and standard interface
+ */
 SFX_IMPL_INTERFACE(OutlineViewShell, SfxShell, SdResId(STR_OUTLINEVIEWSHELL))
 {
     SFX_POPUPMENU_REGISTRATION( SdResId(RID_OUTLINE_POPUP) );
@@ -128,12 +124,9 @@ SFX_IMPL_INTERFACE(OutlineViewShell, SfxShell, SdResId(STR_OUTLINEVIEWSHELL))
 TYPEINIT1( OutlineViewShell, ViewShell );
 
 
-/*************************************************************************
-|*
-|* common initialization part of both constructors
-|*
-\************************************************************************/
-
+/**
+ * common initialization part of both constructors
+ */
 void OutlineViewShell::Construct(DrawDocShell* )
 {
     sal_Bool bModified = GetDoc()->IsChanged();
@@ -192,14 +185,9 @@ Reference<drawing::XDrawSubController> OutlineViewShell::CreateSubController (vo
 }
 
 
-
-
-/*************************************************************************
-|*
-|* Default constructor, windows must not center themselves automatically
-|*
-\************************************************************************/
-
+/**
+ * Default constructor, windows must not center themselves automatically
+ */
 OutlineViewShell::OutlineViewShell (
     SfxViewFrame* pFrame,
     ViewShellBase& rViewShellBase,
@@ -225,11 +213,6 @@ OutlineViewShell::OutlineViewShell (
     doShow();
 }
 
-/*************************************************************************
-|*
-|* Destructor
-|*
-\************************************************************************/
 
 OutlineViewShell::~OutlineViewShell()
 {
@@ -260,13 +243,10 @@ void OutlineViewShell::Shutdown (void)
 
 
 
-/*************************************************************************
-|*
-|* Paint method: the event gets forwarded from pWindow to the Viewshell
-|* and the current function
-|*
-\************************************************************************/
-
+/**
+ * Paint method: the event gets forwarded from pWindow to the Viewshell
+ * and the current function
+ */
 void OutlineViewShell::Paint(const Rectangle& rRect, ::sd::Window* pWin)
 {
     if (pOlView)
@@ -320,12 +300,9 @@ void OutlineViewShell::ArrangeGUIElements ()
     }
 }
 
-/*************************************************************************
-|*
-|* Handle SfxRequest for the Controller
-|*
-\************************************************************************/
-
+/**
+ * Handle SfxRequest for the Controller
+ */
 void OutlineViewShell::ExecCtrl(SfxRequest &rReq)
 {
     sal_uInt16 nSlot = rReq.GetSlot();
@@ -369,11 +346,9 @@ void OutlineViewShell::RemoveWindow (::sd::Window* pWin)
 
 
 
-/*************************************************************************
-|*
-|* Activate(): during the first invocation the fields get updated
-|*
-\************************************************************************/
+/**
+ * Activate(): during the first invocation the fields get updated
+ */
 void OutlineViewShell::Activate( sal_Bool bIsMDIActivate )
 {
     if ( ! mbInitialized)
@@ -395,11 +370,6 @@ void OutlineViewShell::Activate( sal_Bool bIsMDIActivate )
     }
 }
 
-/*************************************************************************
-|*
-|* Deactivate()
-|*
-\************************************************************************/
 void OutlineViewShell::Deactivate( sal_Bool bIsMDIActivate )
 {
     pOlView->DisconnectFromApplication();
@@ -409,11 +379,9 @@ void OutlineViewShell::Deactivate( sal_Bool bIsMDIActivate )
     ViewShell::Deactivate( bIsMDIActivate );
 }
 
-/*************************************************************************
-|*
-|* Set status of Controller-SfxSlots
-|*
-\************************************************************************/
+/**
+ * Set status of Controller-SfxSlots
+ */
 void OutlineViewShell::GetCtrlState(SfxItemSet &rSet)
 {
     if (SFX_ITEM_AVAILABLE == rSet.GetItemState(SID_HYPERLINK_GETLINK))
@@ -473,12 +441,9 @@ void OutlineViewShell::GetCtrlState(SfxItemSet &rSet)
     }
 }
 
-/*************************************************************************
-|*
-|* SfxRequests for support functions
-|*
-\************************************************************************/
-
+/**
+ * SfxRequests for support functions
+ */
 void OutlineViewShell::FuSupport(SfxRequest &rReq)
 {
     if( rReq.GetSlot() == SID_STYLE_FAMILY && rReq.GetArgs())
@@ -705,12 +670,9 @@ void OutlineViewShell::FuSupport(SfxRequest &rReq)
     Invalidate(SID_PASTE);
 }
 
-/*************************************************************************
-|*
-|* SfxRequests for permanent functions
-|*
-\************************************************************************/
-
+/**
+ * SfxRequests for permanent functions
+ */
 void OutlineViewShell::FuPermanent(SfxRequest &rReq)
 {
     if(HasCurrentFunction())
@@ -770,12 +732,9 @@ IMPL_LINK( OutlineViewShell, ClipboardChanged, TransferableDataHelper*, pDataHel
     return 0;
 }
 
-/*************************************************************************
-|*
-|* Set Status (Enabled/Disabled) of Menu-SfxSlots
-|*
-\************************************************************************/
-
+/**
+ * Set Status (Enabled/Disabled) of Menu-SfxSlots
+ */
 void OutlineViewShell::GetMenuState( SfxItemSet &rSet )
 {
     ViewShell::GetMenuState(rSet);
@@ -1122,12 +1081,9 @@ void OutlineViewShell::GetMenuState( SfxItemSet &rSet )
 
 }
 
-/*************************************************************************
-|*
-|* gets invoked when ScrollBar is used
-|*
-\************************************************************************/
-
+/**
+ * gets invoked when ScrollBar is used
+ */
 long OutlineViewShell::VirtHScrollHdl(ScrollBar* pHScroll)
 {
     long   nThumb = pHScroll->GetThumbPos();
@@ -1177,13 +1133,10 @@ long OutlineViewShell::VirtVScrollHdl(ScrollBar* pVScroll)
     return 0;
 }
 
-/*************************************************************************
-|*
-|* PrepareClose, gets called when the Shell shall be destroyed.
-|* Forwards the invocation to the View
-|*
-\************************************************************************/
-
+/**
+ * PrepareClose, gets called when the Shell shall be destroyed.
+ * Forwards the invocation to the View
+ */
 sal_uInt16 OutlineViewShell::PrepareClose( sal_Bool bUI, sal_Bool bForBrowsing )
 {
     if( ViewShell::PrepareClose(bUI, bForBrowsing) != sal_True )
@@ -1193,12 +1146,9 @@ sal_uInt16 OutlineViewShell::PrepareClose( sal_Bool bUI, sal_Bool bForBrowsing )
 }
 
 
-/*************************************************************************
-|*
-|* Zoom with zoom factor. Inform OutlinerView
-|*
-\************************************************************************/
-
+/**
+ * Zoom with zoom factor. Inform OutlinerView
+ */
 void OutlineViewShell::SetZoom(long nZoom)
 {
     ViewShell::SetZoom(nZoom);
@@ -1217,12 +1167,9 @@ void OutlineViewShell::SetZoom(long nZoom)
     GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOMSLIDER );
 }
 
-/*************************************************************************
-|*
-|* Zoom with zoom rectangle. Inform OutlinerView
-|*
-\************************************************************************/
-
+/**
+ * Zoom with zoom rectangle. Inform OutlinerView
+ */
 void OutlineViewShell::SetZoomRect(const Rectangle& rZoomRect)
 {
     ViewShell::SetZoomRect(rZoomRect);
@@ -1241,13 +1188,10 @@ void OutlineViewShell::SetZoomRect(const Rectangle& rZoomRect)
     GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOMSLIDER );
 }
 
-/*************************************************************************
-|*
-|* Before saving: Update Model of the Drawing Engine, then forward the
-|* invocation to the ObjectShell.
-|*
-\************************************************************************/
-
+/**
+ * Before saving: Update Model of the Drawing Engine, then forward the
+ * invocation to the ObjectShell.
+ */
 void OutlineViewShell::Execute(SfxRequest& rReq)
 {
     bool bForwardCall = true;
@@ -1293,12 +1237,9 @@ void OutlineViewShell::Execute(SfxRequest& rReq)
         ((DrawDocShell*)GetViewFrame()->GetObjectShell())->ExecuteSlot( rReq );
 }
 
-/*************************************************************************
-|*
-|* Read FrameViews data and set actual views data
-|*
-\************************************************************************/
-
+/**
+ * Read FrameViews data and set actual views data
+ */
 void OutlineViewShell::ReadFrameViewData(FrameView* pView)
 {
     ::Outliner* pOutl = pOlView->GetOutliner();
@@ -1319,12 +1260,9 @@ void OutlineViewShell::ReadFrameViewData(FrameView* pView)
 
 
 
-/*************************************************************************
-|*
-|* Write actual views data to FrameView
-|*
-\************************************************************************/
-
+/**
+ * Write actual views data to FrameView
+ */
 void OutlineViewShell::WriteFrameViewData()
 {
     ::Outliner* pOutl = pOlView->GetOutliner();
@@ -1342,21 +1280,13 @@ void OutlineViewShell::WriteFrameViewData()
 }
 
 
-/*************************************************************************
-|*
-|* Handle SfxRequests for the StatusBar
-|*
-\************************************************************************/
-
+/**
+ * Handle SfxRequests for the StatusBar
+ */
 void OutlineViewShell::ExecStatusBar(SfxRequest&)
 {
 }
 
-/*************************************************************************
-|*
-|* Return state values of the StatusBar
-|*
-\************************************************************************/
 
 void OutlineViewShell::GetStatusBarState(SfxItemSet& rSet)
 {
@@ -1452,11 +1382,6 @@ void OutlineViewShell::GetStatusBarState(SfxItemSet& rSet)
     rSet.Put( SfxStringItem( SID_STATUS_LAYOUT, aLayoutStr ) );
 }
 
-/*************************************************************************
-|*
-|* Command event
-|*
-\************************************************************************/
 
 void OutlineViewShell::Command( const CommandEvent& rCEvt, ::sd::Window* pWin )
 {
@@ -1490,11 +1415,6 @@ void OutlineViewShell::Command( const CommandEvent& rCEvt, ::sd::Window* pWin )
 }
 
 
-/*************************************************************************
-|*
-|* Keyboard event
-|*
-\************************************************************************/
 
 sal_Bool OutlineViewShell::KeyInput(const KeyEvent& rKEvt, ::sd::Window* pWin)
 {
@@ -1534,12 +1454,9 @@ sal_Bool OutlineViewShell::KeyInput(const KeyEvent& rKEvt, ::sd::Window* pWin)
 }
 
 
-/*************************************************************************
-|*
-|* Return text of the selection
-|*
-\************************************************************************/
-
+/**
+ * Return text of the selection
+ */
 String OutlineViewShell::GetSelectionText(sal_Bool bCompleteWords)
 {
     String aStrSelection;
@@ -1567,12 +1484,9 @@ String OutlineViewShell::GetSelectionText(sal_Bool bCompleteWords)
 }
 
 
-/*************************************************************************
-|*
-|* Is something selected?
-|*
-\************************************************************************/
-
+/**
+ * Is something selected?
+ */
 sal_Bool OutlineViewShell::HasSelection(sal_Bool bText) const
 {
     sal_Bool bReturn = sal_False;
@@ -1591,12 +1505,9 @@ sal_Bool OutlineViewShell::HasSelection(sal_Bool bText) const
 }
 
 
-/*************************************************************************
-|*
-|* Status of Attribute-Items
-|*
-\************************************************************************/
-
+/**
+ * Status of Attribute-Items
+ */
 void OutlineViewShell::GetAttrState( SfxItemSet& rSet )
 {
     SfxWhichIter  aIter( rSet );
@@ -1695,11 +1606,6 @@ void OutlineViewShell::GetAttrState( SfxItemSet& rSet )
 
 
 
-/*************************************************************************
-|*
-|* MouseButtonUp event
-|*
-\************************************************************************/
 
 void OutlineViewShell::MouseButtonUp(const MouseEvent& rMEvt, ::sd::Window* pWin)
 {
@@ -1730,12 +1636,10 @@ SdPage* OutlineViewShell::getCurrentPage() const
     return const_cast<OutlineViewShell*>(this)->GetActualPage();
 }
 
-/*************************************************************************
-|*
-|* Returns the first selected page.
-|* If nothing is selected, the first page is returned.
-|*
-\************************************************************************/
+/**
+ * Returns the first selected page.
+ * If nothing is selected, the first page is returned.
+ */
 SdPage* OutlineViewShell::GetActualPage()
 {
     return pOlView->GetActualPage();
@@ -1752,11 +1656,6 @@ void OutlineViewShell::UpdatePreview( SdPage* pPage, sal_Bool )
     }
 }
 
-/*************************************************************************
-|*
-|* Update Title
-|*
-\************************************************************************/
 
 bool OutlineViewShell::UpdateTitleObject( SdPage* pPage, Paragraph* pPara )
 {
@@ -1839,11 +1738,6 @@ bool OutlineViewShell::UpdateTitleObject( SdPage* pPage, Paragraph* pPara )
     return bNewObject;
 }
 
-/*************************************************************************
-|*
-|* Update LayoutObject
-|*
-\************************************************************************/
 
 bool OutlineViewShell::UpdateOutlineObject( SdPage* pPage, Paragraph* pPara )
 {
@@ -1952,12 +1846,9 @@ bool OutlineViewShell::UpdateOutlineObject( SdPage* pPage, Paragraph* pPara )
 }
 
 
-/*************************************************************************
-|*
-|* Fill Outliner from Stream
-|*
-\************************************************************************/
-
+/**
+ * Fill Outliner from Stream
+ */
 sal_uLong OutlineViewShell::Read(SvStream& rInput, const String& rBaseURL, sal_uInt16 eFormat)
 {
     sal_uLong bRet = 0;
diff --git a/sd/source/ui/view/outlview.cxx b/sd/source/ui/view/outlview.cxx
index 8d5f9f31c4a7..9758fc94f57e 100644
--- a/sd/source/ui/view/outlview.cxx
+++ b/sd/source/ui/view/outlview.cxx
@@ -91,11 +91,6 @@ struct SdParaAndPos
 
 TYPEINIT1( OutlineView, ::sd::View );
 
-/*************************************************************************
-|*
-|* Constructor
-|*
-\************************************************************************/
 
 OutlineView::OutlineView( DrawDocShell& rDocSh, ::Window* pWindow, OutlineViewShell& rOutlineViewSh)
 : ::sd::View(*rDocSh.GetDoc(), pWindow, &rOutlineViewSh)
@@ -174,12 +169,9 @@ OutlineView::OutlineView( DrawDocShell& rDocSh, ::Window* pWindow, OutlineViewSh
         pDocUndoMgr->SetLinkedUndoManager(&mrOutliner.GetUndoManager());
 }
 
-/*************************************************************************
-|*
-|* Destructor, restore Links, clear Oultiner
-|*
-\************************************************************************/
-
+/**
+ * Destructor, restore Links, clear Oultiner
+ */
 OutlineView::~OutlineView()
 {
     DBG_ASSERT(maDragAndDropModelGuard.get() == 0, "sd::OutlineView::~OutlineView(), prior drag operation not finished correctly!" );
@@ -235,11 +227,6 @@ void OutlineView::DisconnectFromApplication (void)
 
 
 
-/*************************************************************************
-|*
-|* Paint method
-|*
-\************************************************************************/
 
 void OutlineView::Paint(const Rectangle& rRect, ::sd::Window* pWin)
 {
@@ -260,21 +247,14 @@ void OutlineView::InvalidateSlideNumberArea()
 {
 }
 
-/*************************************************************************
-|*
-|* Window size was changed
-|*
-\************************************************************************/
+/**
+ * Window size was changed
+ */
 
 void OutlineView::AdjustPosSizePixel(const Point &,const Size &,::sd::Window*)
 {
 }
 
-/*************************************************************************
-|*
-|* add a window
-|*
-\************************************************************************/
 
 void OutlineView::AddWindowToPaintView(OutputDevice* pWin)
 {
@@ -313,11 +293,6 @@ void OutlineView::AddWindowToPaintView(OutputDevice* pWin)
     ::sd::View::AddWindowToPaintView(pWin);
 }
 
-/*************************************************************************
-|*
-|* remove a window
-|*
-\************************************************************************/
 
 void OutlineView::DeleteWindowFromPaintView(OutputDevice* pWin)
 {
@@ -346,12 +321,9 @@ void OutlineView::DeleteWindowFromPaintView(OutputDevice* pWin)
     ::sd::View::DeleteWindowFromPaintView(pWin);
 }
 
-/*************************************************************************
-|*
-|* Return a pointer to the OutlinerView corresponding to the window
-|*
-\************************************************************************/
-
+/**
+ * Return a pointer to the OutlinerView corresponding to the window
+ */
 OutlinerView* OutlineView::GetViewByWindow (::Window* pWin) const
 {
     OutlinerView* pOlView = NULL;
@@ -369,12 +341,9 @@ OutlinerView* OutlineView::GetViewByWindow (::Window* pWin) const
 }
 
 
-/*************************************************************************
-|*
-|* Return the title before a random paragraph
-|*
-\************************************************************************/
-
+/**
+ * Return the title before a random paragraph
+ */
 Paragraph* OutlineView::GetPrevTitle(const Paragraph* pPara)
 {
     sal_Int32 nPos = mrOutliner.GetAbsPos(const_cast<Paragraph*>(pPara));
@@ -394,12 +363,9 @@ Paragraph* OutlineView::GetPrevTitle(const Paragraph* pPara)
     return NULL;
 }
 
-/*************************************************************************
-|*
-|* Return the title after a random paragraph
-|*
-\************************************************************************/
-
+/**
+ * Return the title after a random paragraph
+ */
 Paragraph* OutlineView::GetNextTitle(const Paragraph* pPara)
 {
     Paragraph* pResult = const_cast< Paragraph* >( pPara );
@@ -417,12 +383,9 @@ Paragraph* OutlineView::GetNextTitle(const Paragraph* pPara)
     return NULL;
 }
 
-/*************************************************************************
-|*
-|* Handler for inserting pages (paragraphs)
-|*
-\************************************************************************/
-
+/**
+ * Handler for inserting pages (paragraphs)
+ */
 IMPL_LINK( OutlineView, ParagraphInsertedHdl, ::Outliner *, pOutliner )
 {
     // we get calls to this handler during binary insert of drag and drop contents but
@@ -562,12 +525,9 @@ SdPage* OutlineView::InsertSlideForParagraph( Paragraph* pPara )
     return pPage;
 }
 
-/*************************************************************************
-|*
-|* Handler for deleting pages (paragraphs)
-|*
-\************************************************************************/
-
+/**
+ * Handler for deleting pages (paragraphs)
+ */
 IMPL_LINK( OutlineView, ParagraphRemovingHdl, ::Outliner *, pOutliner )
 {
     DBG_ASSERT( isRecordingUndo(), "sd::OutlineView::ParagraphRemovingHdl(), model change without undo?!" );
@@ -625,13 +585,10 @@ IMPL_LINK( OutlineView, ParagraphRemovingHdl, ::Outliner *, pOutliner )
     return 0;
 }
 
-/*************************************************************************
-|*
-|* Handler for changing the indentation depth of paragraphs (requires inserting
-|* or deleting of pages in some cases)
-|*
-\************************************************************************/
-
+/**
+ * Handler for changing the indentation depth of paragraphs (requires inserting
+ * or deleting of pages in some cases)
+ */
 IMPL_LINK( OutlineView, DepthChangedHdl, ::Outliner *, pOutliner )
 {
     DBG_ASSERT( isRecordingUndo(), "sd::OutlineView::DepthChangedHdl(), no undo for model change?!" );
@@ -849,12 +806,9 @@ IMPL_LINK( OutlineView, DepthChangedHdl, ::Outliner *, pOutliner )
     return 0;
 }
 
-/*************************************************************************
-|*
-|* Handler for StatusEvents
-|*
-\************************************************************************/
-
+/**
+ * Handler for StatusEvents
+ */
 IMPL_LINK_NOARG(OutlineView, StatusEventHdl)
 {
     ::sd::Window*   pWin = mrOutlineViewShell.GetActiveWindow();
@@ -895,12 +849,9 @@ IMPL_LINK_NOARG(OutlineView, EndDropHdl)
     return 0;
 }
 
-/*************************************************************************
-|*
-|* Handler for the start of a paragraph movement
-|*
-\************************************************************************/
-
+/**
+ * Handler for the start of a paragraph movement
+ */
 IMPL_LINK( OutlineView, BeginMovingHdl, ::Outliner *, pOutliner )
 {
     OutlineViewPageChangesGuard aGuard(this);
@@ -941,12 +892,9 @@ IMPL_LINK( OutlineView, BeginMovingHdl, ::Outliner *, pOutliner )
     return 0;
 }
 
-/*************************************************************************
-|*
-|* Handler for the end of a paragraph movement
-|*
-\************************************************************************/
-
+/**
+ * Handler for the end of a paragraph movement
+ */
 IMPL_LINK( OutlineView, EndMovingHdl, ::Outliner *, pOutliner )
 {
     OutlineViewPageChangesGuard aGuard(this);
@@ -1013,12 +961,9 @@ IMPL_LINK( OutlineView, EndMovingHdl, ::Outliner *, pOutliner )
     return 0;
 }
 
-/*************************************************************************
-|*
-|* Look for the title text object in one page of the model
-|*
-\************************************************************************/
-
+/**
+ * Look for the title text object in one page of the model
+ */
 SdrTextObj* OutlineView::GetTitleTextObject(SdrPage* pPage)
 {
     sal_uLong           nObjectCount = pPage->GetObjCount();
@@ -1039,12 +984,9 @@ SdrTextObj* OutlineView::GetTitleTextObject(SdrPage* pPage)
 }
 
 
-/*************************************************************************
-|*
-|* Look for the outline text object in one page of the model
-|*
-\************************************************************************/
-
+/**
+ * Look for the outline text object in one page of the model
+ */
 SdrTextObj* OutlineView::GetOutlineTextObject(SdrPage* pPage)
 {
     sal_uLong           nObjectCount = pPage->GetObjCount();
@@ -1137,12 +1079,9 @@ sal_Bool OutlineView::PrepareClose(sal_Bool)
 }
 
 
-/*************************************************************************
-|*
-|* Set attributes of the selected text
-|*
-\************************************************************************/
-
+/**
+ * Set attributes of the selected text
+ */
 sal_Bool OutlineView::SetAttributes(const SfxItemSet& rSet, sal_Bool )
 {
     sal_Bool bOk = sal_False;
@@ -1160,12 +1099,9 @@ sal_Bool OutlineView::SetAttributes(const SfxItemSet& rSet, sal_Bool )
     return (bOk);
 }
 
-/*************************************************************************
-|*
-|* Get attributes of the selected text
-|*
-\************************************************************************/
-
+/**
+ * Get attributes of the selected text
+ */
 sal_Bool OutlineView::GetAttributes( SfxItemSet& rTargetSet, sal_Bool ) const
 {
     OutlinerView* pOlView = GetViewByWindow(
@@ -1280,12 +1216,9 @@ void OutlineView::FillOutliner()
     mrOutliner.SetUpdateMode(true);
 }
 
-/*************************************************************************
-|*
-|* Handler for deleting of level 0 paragraphs (pages): Warning
-|*
-\************************************************************************/
-
+/**
+ * Handler for deleting of level 0 paragraphs (pages): Warning
+ */
 IMPL_LINK_NOARG(OutlineView, RemovingPagesHdl)
 {
     sal_uInt16 nNumOfPages = mrOutliner.GetSelPageCount();
@@ -1311,12 +1244,9 @@ IMPL_LINK_NOARG(OutlineView, RemovingPagesHdl)
     return 1;
 }
 
-/*************************************************************************
-|*
-|* Handler for indenting level 0 paragraphs (pages): Warning
-|*
-\************************************************************************/
-
+/**
+ * Handler for indenting level 0 paragraphs (pages): Warning
+ */
 IMPL_LINK_INLINE_START( OutlineView, IndentingPagesHdl, OutlinerView *, pOutlinerView )
 {
     return RemovingPagesHdl(pOutlinerView);
@@ -1407,12 +1337,9 @@ void OutlineView::SetActualPage( SdPage* pActual )
     }
 }
 
-/*************************************************************************
-|*
-|* Get StyleSheet from the selection
-|*
-\************************************************************************/
-
+/**
+ * Get StyleSheet from the selection
+ */
 SfxStyleSheet* OutlineView::GetStyleSheet() const
 {
      ::sd::Window* pActWin = mrOutlineViewShell.GetActiveWindow();
@@ -1423,12 +1350,9 @@ SfxStyleSheet* OutlineView::GetStyleSheet() const
 
 
 
-/*************************************************************************
-|*
-|* Mark pages as selected / not selected
-|*
-\************************************************************************/
-
+/**
+ * Mark pages as selected / not selected
+ */
 void OutlineView::SetSelectedPages()
 {
     // list of selected title paragraphs
@@ -1471,12 +1395,9 @@ void OutlineView::SetSelectedPages()
 }
 
 
-/*************************************************************************
-|*
-|* Set new links
-|*
-\************************************************************************/
-
+/**
+ * Set new links
+ */
 void OutlineView::SetLinks()
 {
     // set notification links
@@ -1497,12 +1418,9 @@ void OutlineView::SetLinks()
 
 
 
-/*************************************************************************
-|*
-|* Restore old links
-|*
-\************************************************************************/
-
+/**
+ * Restore old links
+ */
 void OutlineView::ResetLinks() const
 {
     Link aEmptyLink;
@@ -1519,22 +1437,12 @@ void OutlineView::ResetLinks() const
     mrOutliner.SetEndPasteOrDropHdl(aEmptyLink);
 }
 
-/*************************************************************************
-|*
-|* AcceptDrop
-|*
-\************************************************************************/
 
 sal_Int8 OutlineView::AcceptDrop( const AcceptDropEvent&, DropTargetHelper&, ::sd::Window*, sal_uInt16, sal_uInt16)
 {
     return DND_ACTION_NONE;
 }
 
-/*************************************************************************
-|*
-|* ExecuteDrop
-|*
-\************************************************************************/
 
 sal_Int8 OutlineView::ExecuteDrop( const ExecuteDropEvent&, DropTargetHelper&, ::sd::Window*, sal_uInt16, sal_uInt16)
 {
diff --git a/sd/source/ui/view/sdruler.cxx b/sd/source/ui/view/sdruler.cxx
index 52331c3ef597..66bed37aa4ec 100644
--- a/sd/source/ui/view/sdruler.cxx
+++ b/sd/source/ui/view/sdruler.cxx
@@ -34,12 +34,9 @@
 
 namespace sd {
 
-/*************************************************************************
-|*
-|* Controller-Item fuer Ruler
-|*
-\************************************************************************/
-
+/**
+ * Controller-Item for ruler
+ */
 class RulerCtrlItem : public SfxControllerItem
 {
     Ruler &rRuler;
@@ -74,11 +71,6 @@ void RulerCtrlItem::StateChanged( sal_uInt16 nSId, SfxItemState, const SfxPoolIt
 }
 
 
-/*************************************************************************
-|*
-|* Konstruktor
-|*
-\************************************************************************/
 
 Ruler::Ruler( DrawViewShell& rViewSh, ::Window* pParent, ::sd::Window* pWin, sal_uInt16 nRulerFlags,  SfxBindings& rBindings, WinBits nWinStyle)
 : SvxRuler(pParent, pWin, nRulerFlags, rBindings, nWinStyle)
@@ -101,11 +93,6 @@ Ruler::Ruler( DrawViewShell& rViewSh, ::Window* pParent, ::sd::Window* pWin, sal
     }
 }
 
-/*************************************************************************
-|*
-|* Destruktor
-|*
-\************************************************************************/
 
 Ruler::~Ruler()
 {
@@ -115,11 +102,6 @@ Ruler::~Ruler()
     rBindings.LeaveRegistrations();
 }
 
-/*************************************************************************
-|*
-|* MouseButtonDown-Handler
-|*
-\************************************************************************/
 
 void Ruler::MouseButtonDown(const MouseEvent& rMEvt)
 {
@@ -136,33 +118,18 @@ void Ruler::MouseButtonDown(const MouseEvent& rMEvt)
         SvxRuler::MouseButtonDown(rMEvt);
 }
 
-/*************************************************************************
-|*
-|* MouseMove-Handler
-|*
-\************************************************************************/
 
 void Ruler::MouseMove(const MouseEvent& rMEvt)
 {
     SvxRuler::MouseMove(rMEvt);
 }
 
-/*************************************************************************
-|*
-|* MouseButtonUp-Handler
-|*
-\************************************************************************/
 
 void Ruler::MouseButtonUp(const MouseEvent& rMEvt)
 {
     SvxRuler::MouseButtonUp(rMEvt);
 }
 
-/*************************************************************************
-|*
-|* NullOffset setzen
-|*
-\************************************************************************/
 
 void Ruler::SetNullOffset(const Point& rOffset)
 {
@@ -174,11 +141,6 @@ void Ruler::SetNullOffset(const Point& rOffset)
     SetNullOffsetLogic(nOffset);
 }
 
-/*************************************************************************
-|*
-|* Command event
-|*
-\************************************************************************/
 
 void Ruler::Command(const CommandEvent& rCEvt)
 {
@@ -189,11 +151,6 @@ void Ruler::Command(const CommandEvent& rCEvt)
     }
 }
 
-/*************************************************************************
-|*
-|* ExtraDown
-|*
-\************************************************************************/
 
 void Ruler::ExtraDown()
 {
diff --git a/sd/source/ui/view/sdview.cxx b/sd/source/ui/view/sdview.cxx
index 7159b294fc3b..42fa3b8f9ed5 100644
--- a/sd/source/ui/view/sdview.cxx
+++ b/sd/source/ui/view/sdview.cxx
@@ -93,11 +93,6 @@ namespace sd {
 
 TYPEINIT1(View, FmFormView);
 
-/*************************************************************************
-|*
-|* Ctor
-|*
-\************************************************************************/
 
 View::View(SdDrawDocument& rDrawDoc, OutputDevice* pOutDev,
                ViewShell* pViewShell)
@@ -133,7 +128,7 @@ View::View(SdDrawDocument& rDrawDoc, OutputDevice* pOutDev,
     SetHitTolerancePixel(2);
     SetMeasureLayer(String(SdResId(STR_LAYER_MEASURELINES)));
 
-    // Timer fuer verzoegertes Drop (muss fuer MAC sein)
+    // Timer for delayed drop (has to be for MAC)
     maDropErrorTimer.SetTimeoutHdl( LINK(this, View, DropErrorHdl) );
     maDropErrorTimer.SetTimeout(50);
     maDropInsertFileTimer.SetTimeoutHdl( LINK(this, View, DropInsertFileHdl) );
@@ -149,11 +144,6 @@ void View::ImplClearDrawDropMarker()
     }
 }
 
-/*************************************************************************
-|*
-|* Dtor
-|*
-\************************************************************************/
 
 View::~View()
 {
@@ -169,7 +159,7 @@ View::~View()
 
     while(PaintWindowCount())
     {
-        // Alle angemeldeten OutDevs entfernen
+        // remove all registered OutDevs
         DeleteWindowFromPaintView(GetFirstOutputDevice() /*GetWin(0)*/);
     }
 }
@@ -466,15 +456,12 @@ drawinglayer::primitive2d::Primitive2DSequence ViewRedirector::createRedirectedP
     return xRetval;
 }
 
-/*************************************************************************
-|*
-|* Paint-Methode: das Ereignis wird an die View weitergeleitet
-|*
-\************************************************************************/
-
+/**
+ * The event will be forwarded to the View
+ */
 void View::CompleteRedraw(OutputDevice* pOutDev, const Region& rReg, sdr::contact::ViewObjectContactRedirector* pRedirector /*=0L*/)
 {
-    // ausfuehren ??
+    // execute ??
     if (mnLockRedrawSmph == 0)
     {
         SdrPageView* pPgView = GetSdrPageView();
@@ -510,7 +497,7 @@ void View::CompleteRedraw(OutputDevice* pOutDev, const Region& rReg, sdr::contac
         ViewRedirector aViewRedirector;
         FmFormView::CompleteRedraw(pOutDev, rReg, pRedirector ? pRedirector : &aViewRedirector);
     }
-    // oder speichern?
+    // or save?
     else
     {
         SdViewRedrawRec* pRec = new SdViewRedrawRec;
@@ -521,12 +508,6 @@ void View::CompleteRedraw(OutputDevice* pOutDev, const Region& rReg, sdr::contac
 }
 
 
-/*************************************************************************
-|*
-|* Selektion hat sich geaendert
-|*
-\************************************************************************/
-
 void View::MarkListHasChanged()
 {
     FmFormView::MarkListHasChanged();
@@ -536,12 +517,6 @@ void View::MarkListHasChanged()
 }
 
 
-/*************************************************************************
-|*
-|* Attribute setzen
-|*
-\************************************************************************/
-
 sal_Bool View::SetAttributes(const SfxItemSet& rSet, sal_Bool bReplaceAll)
 {
     sal_Bool bOk = FmFormView::SetAttributes(rSet, bReplaceAll);
@@ -549,42 +524,30 @@ sal_Bool View::SetAttributes(const SfxItemSet& rSet, sal_Bool bReplaceAll)
 }
 
 
-/*************************************************************************
-|*
-|* Attribute holen
-|*
-\************************************************************************/
-
 sal_Bool View::GetAttributes( SfxItemSet& rTargetSet, sal_Bool bOnlyHardAttr ) const
 {
     return( FmFormView::GetAttributes( rTargetSet, bOnlyHardAttr ) );
 }
 
 
-/*************************************************************************
-|*
-|* Ist ein Praesentationsobjekt selektiert?
-|*
-\************************************************************************/
-
+/**
+ * Is a presentation object selected?
+ */
 sal_Bool View::IsPresObjSelected(sal_Bool bOnPage, sal_Bool bOnMasterPage, sal_Bool bCheckPresObjListOnly, sal_Bool bCheckLayoutOnly) const
 {
-    /**************************************************************************
-    * Ist ein Presentationsobjekt selektiert?
-    **************************************************************************/
     SdrMarkList* pMarkList;
 
     if (mnDragSrcPgNum != SDRPAGE_NOTFOUND &&
         mnDragSrcPgNum != GetSdrPageView()->GetPage()->GetPageNum())
     {
-        // Es laeuft gerade Drag&Drop
-        // Source- und Destination-Page unterschiedlich:
-        // es wird die gemerkte MarkList verwendet
+        /* Drag&Drop is in progress
+           Source and destination page are different:
+           we use the saved mark list */
         pMarkList = mpDragSrcMarkList;
     }
     else
     {
-        // Es wird die aktuelle MarkList verwendet
+        // We use the current mark list
         pMarkList = new SdrMarkList(GetMarkedObjectList());
     }
 
@@ -599,7 +562,7 @@ sal_Bool View::IsPresObjSelected(sal_Bool bOnPage, sal_Bool bOnMasterPage, sal_B
 
     for (nMark = nMarkMax; (nMark >= 0) && !bSelected; nMark--)
     {
-        // Rueckwaerts durch die Marklist
+        // Backwards through mark list
         pMark = pMarkList->GetMark(nMark);
         pObj = pMark->GetMarkedSdrObj();
 
@@ -636,11 +599,6 @@ sal_Bool View::IsPresObjSelected(sal_Bool bOnPage, sal_Bool bOnMasterPage, sal_B
     return (bSelected);
 }
 
-/*************************************************************************
-|*
-|* Alles selektieren
-|*
-\************************************************************************/
 
 void View::SelectAll()
 {
@@ -657,37 +615,24 @@ void View::SelectAll()
 }
 
 
-/*************************************************************************
-|*
-|* Dokument hat sich geaendert
-|*
-\************************************************************************/
 
 void View::ModelHasChanged()
 {
-    // Erst SdrView benachrichtigen
+    // First, notify SdrView
     FmFormView::ModelHasChanged();
 }
 
-/*************************************************************************
-|*
-|* StyleSheet setzen
-|*
-\************************************************************************/
 
 sal_Bool View::SetStyleSheet(SfxStyleSheet* pStyleSheet, sal_Bool bDontRemoveHardAttr)
 {
-    // weiter an SdrView
+    // forward to SdrView
     return FmFormView::SetStyleSheet(pStyleSheet, bDontRemoveHardAttr);
 }
 
 
-/*************************************************************************
-|*
-|* Texteingabe beginnen
-|*
-\************************************************************************/
-
+/**
+ * Start text input
+ */
 static void SetSpellOptions( const SdDrawDocument& rDoc, sal_uLong& rCntrl )
 {
     sal_Bool bOnlineSpell = rDoc.GetOnlineSpell();
@@ -845,12 +790,9 @@ bool View::RestoreDefaultText( SdrTextObj* pTextObj )
     return bRestored;
 }
 
-/*************************************************************************
-|*
-|* Originalgroesse der markierten Objekte setzen
-|*
-\************************************************************************/
-
+/**
+ * Sets the original size of the marked objects.
+ */
 void View::SetMarkedOriginalSize()
 {
     SdrUndoGroup* pUndoGroup = new SdrUndoGroup(mrDoc);
@@ -935,12 +877,9 @@ void View::SetMarkedOriginalSize()
         delete pUndoGroup;
 }
 
-/*************************************************************************
-|*
-|* OLE-Obj am Client connecten
-|*
-\************************************************************************/
-
+/**
+ * Connect OLE object to client.
+ */
 void View::DoConnect(SdrOle2Obj* pObj)
 {
     if (mpViewSh)
@@ -964,11 +903,11 @@ void View::DoConnect(SdrOle2Obj* pObj)
 
                     Fraction aScaleWidth (aDrawSize.Width(),  aObjAreaSize.Width() );
                     Fraction aScaleHeight(aDrawSize.Height(), aObjAreaSize.Height() );
-                    aScaleWidth.ReduceInaccurate(10);       // kompatibel zum SdrOle2Obj
+                    aScaleWidth.ReduceInaccurate(10);       // compatible to SdrOle2Obj
                     aScaleHeight.ReduceInaccurate(10);
                     pSdClient->SetSizeScale(aScaleWidth, aScaleHeight);
 
-                    // sichtbarer Ausschnitt wird nur inplace veraendert!
+                    // visible area is only changed in-place!
                     // the object area must be set after the scaling, since it triggers resize
                     aRect.SetSize(aObjAreaSize);
                     pSdClient->SetObjArea(aRect);
@@ -1101,12 +1040,9 @@ IMPL_LINK( View, OnParagraphInsertedHdl, ::Outliner *, pOutliner )
     return 0;
 }
 
-/*************************************************************************
-|*
-|* Handler fuer das Loeschen von Seiten (Absaetzen)
-|*
-\************************************************************************/
-
+/**
+ * Handler for the deletion of the pages (paragraphs).
+ */
 IMPL_LINK( View, OnParagraphRemovingHdl, ::Outliner *, pOutliner )
 {
     Paragraph* pPara = pOutliner->GetHdlParagraph();
diff --git a/sd/source/ui/view/sdview2.cxx b/sd/source/ui/view/sdview2.cxx
index 1a9d5870c68e..3d804aed035f 100644
--- a/sd/source/ui/view/sdview2.cxx
+++ b/sd/source/ui/view/sdview2.cxx
@@ -452,7 +452,7 @@ void View::DragFinished( sal_Int8 nDropAction )
                 SdrObject* pChkObj =
 #endif
                     pObj->GetPage()->RemoveObject(nOrdNum);
-                DBG_ASSERT(pChkObj==pObj,"pChkObj!=pObj beim RemoveObject()");
+                DBG_ASSERT(pChkObj==pObj,"pChkObj!=pObj in RemoveObject()");
             }
         }
 
@@ -784,7 +784,7 @@ sal_Int8 View::ExecuteDrop( const ExecuteDropEvent& rEvt, DropTargetHelper& rTar
                                     bCreated = sal_True;
                                 }
 
-                                // Undo-Action mit alten und neuen Groessen erzeugen
+                                // create undo action with old and new sizes
                                 SdAnimationPrmsUndoAction* pAction = new SdAnimationPrmsUndoAction(&mrDoc, pPickObj, bCreated);
                                 pAction->SetActive(pInfo->mbActive, pInfo->mbActive);
                                 pAction->SetEffect(pInfo->meEffect, pInfo->meEffect);
@@ -864,16 +864,17 @@ IMPL_LINK( View, ExecuteNavigatorDrop, SdNavigatorDropEvent*, pSdNavigatorDropEv
                 nPgPos = pPage->GetPageNum() + 1;
         }
 
-        // Um zu gewaehrleisten, dass alle Seitennamen eindeutig sind, werden
-        // die einzufuegenden geprueft und gegebenenfalls in einer Ersatzliste
-        // aufgenommen (bNameOK == sal_False -> Benutzer hat abgebrochen)
+        /* In order t ensure unique page names, we test the ones we want to
+           insert. If necessary. we put them into and replacement list (bNameOK
+           == sal_False -> User canceled).  */
         sal_Bool    bLink = ( NAVIGATOR_DRAGTYPE_LINK == pPageObjsTransferable->GetDragType()  ? sal_True : sal_False );
         sal_Bool    bNameOK = GetExchangeList( aExchangeList, aBookmarkList, 2 );
         sal_Bool    bReplace = sal_False;
 
-        // Da man hier nicht weiss, ob es sich um eine Seite oder ein Objekt handelt,
-        // wird eine Liste sowohl mit Seiten, als auch mit Objekten gefuellt.
-        // Sollten Seitennamen und Objektnamen identisch sein gibt es hier natuerlich Probleme !!!
+        /* Since we don't know the type (page or object), we fill a list with
+           pages and objects.
+           Of course we have problems if there are pages and objects with the
+           same name!!! */
         if( bNameOK )
         {
             mrDoc.InsertBookmark( aBookmarkList, aExchangeList,
@@ -894,8 +895,8 @@ bool View::GetExchangeList (std::vector<rtl::OUString> &rExchangeList,
 {
     assert(rExchangeList.empty());
 
-    bool bListIdentical = true; // BookmarkList und ExchangeList sind gleich
-    bool bNameOK = true;        // Name ist eindeutig
+    bool bListIdentical = true; ///< Bookmark list and exchange list are identical
+    bool bNameOK = true;        ///< name is unique
 
     std::vector<rtl::OUString>::const_iterator pIter;
     for ( pIter = rBookmarkList.begin(); bNameOK && pIter != rBookmarkList.end(); ++pIter )
@@ -943,7 +944,7 @@ bool View::GetExchangeList (std::vector<rtl::OUString> &rExchangeList,
         rExchangeList.push_back(aNewName);
     }
 
-    // ExchangeList ist mit BookmarkList identisch
+    // Exchange list is identical to bookmark list
     if( !rExchangeList.empty() && bListIdentical )
         rExchangeList.clear();
 
diff --git a/sd/source/ui/view/sdview3.cxx b/sd/source/ui/view/sdview3.cxx
index f6a59d691dcc..7d6bf5e696c9 100644
--- a/sd/source/ui/view/sdview3.cxx
+++ b/sd/source/ui/view/sdview3.cxx
@@ -732,17 +732,17 @@ sal_Bool View::InsertData( const TransferableDataHelper& rDataHelper,
                             }
                             aSet.Put( pObj->GetMergedItemSet() );
 
-                            // Eckenradius soll nicht uebernommen werden.
-                            // In der Gallery stehen Farbverlauefe (Rechtecke)
-                            // welche den Eckenradius == 0 haben. Dieser soll
-                            // nicht auf das Objekt uebertragen werden.
+                            /* Do not take over corner radius. There are
+                               gradients (rectangles) in the gallery with corner
+                               radius of 0. We should not use that on the
+                               object. */
                             aSet.ClearItem( SDRATTR_ECKENRADIUS );
 
                             pPickObj->SetMergedItemSetAndBroadcast( aSet );
 
                             if( pPickObj->ISA( E3dObject ) && pObj->ISA( E3dObject ) )
                             {
-                                // Zusaetzlich 3D Attribute handeln
+                                // handle 3D attribute in addition
                                 SfxItemSet aNewSet( mrDoc.GetPool(), SID_ATTR_3D_START, SID_ATTR_3D_END, 0 );
                                 SfxItemSet aOldSet( mrDoc.GetPool(), SID_ATTR_3D_START, SID_ATTR_3D_END, 0 );
 
@@ -1287,7 +1287,7 @@ sal_Bool View::InsertData( const TransferableDataHelper& rDataHelper,
                 else
                     aSet.Put( XLineColorItem( aName, aColor ) );
 
-                // Textfarbe hinzufuegen
+                // add text color
                 pPickObj->SetMergedItemSetAndBroadcast( aSet );
             }
         }
diff --git a/sd/source/ui/view/sdview4.cxx b/sd/source/ui/view/sdview4.cxx
index f9fdabb2edef..a58b387b141d 100644
--- a/sd/source/ui/view/sdview4.cxx
+++ b/sd/source/ui/view/sdview4.cxx
@@ -64,23 +64,18 @@ using namespace com::sun::star;
 
 namespace sd {
 
-/*************************************************************************
-|*
-|* Graphik einfuegen
-|* Wird ein leeres Graphikobjekt uebergeben, so wird dieses gefuellt.
-|* Andernfalls wird ein an der gegebenen Position vorhandenes Objekt
-|* gefuellt. Ist an der Position kein Objekt vorhanden, so wird ein neues
-|* Objekt erzeugt und ein Pointer auf dieses Objekt zurueckgegeben.
-|*
-\************************************************************************/
-
+/**
+ * If an empty graphic object is provided, we fill it. Otherwise we fill an
+ * existing object at the specified position. If there is no object at the
+ * position, we create a new object and return a pointer to it.
+ */
 SdrGrafObj* View::InsertGraphic( const Graphic& rGraphic, sal_Int8& rAction,
                                    const Point& rPos, SdrObject* pObj, ImageMap* pImageMap )
 {
     SdrEndTextEdit();
     mnAction = rAction;
 
-    // Liegt ein Objekt an der Position rPos?
+    // Is there a object at the position rPos?
     SdrGrafObj*     pNewGrafObj = NULL;
     SdrPageView*    pPV = GetSdrPageView();
     SdrObject*      pPickObj = pObj;
@@ -110,7 +105,7 @@ SdrGrafObj* View::InsertGraphic( const Graphic& rGraphic, sal_Int8& rAction,
 
             if( bIsGraphic )
             {
-                // Das Objekt wird mit der Bitmap gefuellt
+                // We fill the object with the Bitmap
                 pNewGrafObj = (SdrGrafObj*) pPickObj->Clone();
                 pNewGrafObj->SetGraphic(rGraphic);
             }
@@ -130,7 +125,7 @@ SdrGrafObj* View::InsertGraphic( const Graphic& rGraphic, sal_Int8& rAction,
 
             if (pPage && pPage->IsPresObj(pPickObj))
             {
-                // Neues PresObj in die Liste eintragen
+                // Insert new PresObj into the list
                 pPage->InsertPresObj( pNewGrafObj, PRESOBJ_GRAPHIC );
                 pNewGrafObj->SetUserCall(pPickObj->GetUserCall());
             }
@@ -145,9 +140,7 @@ SdrGrafObj* View::InsertGraphic( const Graphic& rGraphic, sal_Int8& rAction,
         }
         else if (pPickObj->IsClosedObj() && !pPickObj->ISA(SdrOle2Obj))
         {
-            /******************************************************************
-            * Das Objekt wird mit der Graphik gefuellt
-            ******************************************************************/
+            // we fill the object with the graphic
             if( IsUndoEnabled() )
             {
                 BegUndo(String(SdResId(STR_UNDO_DRAGDROP)));
@@ -353,12 +346,9 @@ SdrMediaObj* View::InsertMediaURL( const rtl::OUString& rMediaURL, sal_Int8& rAc
     return pNewMediaObj;
 }
 
-/*************************************************************************
-|*
-|* Timer-Handler fuer InsertFile beim Drop()
-|*
-\************************************************************************/
-
+/**
+ * Timer handler for InsertFile at Drop()
+ */
 IMPL_LINK_NOARG(View, DropInsertFileHdl)
 {
     DBG_ASSERT( mpViewSh, "sd::View::DropInsertFileHdl(), I need a view shell to work!" );
@@ -550,24 +540,18 @@ IMPL_LINK_NOARG(View, DropInsertFileHdl)
     return nError;
 }
 
-/*************************************************************************
-|*
-|* Timer-Handler fuer Errorhandling beim Drop()
-|*
-\************************************************************************/
-
+/**
+ * Timer handler for Errorhandling at Drop()
+ */
 IMPL_LINK_NOARG(View, DropErrorHdl)
 {
     InfoBox( mpViewSh ? mpViewSh->GetActiveWindow() : 0, String(SdResId(STR_ACTION_NOTPOSSIBLE) ) ).Execute();
     return 0;
 }
 
-/*************************************************************************
-|*
-|* StyleSheet aus der Sleketion besorgen
-|*
-\************************************************************************/
-
+/**
+ * @returns StyleSheet from selection
+ */
 SfxStyleSheet* View::GetStyleSheet() const
 {
     return SdrView::GetStyleSheet();
diff --git a/sd/source/ui/view/sdwindow.cxx b/sd/source/ui/view/sdwindow.cxx
index 3872bb56b9ea..4967cfea64de 100644
--- a/sd/source/ui/view/sdwindow.cxx
+++ b/sd/source/ui/view/sdwindow.cxx
@@ -41,27 +41,22 @@
 
 namespace sd {
 
-#define SCROLL_LINE_FACT   0.05     // Faktor fuer Zeilenscrolling
-#define SCROLL_PAGE_FACT   0.5      // Faktor fuer Seitenscrolling
-#define SCROLL_SENSITIVE   20       // Sensitiver Bereich (Pixel)
-#define ZOOM_MULTIPLICATOR 10000    // Multiplikator um Rundungsfehler zu vermeiden
-#define MIN_ZOOM           5        // Minimaler Zoomfaktor
-#define MAX_ZOOM           3000     // Maximaler Zoomfaktor
+#define SCROLL_LINE_FACT   0.05     ///< factor for line scrolling
+#define SCROLL_PAGE_FACT   0.5      ///< factor for page scrolling
+#define SCROLL_SENSITIVE   20       ///< sensitive area in pixel
+#define ZOOM_MULTIPLICATOR 10000    ///< multiplier to avoid rounding errors
+#define MIN_ZOOM           5        ///< minimal zoom factor
+#define MAX_ZOOM           3000     ///< maximal zoom factor
 
 
-/*************************************************************************
-|*
-|* Konstruktor
-|*
-\************************************************************************/
 
 Window::Window(::Window* pParent)
     : ::Window(pParent, WinBits(WB_CLIPCHILDREN | WB_DIALOGCONTROL)),
       DropTargetHelper( this ),
       mpShareWin(NULL),
-      maWinPos(0, 0),           // vorsichtshalber; die Werte sollten aber
-      maViewOrigin(0, 0),       // vom Besitzer des Fensters neu gesetzt
-      maViewSize(1000, 1000),   // werden
+      maWinPos(0, 0),           // precautionary; but the values should be set
+      maViewOrigin(0, 0),       // again from the owner of the window
+      maViewSize(1000, 1000),
       maPrevSize(-1,-1),
       mnMinZoom(MIN_ZOOM),
       mnMaxZoom(MAX_ZOOM),
@@ -79,7 +74,7 @@ Window::Window(::Window* pParent)
     aMap.SetMapUnit(MAP_100TH_MM);
     SetMapMode(aMap);
 
-    // Damit im Diamodus die ::WindowColor genommen wird
+    // whit it, the ::WindowColor is used in the slide mode
     SetBackground( Wallpaper( GetSettings().GetStyleSettings().GetWindowColor() ) );
 
     // adjust contrast mode initially
@@ -88,7 +83,7 @@ Window::Window(::Window* pParent)
         ? ViewShell::OUTPUT_DRAWMODE_CONTRAST
         : ViewShell::OUTPUT_DRAWMODE_COLOR );
 
-    // Hilfe-ID setzen
+    // set Help ID
     // SetHelpId(HID_SD_WIN_DOCUMENT);
     SetUniqueId(HID_SD_WIN_DOCUMENT);
 
@@ -96,11 +91,6 @@ Window::Window(::Window* pParent)
     EnableRTL(sal_False);
 }
 
-/*************************************************************************
-|*
-|* Destruktor
-|*
-\************************************************************************/
 
 Window::~Window (void)
 {
@@ -232,11 +222,6 @@ long Window::GetZoom (void) const
 
 
 
-/*************************************************************************
-|*
-|* Resize event
-|*
-\************************************************************************/
 
 void Window::Resize()
 {
@@ -247,11 +232,6 @@ void Window::Resize()
         mpViewShell->GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOMSLIDER );
 }
 
-/*************************************************************************
-|*
-|* PrePaint event
-|*
-\************************************************************************/
 
 void Window::PrePaint()
 {
@@ -259,11 +239,6 @@ void Window::PrePaint()
         mpViewShell->PrePaint();
 }
 
-/*************************************************************************
-|*
-|* Paint event
-|*
-\************************************************************************/
 
 void Window::Paint(const Rectangle& rRect)
 {
@@ -271,11 +246,6 @@ void Window::Paint(const Rectangle& rRect)
         mpViewShell->Paint(rRect, this);
 }
 
-/*************************************************************************
-|*
-|* Keyboard event
-|*
-\************************************************************************/
 
 void Window::KeyInput(const KeyEvent& rKEvt)
 {
@@ -292,11 +262,6 @@ void Window::KeyInput(const KeyEvent& rKEvt)
     }
 }
 
-/*************************************************************************
-|*
-|* MouseButtonDown event
-|*
-\************************************************************************/
 
 void Window::MouseButtonDown(const MouseEvent& rMEvt)
 {
@@ -304,11 +269,6 @@ void Window::MouseButtonDown(const MouseEvent& rMEvt)
         mpViewShell->MouseButtonDown(rMEvt, this);
 }
 
-/*************************************************************************
-|*
-|* MouseMove event
-|*
-\************************************************************************/
 
 void Window::MouseMove(const MouseEvent& rMEvt)
 {
@@ -316,11 +276,6 @@ void Window::MouseMove(const MouseEvent& rMEvt)
         mpViewShell->MouseMove(rMEvt, this);
 }
 
-/*************************************************************************
-|*
-|* MouseButtonUp event
-|*
-\************************************************************************/
 
 void Window::MouseButtonUp(const MouseEvent& rMEvt)
 {
@@ -330,11 +285,6 @@ void Window::MouseButtonUp(const MouseEvent& rMEvt)
         mpViewShell->MouseButtonUp(rMEvt, this);
 }
 
-/*************************************************************************
-|*
-|* Command event
-|*
-\************************************************************************/
 
 void Window::Command(const CommandEvent& rCEvt)
 {
@@ -342,6 +292,7 @@ void Window::Command(const CommandEvent& rCEvt)
         mpViewShell->Command(rCEvt, this);
 }
 
+
 long Window::Notify( NotifyEvent& rNEvt )
 {
     long nResult = sal_False;
@@ -356,12 +307,6 @@ long Window::Notify( NotifyEvent& rNEvt )
 }
 
 
-/*************************************************************************
-|*
-|* RequestHelp event
-|*
-\************************************************************************/
-
 void Window::RequestHelp(const HelpEvent& rEvt)
 {
     if ( mpViewShell )
@@ -400,36 +345,26 @@ Size Window::GetViewSize (void) const
 
 
 
-/*************************************************************************
-|*
-|* Position der linken oberen Ecke des im Fenster sichtbaren Bereichs
-|* setzen
-|*
-\************************************************************************/
-
+/**
+ * Set the position of the upper left corner from the visible area of the
+ * window.
+ */
 void Window::SetWinViewPos(const Point& rPnt)
 {
     maWinPos = rPnt;
 }
 
-/*************************************************************************
-|*
-|* Ursprung der Darstellung in Bezug zur gesamten Arbeitsflaeche setzen
-|*
-\************************************************************************/
-
+/**
+ * Set origin of the representation in respect to the whole working area.
+ */
 void Window::SetViewOrigin(const Point& rPnt)
 {
     maViewOrigin = rPnt;
 }
 
-/*************************************************************************
-|*
-|* Groesse der gesamten Arbeitsflaeche, die mit dem Fenster betrachtet
-|* werden kann, setzen
-|*
-\************************************************************************/
-
+/**
+ * Set size of the whole working area which can be seen with the window.
+ */
 void Window::SetViewSize(const Size& rSize)
 {
     maViewSize = rSize;
@@ -651,14 +586,11 @@ void Window::SetMinZoomAutoCalc (bool bAuto)
 
 
 
-/*************************************************************************
-|*
-|* Neuen MapMode-Origin berechnen und setzen; wenn aWinPos.X()/Y()
-|* gleich -1 ist, wird die entsprechende Position zentriert
-|* (z.B. fuer Initialisierung)
-|*
-\************************************************************************/
-
+/**
+ * Calculate and set new MapMode origin.
+ * If aWinPos.X()/Y() == -1, then we center the corresponding position (e.g. for
+ * initialization).
+ */
 void Window::UpdateMapOrigin(sal_Bool bInvalidate)
 {
     sal_Bool       bChanged = sal_False;
@@ -713,15 +645,15 @@ void Window::UpdateMapMode (void)
     maWinPos -= maViewOrigin;
     Size aPix(maWinPos.X(), maWinPos.Y());
     aPix = LogicToPixel(aPix);
-    // Groesse muss vielfaches von BRUSH_SIZE sein, damit Muster
-    // richtig dargestellt werden
+    // Size has to be a multiple of BRUSH_SIZE due to the correct depiction of
+    // pattern
     // #i2237#
     // removed old stuff here which still forced zoom to be
     // %BRUSH_SIZE which is outdated now
 
     if (mpViewShell && mpViewShell->ISA(DrawViewShell))
     {
-        // Seite soll nicht am Fensterrand "kleben"
+        // page should not "stick" to the window border
         if (aPix.Width() == 0)
         {
             // #i2237#
@@ -752,38 +684,28 @@ void Window::UpdateMapMode (void)
 
 
 
-/*************************************************************************
-|*
-|* X-Position des sichtbaren Bereichs als Bruchteil (< 1)
-|* der gesamten Arbeitsbereichbreite zuruegeben
-|*
-\************************************************************************/
-
+/**
+ * @returns X position of the visible area as fraction (< 1) of the whole
+ * working area.
+ */
 double Window::GetVisibleX()
 {
     return ((double) maWinPos.X() / maViewSize.Width());
 }
 
-/*************************************************************************
-|*
-|* Y-Position des sichtbaren Bereichs als Bruchteil (< 1)
-|* der gesamten Arbeitsbereichhoehe zuruegeben
-|*
-\************************************************************************/
-
+/**
+ * @returns Y position of the visible area as fraction (< 1) of the whole
+ * working area.
+ */
 double Window::GetVisibleY()
 {
     return ((double) maWinPos.Y() / maViewSize.Height());
 }
 
-/*************************************************************************
-|*
-|* X- und Y-Position des sichtbaren Bereichs als Bruchteile (< 1)
-|* der gesamten Arbeitsbereichgroesse setzen
-|* negative Werte werden ignoriert
-|*
-\************************************************************************/
-
+/**
+ * Set x and y position of the visible area as fraction (< 1) of the whole
+ * working area. Negative values are ignored.
+ */
 void Window::SetVisibleXY(double fX, double fY)
 {
     long nOldX = maWinPos.X();
@@ -798,13 +720,10 @@ void Window::SetVisibleXY(double fX, double fY)
     Update();
 }
 
-/*************************************************************************
-|*
-|* Breite des sichtbaren Bereichs im Verhaeltnis zur
-|* gesamten Arbeitsbereichbreite zuruegeben
-|*
-\************************************************************************/
-
+/**
+ * @returns width of the visible area in proportion to the width of the whole
+ * working area.
+ */
 double Window::GetVisibleWidth()
 {
     Size aWinSize = PixelToLogic(GetOutputSizePixel());
@@ -813,13 +732,10 @@ double Window::GetVisibleWidth()
     return ((double) aWinSize.Width() / maViewSize.Width());
 }
 
-/*************************************************************************
-|*
-|* Hoehe des sichtbaren Bereichs im Verhaeltnis zur
-|* gesamten Arbeitsbereichhoehe zuruegeben
-|*
-\************************************************************************/
-
+/**
+ * @returns height of the visible area in proportion to the height of the whole
+ * working area.
+ */
 double Window::GetVisibleHeight()
 {
     Size aWinSize = PixelToLogic(GetOutputSizePixel());
@@ -828,72 +744,54 @@ double Window::GetVisibleHeight()
     return ((double) aWinSize.Height() / maViewSize.Height());
 }
 
-/*************************************************************************
-|*
-|* Breite einer Scrollspalte im Verhaeltnis zur gesamten
-|* Arbeitsbereichbreite zuruegeben
-|*
-\************************************************************************/
-
+/**
+ * @returns width of a scroll column in proportion to the width of the whole
+ * working area.
+ */
 double Window::GetScrlLineWidth()
 {
     return (GetVisibleWidth() * SCROLL_LINE_FACT);
 }
 
-/*************************************************************************
-|*
-|* Breite einer Scrollspalte im Verhaeltnis zur gesamten
-|* Arbeitsbereichhoehe zuruegeben
-|*
-\************************************************************************/
-
+/**
+ * @returns height of a scroll column in proportion to the height of the whole
+ * working area.
+ */
 double Window::GetScrlLineHeight()
 {
     return (GetVisibleHeight() * SCROLL_LINE_FACT);
 }
 
-/*************************************************************************
-|*
-|* Breite einer Scrollpage im Verhaeltnis zur gesamten
-|* Arbeitsbereichbreite zuruegeben
-|*
-\************************************************************************/
-
+/**
+ * @returns width of a scroll page in proportion to the width of the whole
+ * working area.
+ */
 double Window::GetScrlPageWidth()
 {
     return (GetVisibleWidth() * SCROLL_PAGE_FACT);
 }
 
-/*************************************************************************
-|*
-|* Breite einer Scrollpage im Verhaeltnis zur gesamten
-|* Arbeitsbereichhoehe zuruegeben
-|*
-\************************************************************************/
-
+/**
+ * @returns height of a scroll page in proportion to the height of the whole
+ * working area.
+ */
 double Window::GetScrlPageHeight()
 {
     return (GetVisibleHeight() * SCROLL_PAGE_FACT);
 }
 
-/*************************************************************************
-|*
-|* Fenster deaktivieren
-|*
-\************************************************************************/
-
+/**
+ * Deactivate window.
+ */
 void Window::LoseFocus()
 {
     mnTicks = 0;
     ::Window::LoseFocus ();
 }
 
-/*************************************************************************
-|*
-|* Fenster aktivieren
-|*
-\************************************************************************/
-
+/**
+ * Activate window.
+ */
 void Window::GrabFocus()
 {
     mnTicks      = 0;
@@ -901,19 +799,14 @@ void Window::GrabFocus()
 }
 
 
-/*************************************************************************
-|*
-|* DataChanged
-|*
-\************************************************************************/
 
 void Window::DataChanged( const DataChangedEvent& rDCEvt )
 {
     ::Window::DataChanged( rDCEvt );
 
-    // PRINTER bei allen Dokumenten weglassen, die keinen Printer benutzen.
-    // FONTS und FONTSUBSTITUTION weglassen, wenn keine Textausgaben
-    // vorhanden sind, bzw. wenn das Dokument keinen Text zulaesst.
+    /* Omit PRINTER by all documents which are not using a printer.
+       Omit FONTS and FONTSUBSTITUTION if no text output is available or if the
+       document does not allow text.  */
 
     if ( (rDCEvt.GetType() == DATACHANGED_PRINTER) ||
          (rDCEvt.GetType() == DATACHANGED_DISPLAY) ||
@@ -935,16 +828,15 @@ void Window::DataChanged( const DataChangedEvent& rDCEvt )
                     mpViewShell->GetViewFrame()->GetDispatcher()->
                         Execute(SID_SIZE_PAGE, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD);
 
-            // ScrollBars neu anordnen bzw. Resize ausloesen, da sich
-            // ScrollBar-Groesse geaendert haben kann. Dazu muss dann im
-            // Resize-Handler aber auch die Groesse der ScrollBars aus
-            // den Settings abgefragt werden.
+            /* Rearrange or initiate Resize for scroll bars since the size of
+               the scroll bars my have changed. Within this, inside the resize-
+               handler, the size of the scroll bars will be asked from the
+               Settings. */
             Resize();
 
-            // Daten neu Setzen, die aus den Systemeinstellungen bzw. aus
-            // den Settings uebernommen werden. Evtl. weitere Daten neu
-            // berechnen, da sich auch die Aufloesung hierdurch geaendert
-            // haben kann.
+            /* Re-set data, which are from system control or from Settings. May
+               have to re-set more data since the resolution may also has
+               changed. */
             if( mpViewShell )
             {
                 const StyleSettings&    rStyleSettings = GetSettings().GetStyleSettings();
@@ -994,34 +886,29 @@ void Window::DataChanged( const DataChangedEvent& rDCEvt )
              ((rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
               (rDCEvt.GetFlags() & SETTINGS_STYLE)) )
         {
-            // Virtuelle Device die auch von der Aufloesung oder von
-            // Systemeinstellungen abhaengen, sollten geupdatet werden.
-            // Ansonsten sollte zumindest bei DATACHANGED_DISPLAY
-            // die virtuellen Devices geupdatet werden, da es einige
-            // Systeme erlauben die Aufloesung und Farbtiefe waehrend
-            // der Laufzeit zu aendern oder eben bei Palettenaenderungen
-            // die virtuellen Device geupdatet werden muessen, da bei
-            // Ausgaben ein anderes Farbmatching stattfinden kann.
+            /* Virtual devices, which also depends on the resolution or the
+               system control, should be updated. Otherwise, we should update
+               the virtual devices at least at DATACHANGED_DISPLAY since some
+               systems allow to change the resolution and color depth during
+               runtime. Or the virtual devices have to be updated when the color
+               palette has changed since a different color matching can be used
+               when outputting. */
         }
 
         if ( rDCEvt.GetType() == DATACHANGED_FONTS )
         {
-            // Wenn das Dokument Font-AuswahlBoxen anbietet, muessen
-            // diese geupdatet werden. Wie dies genau aussehen muss,
-            // weiss ich leider auch nicht. Aber evtl. kann man das
-            // ja global handeln. Dies muessten wir evtl. mal
-            // mit PB absprechen, aber der ist derzeit leider Krank.
-            // Also bevor dies hier gehandelt wird, vorher mit
-            // PB und mir absprechen.
+            /* If the document provides font choose boxes, we have to update
+               them. I don't know how this looks like (also not really me, I
+               only translated the comment ;). We may can handle it global. We
+               have to discuss it with PB, but he is ill at the moment.
+               Before we handle it here, discuss it with PB and me. */
         }
 
         if ( (rDCEvt.GetType() == DATACHANGED_FONTS) ||
              (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) )
         {
-            // Formatierung neu durchfuehren, da Fonts die im Dokument
-            // vorkommen, nicht mehr vorhanden sein muessen oder
-            // jetzt vorhanden sind oder durch andere ersetzt wurden
-            // sind.
+            /* Do reformating since the fonts of the document may no longer
+               exist, or exist now, or are replaced with others. */
             if( mpViewShell )
             {
                 DrawDocShell* pDocSh = mpViewShell->GetDocSh();
@@ -1032,13 +919,11 @@ void Window::DataChanged( const DataChangedEvent& rDCEvt )
 
         if ( rDCEvt.GetType() == DATACHANGED_PRINTER )
         {
-            // Wie hier die Behandlung aussehen soll, weiss ich leider
-            // selbst noch nicht. Evtl. mal einen Printer loeschen und
-            // schauen was gemacht werden muss. Evtl. muesste ich in
-            // VCL dafuer noch etwas einbauen, wenn der benutze Printer
-            // geloescht wird. Ansonsten wuerde ich hier evtl. die
-            // Formatierung neu berechnen, wenn der aktuelle Drucker
-            // zerstoert wurde.
+            /* I don't know how the handling should look like. Maybe we delete a
+               printer and look what we have to do. Maybe I have to add
+               something to the VCL, in case the used printer is deleted.
+               Otherwise I may recalculate the formatting here if the current
+               printer is destroyed. */
             if( mpViewShell )
             {
                 DrawDocShell* pDocSh = mpViewShell->GetDocSh();
@@ -1047,7 +932,7 @@ void Window::DataChanged( const DataChangedEvent& rDCEvt )
             }
         }
 
-        // Alles neu ausgeben
+        // Update everything
         Invalidate();
     }
 }
@@ -1055,11 +940,6 @@ void Window::DataChanged( const DataChangedEvent& rDCEvt )
 
 
 
-/*************************************************************************
-|*
-|* DropTargetHelper::AcceptDrop
-|*
-\************************************************************************/
 
 sal_Int8 Window::AcceptDrop( const AcceptDropEvent& rEvt )
 {
@@ -1077,11 +957,6 @@ sal_Int8 Window::AcceptDrop( const AcceptDropEvent& rEvt )
     return nRet;
 }
 
-/*************************************************************************
-|*
-|* DropTargetHelper::ExecuteDrop
-|*
-\************************************************************************/
 
 sal_Int8 Window::ExecuteDrop( const ExecuteDropEvent& rEvt )
 {
@@ -1106,11 +981,6 @@ void Window::SetUseDropScroll (bool bUseDropScroll)
 
 
 
-/*************************************************************************
-|*
-|* Scrolling bei AcceptDrop-Events
-|*
-\************************************************************************/
 
 void Window::DropScroll(const Point& rMousePos)
 {
diff --git a/sd/source/ui/view/tabcontr.cxx b/sd/source/ui/view/tabcontr.cxx
index fd7ef5ba8f14..9cfcea5dc629 100644
--- a/sd/source/ui/view/tabcontr.cxx
+++ b/sd/source/ui/view/tabcontr.cxx
@@ -76,11 +76,6 @@ void TabControl::TabControlTransferable::DragFinished( sal_Int8 nDropAction )
     mrParent.DragFinished( nDropAction );
 }
 
-/*************************************************************************
-|*
-|* Standard-Konstruktor
-|*
-\************************************************************************/
 
 TabControl::TabControl(DrawViewShell* pViewSh, Window* pParent) :
     TabBar( pParent, WinBits( WB_BORDER | WB_3DLOOK | WB_SCROLL | WB_SIZEABLE | WB_DRAG) ),
@@ -95,11 +90,6 @@ TabControl::TabControl(DrawViewShell* pViewSh, Window* pParent) :
     SetHelpId( HID_SD_TABBAR_PAGES );
 }
 
-/*************************************************************************
-|*
-|* Destruktor
-|*
-\************************************************************************/
 
 TabControl::~TabControl()
 {
@@ -168,11 +158,6 @@ void TabControl::DoubleClick()
     }
 }
 
-/*************************************************************************
-|*
-|* StartDrag-Request
-|*
-\************************************************************************/
 
 void TabControl::StartDrag( sal_Int8, const Point& )
 {
@@ -182,22 +167,12 @@ void TabControl::StartDrag( sal_Int8, const Point& )
     ( new TabControl::TabControlTransferable( *this ) )->StartDrag( this, DND_ACTION_COPYMOVE );
 }
 
-/*************************************************************************
-|*
-|* DragFinished
-|*
-\************************************************************************/
 
 void TabControl::DragFinished( sal_Int8 )
 {
     bInternalMove = sal_False;
 }
 
-/*************************************************************************
-|*
-|* AcceptDrop-Event
-|*
-\************************************************************************/
 
 sal_Int8 TabControl::AcceptDrop( const AcceptDropEvent& rEvt )
 {
@@ -238,11 +213,6 @@ sal_Int8 TabControl::AcceptDrop( const AcceptDropEvent& rEvt )
     return nRet;
 }
 
-/*************************************************************************
-|*
-|* ExecuteDrop-Event
-|*
-\************************************************************************/
 
 sal_Int8 TabControl::ExecuteDrop( const ExecuteDropEvent& rEvt )
 {
@@ -360,7 +330,7 @@ long TabControl::AllowRenaming()
 
     if( aCompareName != aNewName )
     {
-        // Seite umbenennen
+        // rename page
         if( pDrViewSh->GetDocSh()->CheckPageName( this, aNewName ) )
         {
             SetEditText( aNewName );
diff --git a/sd/source/ui/view/unmodpg.cxx b/sd/source/ui/view/unmodpg.cxx
index 81a3f50e64c3..08a97b4dd490 100644
--- a/sd/source/ui/view/unmodpg.cxx
+++ b/sd/source/ui/view/unmodpg.cxx
@@ -39,11 +39,6 @@
 TYPEINIT1(ModifyPageUndoAction, SdUndoAction);
 
 
-/*************************************************************************
-|*
-|* Konstruktor
-|*
-\************************************************************************/
 
 ModifyPageUndoAction::ModifyPageUndoAction(
     SdDrawDocument* pTheDoc,
@@ -79,16 +74,11 @@ ModifyPageUndoAction::ModifyPageUndoAction(
     maComment = String(SdResId(STR_UNDO_MODIFY_PAGE));
 }
 
-/*************************************************************************
-|*
-|* Undo()
-|*
-\************************************************************************/
 #include <svx/svdviter.hxx>
 #include <svx/svdview.hxx>
 void ModifyPageUndoAction::Undo()
 {
-    // invalidate Selection, there could be objects deleted in tis UNDO
+    // invalidate Selection, there could be objects deleted in this UNDO
     // which are no longer allowed to be selected then.
       SdrViewIter aIter(mpPage);
     SdrView* pView = aIter.FirstView();
@@ -129,15 +119,10 @@ void ModifyPageUndoAction::Undo()
         SID_SWITCHPAGE, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD );
 }
 
-/*************************************************************************
-|*
-|* Redo()
-|*
-\************************************************************************/
 
 void ModifyPageUndoAction::Redo()
 {
-    // invalidate Selection, there could be objects deleted in tis UNDO
+    // invalidate Selection, there could be objects deleted in this UNDO
     // which are no longer allowed to be selected then.
       SdrViewIter aIter(mpPage);
     SdrView* pView = aIter.FirstView();
@@ -178,21 +163,11 @@ void ModifyPageUndoAction::Redo()
         SID_SWITCHPAGE, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD );
 }
 
-/*************************************************************************
-|*
-|* Destruktor
-|*
-\************************************************************************/
 
 ModifyPageUndoAction::~ModifyPageUndoAction()
 {
 }
 
-/*************************************************************************
-|*
-|* Kommentar liefern
-|*
-\************************************************************************/
 
 rtl::OUString ModifyPageUndoAction::GetComment() const
 {
diff --git a/sd/source/ui/view/viewshe2.cxx b/sd/source/ui/view/viewshe2.cxx
index c666875643ec..90b81798ad8f 100644
--- a/sd/source/ui/view/viewshe2.cxx
+++ b/sd/source/ui/view/viewshe2.cxx
@@ -78,12 +78,9 @@ const String aEmptyStr;
 
 namespace sd {
 
-/*************************************************************************
-|*
-|* Scrollbar-Update: Thumbpos und VisibleSize anpassen
-|*
-\************************************************************************/
-
+/**
+ * adjust Thumbpos and VisibleSize
+ */
 void ViewShell::UpdateScrollBars()
 {
     if (mpHorizontalScrollBar.get() != NULL)
@@ -135,24 +132,18 @@ void ViewShell::UpdateScrollBars()
     }
 
 }
-/*************************************************************************
-|*
-|* Handling fuer horizontale Scrollbars
-|*
-\************************************************************************/
-
+/**
+ * Handling for horizontal Scrollbars
+ */
 IMPL_LINK_INLINE_START(ViewShell, HScrollHdl, ScrollBar *, pHScroll )
 {
     return VirtHScrollHdl(pHScroll);
 }
 IMPL_LINK_INLINE_END(ViewShell, HScrollHdl, ScrollBar *, pHScroll )
 
-/*************************************************************************
-|*
-|* virtueller Scroll-Handler fuer horizontale Scrollbars
-|*
-\************************************************************************/
-
+/**
+ * virtual scroll handler for horizontal Scrollbars
+ */
 long ViewShell::VirtHScrollHdl(ScrollBar* pHScroll)
 {
     long nDelta = pHScroll->GetDelta();
@@ -161,7 +152,7 @@ long ViewShell::VirtHScrollHdl(ScrollBar* pHScroll)
     {
         double fX = (double) pHScroll->GetThumbPos() / pHScroll->GetRange().Len();
 
-        // alle Fenster der Spalte scrollen
+        // scroll all windows of the column
         ::sd::View* pView = GetView();
         OutlinerView* pOLV = NULL;
 
@@ -198,24 +189,18 @@ long ViewShell::VirtHScrollHdl(ScrollBar* pHScroll)
     return 0;
 }
 
-/*************************************************************************
-|*
-|* Handling fuer vertikale Scrollbars
-|*
-\************************************************************************/
-
+/**
+ * handling for vertical Scrollbars
+ */
 IMPL_LINK_INLINE_START(ViewShell, VScrollHdl, ScrollBar *, pVScroll )
 {
     return VirtVScrollHdl(pVScroll);
 }
 IMPL_LINK_INLINE_END(ViewShell, VScrollHdl, ScrollBar *, pVScroll )
 
-/*************************************************************************
-|*
-|* Handling fuer vertikale Scrollbars
-|*
-\************************************************************************/
-
+/**
+ * handling for vertical Scrollbars
+ */
 long ViewShell::VirtVScrollHdl(ScrollBar* pVScroll)
 {
     if(IsPageFlipMode())
@@ -284,13 +269,10 @@ void ViewShell::UpdateVRuler()
 {
 }
 
-/*************************************************************************
-|*
-|* Eine bestimmte Anzahl von Zeilen scrollen (wird beim automatischen
-|* Scrollen (Zeichen/Draggen) verwendet)
-|*
-\************************************************************************/
-
+/**
+ * Scroll a specific number of lines. Is used in the automatic scrolling
+ * (character/drag).
+ */
 void ViewShell::ScrollLines(long nLinesX, long nLinesY)
 {
     if ( nLinesX )
@@ -305,12 +287,6 @@ void ViewShell::ScrollLines(long nLinesX, long nLinesY)
     Scroll(nLinesX, nLinesY);
 }
 
-/*************************************************************************
-|*
-|* Window um nScrollX, nScrollY scrollen
-|*
-\************************************************************************/
-
 void ViewShell::Scroll(long nScrollX, long nScrollY)
 {
     if (nScrollX)
@@ -352,12 +328,9 @@ void ViewShell::Scroll(long nScrollX, long nScrollY)
     }
 }
 
-/*************************************************************************
-|*
-|* Den Zoomfaktor fuer alle Split-Windows setzen
-|*
-\************************************************************************/
-
+/**
+ * Set zoom factor for all split windows.
+ */
 void ViewShell::SetZoom(long nZoom)
 {
     Fraction aUIScale(nZoom, 100);
@@ -393,13 +366,10 @@ void ViewShell::SetZoom(long nZoom)
     UpdateScrollBars();
 }
 
-/*************************************************************************
-|*
-|* Zoomrechteck fuer aktives Fenster einstellen und alle Split-Windows
-|* auf den gleichen Zoomfaktor setzen
-|*
-\************************************************************************/
-
+/**
+ * Set zoom rectangle for active window. Sets all split windows to the same zoom
+ * factor.
+ */
 void ViewShell::SetZoomRect(const Rectangle& rZoomRect)
 {
     long nZoom = GetActiveWindow()->SetZoomRect(rZoomRect);
@@ -440,12 +410,9 @@ void ViewShell::SetZoomRect(const Rectangle& rZoomRect)
     UpdateScrollBars();
 }
 
-/*************************************************************************
-|*
-|* Abbildungsparameter fuer alle Split-Windows initialisieren
-|*
-\************************************************************************/
-
+/**
+ * Initialize imaging parameters for all split windows.
+ */
 void ViewShell::InitWindows(const Point& rViewOrigin, const Size& rViewSize,
                               const Point& rWinPos, sal_Bool bUpdate)
 {
@@ -473,12 +440,9 @@ void ViewShell::InitWindows(const Point& rViewOrigin, const Size& rViewSize,
     }
 }
 
-/*************************************************************************
-|*
-|* Alle Split-Windows unter dem uebergebenen Rechteck invalidieren
-|*
-\************************************************************************/
-
+/**
+ * Invalidate all split windows below the ?provided rectangle.
+ */
 void ViewShell::InvalidateWindows()
 {
     if (mpContentWindow.get() != NULL)
@@ -486,13 +450,9 @@ void ViewShell::InvalidateWindows()
 }
 
 
-/*************************************************************************
-|*
-|* Auf allen Split-Windows ein Markierungsrechteck mit dem
-|* uebergebenen Pen zeichnen
-|*
-\************************************************************************/
-
+/**
+ * Draw a selection rectangle with the ?provided pen on all split windows.
+ */
 void ViewShell::DrawMarkRect(const Rectangle& rRect) const
 {
     if (mpContentWindow.get() != NULL)
@@ -501,12 +461,6 @@ void ViewShell::DrawMarkRect(const Rectangle& rRect) const
     }
 }
 
-/*************************************************************************
-|*
-|* Groesse und Raender aller Seiten setzen
-|*
-\************************************************************************/
-
 void ViewShell::SetPageSizeAndBorder(PageKind ePageKind, const Size& rNewSize,
                                        long nLeft, long nRight,
                                        long nUpper, long nLower, sal_Bool bScaleAll,
@@ -527,9 +481,7 @@ void ViewShell::SetPageSizeAndBorder(PageKind ePageKind, const Size& rNewSize,
 
     for (i = 0; i < nPageCnt; i++)
     {
-        /**********************************************************************
-        * Erst alle MasterPages bearbeiten
-        **********************************************************************/
+        // first, handle all master pages
         pPage = GetDoc()->GetMasterSdPage(i, ePageKind);
 
         SdUndoAction* pUndo = new SdPageFormatUndoAction(GetDoc(), pPage,
@@ -577,9 +529,7 @@ void ViewShell::SetPageSizeAndBorder(PageKind ePageKind, const Size& rNewSize,
 
     for (i = 0; i < nPageCnt; i++)
     {
-        /**********************************************************************
-        * Danach alle Pages bearbeiten
-        **********************************************************************/
+        // then, handle all pages
         pPage = GetDoc()->GetSdPage(i, ePageKind);
 
         SdUndoAction* pUndo = new SdPageFormatUndoAction(GetDoc(), pPage,
@@ -626,11 +576,11 @@ void ViewShell::SetPageSizeAndBorder(PageKind ePageKind, const Size& rNewSize,
         pPage->SetAutoLayout( pPage->GetAutoLayout() );
     }
 
-    // Handoutseite an neues Format der Standardseiten anpassen
+    // adjust handout page to new format of the standard page
     if( (ePageKind == PK_STANDARD) || (ePageKind == PK_HANDOUT) )
         GetDoc()->GetSdPage(0, PK_HANDOUT)->CreateTitleAndLayout(sal_True);
 
-    // Undo Gruppe dem Undo Manager uebergeben
+    // handed over undo group to undo manager
     pViewShell->GetViewFrame()->GetObjectShell()
         ->GetUndoManager()->AddUndoAction(pUndoGroup);
 
@@ -666,19 +616,16 @@ void ViewShell::SetPageSizeAndBorder(PageKind ePageKind, const Size& rNewSize,
 
     pViewShell->GetViewFrame()->GetBindings().Invalidate(SID_RULER_NULL_OFFSET);
 
-    // auf (neue) Seitengroesse zoomen
+    // zoom onto (new) page size
     pViewShell->GetViewFrame()->GetDispatcher()->Execute(SID_SIZE_PAGE,
             SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD);
 
     Broadcast (ViewShellHint(ViewShellHint::HINT_PAGE_RESIZE_END));
 }
 
-/*************************************************************************
-|*
-|* Zoom-Faktor fuer InPlace einstellen
-|*
-\************************************************************************/
-
+/**
+ * Set zoom factor for InPlace
+ */
 void ViewShell::SetZoomFactor(const Fraction& rZoomX, const Fraction&)
 {
     long nZoom = (long)((double) rZoomX * 100);
@@ -686,11 +633,6 @@ void ViewShell::SetZoomFactor(const Fraction& rZoomX, const Fraction&)
 }
 
 
-/*************************************************************************
-|*
-|* Aktives Fenster setzen
-|*
-\************************************************************************/
 
 void ViewShell::SetActiveWindow (::sd::Window* pWin)
 {
@@ -728,12 +670,6 @@ void ViewShell::SetActiveWindow (::sd::Window* pWin)
 
 
 
-/*************************************************************************
-|*
-|* RequestHelp event
-|*
-\************************************************************************/
-
 sal_Bool ViewShell::RequestHelp(const HelpEvent& rHEvt, ::sd::Window*)
 {
     sal_Bool bReturn = sal_False;
@@ -794,11 +730,6 @@ void ViewShell::WriteFrameViewData()
 {
 }
 
-/*************************************************************************
-|*
-|* OLE-Object aktivieren
-|*
-\************************************************************************/
 
 sal_Bool ViewShell::ActivateObject(SdrOle2Obj* pObj, long nVerb)
 {
@@ -815,9 +746,7 @@ sal_Bool ViewShell::ActivateObject(SdrOle2Obj* pObj, long nVerb)
     uno::Reference < embed::XEmbeddedObject > xObj = pObj->GetObjRef();
     if ( !xObj.is() )
     {
-        /**********************************************************
-        * Leeres OLE-Objekt mit OLE-Objekt versehen
-        **********************************************************/
+        // provide OLE object to empty OLE object
         aName = pObj->GetProgName();
         ::rtl::OUString aObjName;
         SvGlobalName aClass;
@@ -848,7 +777,7 @@ sal_Bool ViewShell::ActivateObject(SdrOle2Obj* pObj, long nVerb)
         {
             aName = "";
 
-            // Dialog "OLE-Objekt einfuegen" aufrufen
+            // call dialog "insert OLE object"
             GetDocSh()->SetWaitCursor( sal_False );
             pViewShell->GetViewFrame()->GetDispatcher()->Execute(
                 SID_INSERT_OBJECT,
@@ -864,16 +793,12 @@ sal_Bool ViewShell::ActivateObject(SdrOle2Obj* pObj, long nVerb)
 
         if ( xObj.is() )
         {
-            /******************************************************
-            * OLE-Objekt ist nicht mehr leer
-            ******************************************************/
+            // OLE object is no longer empty
             pObj->SetEmptyPresObj(sal_False);
             pObj->SetOutlinerParaObject(NULL);
             pObj->SetGraphic(NULL);
 
-            /******************************************************
-            * Das leere OLE-Objekt bekommt ein neues IPObj
-            ******************************************************/
+            // the empty OLE object gets a new IPObj
             if (!aName.isEmpty())
             {
                 pObj->SetObjRef(xObj);
@@ -882,7 +807,7 @@ sal_Bool ViewShell::ActivateObject(SdrOle2Obj* pObj, long nVerb)
             }
             else
             {
-                // Das Einfuegen hat der Dialog schon gemacht
+                // insertion was done by the dialog
                 pObj->SetObjRef(xObj);
             }
 
@@ -947,7 +872,7 @@ sal_Bool ViewShell::ActivateObject(SdrOle2Obj* pObj, long nVerb)
         aScaleHeight.ReduceInaccurate(10);
         pSdClient->SetSizeScale(aScaleWidth, aScaleHeight);
 
-        // sichtbarer Ausschnitt wird nur inplace veraendert!
+        // visible section is only changed in-place!
         aRect.SetSize(aObjAreaSize);
         // the object area size must be set after scaling, since it triggers the resizing
         pSdClient->SetObjArea(aRect);
@@ -957,7 +882,7 @@ sal_Bool ViewShell::ActivateObject(SdrOle2Obj* pObj, long nVerb)
             AdaptDefaultsForChart( xObj );
         }
 
-        pSdClient->DoVerb(nVerb);   // ErrCode wird ggf. vom Sfx ausgegeben
+        pSdClient->DoVerb(nVerb);   // if necessary, ErrCode is outputted by Sfx
         pViewShell->GetViewFrame()->GetBindings().Invalidate(
             SID_NAVIGATOR_STATE, sal_True, sal_False);
     }
@@ -972,12 +897,9 @@ sal_Bool ViewShell::ActivateObject(SdrOle2Obj* pObj, long nVerb)
     return aErrCode == 0;
 }
 
-/*************************************************************************
-|*
-|* umschliessendes Rechteck aller (Split-)Fenster zurueckgeben.
-|*
-\************************************************************************/
-
+/**
+ * @returns enclosing rectangle of all (split-) windows.
+ */
 const Rectangle& ViewShell::GetAllWindowRect()
 {
     maAllWindowRectangle.SetPos(
@@ -985,37 +907,24 @@ const Rectangle& ViewShell::GetAllWindowRect()
     return maAllWindowRectangle;
 }
 
-/*************************************************************************
-|*
-|* Read user data
-|*
-\************************************************************************/
 void ViewShell::ReadUserData(const String&)
 {
-    // Auf an FrameView gemerkte VisArea zoomen
+    // zoom onto VisArea from FrameView
     GetViewShell()->GetViewFrame()->GetDispatcher()->Execute(SID_SIZE_VISAREA,
         SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD);
 }
 
-/*************************************************************************
-|*
-|* Write user data
-|*
-\************************************************************************/
 
 void ViewShell::WriteUserData(String&)
 {
-    // Das Schreiben unserer Daten erfolgt stets in WriteFrameViewData()
+    // writing of our data is always done in WriteFrameViewData()
     WriteFrameViewData();
 }
 
 
-/*************************************************************************
-|*
-|* Lineale ein- / ausschalten
-|*
-\************************************************************************/
-
+/**
+ * Switch ruler on/off
+ */
 void ViewShell::SetRuler(sal_Bool bRuler)
 {
     mbHasRulers = ( bRuler && !GetDocSh()->IsPreview() ); // no rulers on preview mode
@@ -1049,11 +958,6 @@ void ViewShell::SetRuler(sal_Bool bRuler)
         GetViewShell()->InvalidateBorder();
 }
 
-/*************************************************************************
-|*
-|* AcceptDrop
-|*
-\************************************************************************/
 
 sal_Int8 ViewShell::AcceptDrop (
     const AcceptDropEvent& rEvt,
@@ -1066,11 +970,6 @@ sal_Int8 ViewShell::AcceptDrop (
     return( pView ? pView->AcceptDrop( rEvt, rTargetHelper, pTargetWindow, nPage, nLayer ) : DND_ACTION_NONE );
 }
 
-/*************************************************************************
-|*
-|* ExecuteDrop
-|*
-\************************************************************************/
 
 sal_Int8 ViewShell::ExecuteDrop (
     const ExecuteDropEvent& rEvt,
diff --git a/sd/source/ui/view/viewshe3.cxx b/sd/source/ui/view/viewshe3.cxx
index 1e62a62620e7..54d5fcaf5871 100644
--- a/sd/source/ui/view/viewshe3.cxx
+++ b/sd/source/ui/view/viewshe3.cxx
@@ -80,12 +80,9 @@ using namespace ::rtl;
 
 namespace sd {
 
-/*************************************************************************
-|*
-|* Status (Enabled/Disabled) von Menue-SfxSlots setzen
-|*
-\************************************************************************/
-
+/**
+ * set state (enabled/disabled) of Menu SfxSlots
+ */
 void  ViewShell::GetMenuState( SfxItemSet &rSet )
 {
     if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_STYLE_FAMILY ) )
@@ -226,7 +223,7 @@ SdPage* ViewShell::CreateOrDuplicatePage (
     const SfxItemSet* pArgs = rRequest.GetArgs();
     if (! pArgs)
     {
-        // AutoLayouts muessen fertig sein
+        // AutoLayouts must be ready
         pDocument->StopWorkStartupDelay();
 
         // Use the layouts of the previous page and notes page as template.
@@ -259,7 +256,7 @@ SdPage* ViewShell::CreateOrDuplicatePage (
     }
     else if (pArgs->Count() == 4)
     {
-        // AutoLayouts muessen fertig sein
+        // AutoLayouts must be ready
         pDocument->StopWorkStartupDelay();
 
         SFX_REQUEST_ARG (rRequest, pPageName, SfxStringItem, ID_VAL_PAGENAME, sal_False);
diff --git a/sd/source/ui/view/viewshel.cxx b/sd/source/ui/view/viewshel.cxx
index e5fc5805b941..224e7e52acce 100644
--- a/sd/source/ui/view/viewshel.cxx
+++ b/sd/source/ui/view/viewshel.cxx
@@ -131,11 +131,7 @@ SfxViewFrame* ViewShell::GetViewFrame (void) const
 }
 
 
-/*************************************************************************
-|*
-|* SFX-Slotmap und Standardinterface deklarieren
-|*
-\************************************************************************/
+/// declare SFX-Slotmap and standard interface
 TYPEINIT1(ViewShell, SfxShell);
 
 
@@ -163,12 +159,9 @@ ViewShell::~ViewShell()
 }
 
 
-/*************************************************************************
-|*
-|* gemeinsamer Initialiserungsanteil der beiden Konstruktoren
-|*
-\************************************************************************/
-
+/**
+ * common initialization part of both constructors
+ */
 void ViewShell::construct(void)
 {
     mbHasRulers = false;
@@ -293,20 +286,17 @@ void ViewShell::Exit (void)
 
 
 
-/*************************************************************************
-|*
-|* Aktivierung: Arbeitsfenster den Fokus zuweisen
-|*
-\************************************************************************/
-
+/**
+ * set focus to working window
+ */
 void ViewShell::Activate(sal_Bool bIsMDIActivate)
 {
     SfxShell::Activate(bIsMDIActivate);
 
-    // Laut MI darf keiner GrabFocus rufen, der nicht genau weiss von
-    // welchem Window der Focus gegrabt wird. Da Activate() vom SFX teilweise
-    // asynchron verschickt wird, kann es sein, dass ein falsches Window
-    // den Focus hat
+    /* According to MI, nobody is allowed to call GrabFocus, who does not
+       exactly know from which window the focus is grabbed. Since Activate()
+       is sent sometimes asynchronous,  it can happen, that the wrong window
+       gets the focus. */
 
     if (mpHorizontalRuler.get() != NULL)
         mpHorizontalRuler->SetActive(sal_True);
@@ -315,7 +305,7 @@ void ViewShell::Activate(sal_Bool bIsMDIActivate)
 
     if (bIsMDIActivate)
     {
-        // Damit der Navigator auch einen aktuellen Status bekommt
+        // thus, the Navigator will also get a current status
         SfxBoolItem aItem( SID_NAVIGATOR_INIT, sal_True );
         if (GetDispatcher() != NULL)
             GetDispatcher()->Execute(
@@ -366,11 +356,6 @@ void ViewShell::UIDeactivated( SfxInPlaceClient*  )
         GetViewShellBase().GetToolBarManager()->SelectionHasChanged(*this, *GetDrawView());
 }
 
-/*************************************************************************
-|*
-|* Deaktivierung
-|*
-\************************************************************************/
 
 void ViewShell::Deactivate(sal_Bool bIsMDIActivate)
 {
@@ -385,7 +370,7 @@ void ViewShell::Deactivate(sal_Bool bIsMDIActivate)
 
     OSL_ASSERT (GetViewShell()!=NULL);
 
-    // View-Attribute an der FrameView merken
+    // remember view attributes of FrameView
     WriteFrameViewData();
 
     if (bIsMDIActivate)
@@ -420,12 +405,6 @@ void ViewShell::Shutdown (void)
 
 
 
-/*************************************************************************
-|*
-|* Keyboard event
-|*
-\************************************************************************/
-
 sal_Bool ViewShell::KeyInput(const KeyEvent& rKEvt, ::sd::Window* pWin)
 {
     sal_Bool bReturn(sal_False);
@@ -488,11 +467,6 @@ sal_Bool ViewShell::KeyInput(const KeyEvent& rKEvt, ::sd::Window* pWin)
     return(bReturn);
 }
 
-/*************************************************************************
-|*
-|* MouseButtonDown event
-|*
-\************************************************************************/
 
 void ViewShell::MouseButtonDown(const MouseEvent& rMEvt, ::sd::Window* pWin)
 {
@@ -512,7 +486,7 @@ void ViewShell::MouseButtonDown(const MouseEvent& rMEvt, ::sd::Window* pWin)
         SetActiveWindow(pWin);
     }
 
-    // MouseEvent in E3dView eintragen
+    // insert MouseEvent into E3dView
     if (GetView() != NULL)
         GetView()->SetMouseEvent(rMEvt);
 
@@ -533,11 +507,6 @@ void ViewShell::MouseButtonDown(const MouseEvent& rMEvt, ::sd::Window* pWin)
     }
 }
 
-/*************************************************************************
-|*
-|* MouseMove event
-|*
-\************************************************************************/
 
 void ViewShell::MouseMove(const MouseEvent& rMEvt, ::sd::Window* pWin)
 {
@@ -557,7 +526,7 @@ void ViewShell::MouseMove(const MouseEvent& rMEvt, ::sd::Window* pWin)
         SetActiveWindow(pWin);
     }
 
-    // MouseEvent in E3dView eintragen
+    // insert MouseEvent into E3dView
     if (GetView() != NULL)
         GetView()->SetMouseEvent(rMEvt);
 
@@ -572,11 +541,6 @@ void ViewShell::MouseMove(const MouseEvent& rMEvt, ::sd::Window* pWin)
     }
 }
 
-/*************************************************************************
-|*
-|* MouseButtonUp event
-|*
-\************************************************************************/
 
 void ViewShell::MouseButtonUp(const MouseEvent& rMEvt, ::sd::Window* pWin)
 {
@@ -585,7 +549,7 @@ void ViewShell::MouseButtonUp(const MouseEvent& rMEvt, ::sd::Window* pWin)
         SetActiveWindow(pWin);
     }
 
-    // MouseEvent in E3dView eintragen
+    // insert MouseEvent into E3dView
     if (GetView() != NULL)
         GetView()->SetMouseEvent(rMEvt);
 
@@ -609,11 +573,6 @@ void ViewShell::MouseButtonUp(const MouseEvent& rMEvt, ::sd::Window* pWin)
 }
 
 
-/*************************************************************************
-|*
-|* Command event
-|*
-\************************************************************************/
 
 void ViewShell::Command(const CommandEvent& rCEvt, ::sd::Window* pWin)
 {
@@ -961,11 +920,9 @@ void ViewShell::SetUIUnit(FieldUnit eUnit)
         mpVerticalRuler->SetUnit(eUnit);
 }
 
-/*************************************************************************
-|*
-|* DefTab an den horizontalen Linealen setzen
-|*
-\************************************************************************/
+/**
+ * set DefTab at horizontal rulers
+ */
 void ViewShell::SetDefTabHRuler( sal_uInt16 nDefTab )
 {
     if (mpHorizontalRuler.get() != NULL)