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


Hi,

I translated some more comments. The patch is attached.


Cheers,
Daniel
From 21691cf144af7ceab8a15a31ffadb9540b58adb7 Mon Sep 17 00:00:00 2001
From: Daniel Di Marco <d.dimarco@gmx.de>
Date: Sun, 6 Mar 2011 15:59:13 +0100
Subject: [PATCH] translated some comments from german to english

---
 sd/source/ui/view/outlnvs2.cxx |   48 ++--------
 sd/source/ui/view/outlnvsh.cxx |  165 +++++++++++++++++-------------------
 sd/source/ui/view/outlview.cxx |  185 +++++++++++++++++++---------------------
 sd/source/ui/view/zoomlist.cxx |   16 ++--
 4 files changed, 185 insertions(+), 229 deletions(-)

diff --git a/sd/source/ui/view/outlnvs2.cxx b/sd/source/ui/view/outlnvs2.cxx
index 730a7e2..f1b4e09 100644
--- a/sd/source/ui/view/outlnvs2.cxx
+++ b/sd/source/ui/view/outlnvs2.cxx
@@ -83,7 +83,7 @@ namespace sd {
 
 /*************************************************************************
 |*
-|* SfxRequests fuer temporaere Funktionen
+|* SfxRequests for temporary functions
 |*
 \************************************************************************/
 
@@ -119,7 +119,7 @@ void OutlineViewShell::FuTemporary(SfxRequest &rReq)
             }
             else
             {
-                // hier den Zoom-Dialog oeffnen
+                // open the zoom dialog here
                 SetCurrentFunction( FuScale::Create( this, GetActiveWindow(), pOlView, GetDoc(), 
rReq ) );
             }
             Cancel();
@@ -154,7 +154,7 @@ void OutlineViewShell::FuTemporary(SfxRequest &rReq)
         case SID_ZOOM_OUT:
         {
             SetCurrentFunction( FuZoom::Create(this, GetActiveWindow(), pOlView, GetDoc(), rReq) );
-            // Beendet sich selbst, kein Cancel() notwendig!
+            // ends itself, no need for Cancel()!
             rReq.Done();
         }
         break;
@@ -265,12 +265,12 @@ void OutlineViewShell::FuTemporary(SfxRequest &rReq)
 
             if ( !(nCntrl & EE_CNTRL_NOCOLORS) )
             {
-                // Farbansicht ist eingeschaltet: ausschalten
+                // color view is enabled: disable
                 pOutl->SetControlWord(nCntrl | EE_CNTRL_NOCOLORS);
             }
             else
             {
-                // Farbansicht ist ausgeschaltet: einschalten
+                // color view is disabled: enable
                 pOutl->SetControlWord(nCntrl & ~EE_CNTRL_NOCOLORS);
             }
 
@@ -419,35 +419,7 @@ void OutlineViewShell::FuTemporaryModify(SfxRequest &rReq)
 
         case SID_SET_DEFAULT:
         {
-            // 1. Selektion merken (kriegt die eselige EditEngine nicht selbst
-            //   auf die Reihe!)
-            // 2. Update auf False (sonst flackert's noch staerker
-            // an allen selektierten Absaetzen:
-            // a. deren Vorlage nochmal setzen, um absatzweite harte Attribute
-            //    zu entfernen
-            // b. harte Zeichenattribute loeschen
-            // 3. Update auf True und Selektion wieder setzen
-            /*
-            ESelection aEsel= pOutlinerView->GetSelection();
-            Outliner* pOutl = pOutlinerView->GetOutliner();
-            pOutl->SetUpdateMode(FALSE);
-            List* pSelectedParas = pOutlinerView->CreateSelectionList();
-            Paragraph* pPara = (Paragraph*)pSelectedParas->First();
-            while (pPara)
-            {
-                ULONG nParaPos = pOutl->GetAbsPos(pPara);
-                String aName;
-                SfxStyleFamily aFamily;
-                pOutl->GetStyleSheet(nParaPos, aName, aFamily);
-                pOutl->SetStyleSheet(nParaPos, aName, aFamily);
-                pOutl->QuickRemoveCharAttribs(nParaPos);
-                pPara = (Paragraph*)pSelectedParas->Next();
-            }
-            delete pSelectedParas;
-            pOutl->SetUpdateMode(TRUE);
-            pOutlinerView->SetSelection(aEsel);
-            */
-            pOutlinerView->RemoveAttribs(TRUE); // TRUE = auch Absatzattribute
+            pOutlinerView->RemoveAttribs(TRUE); // TRUE = also paragraph attributes
             Cancel();
             rReq.Done();
         }
@@ -547,7 +519,7 @@ void OutlineViewShell::FuTemporaryModify(SfxRequest &rReq)
                                 pOldFldItem->GetField()->ISA( SvxPageField ) ||
                                 pOldFldItem->GetField()->ISA( SvxPagesField )) )
             {
-                // Feld selektieren, so dass es beim Insert geloescht wird
+                // select field, so it gets deleted on Insert
                 ESelection aSel = pOutlinerView->GetSelection();
                 if( aSel.nStartPos == aSel.nEndPos )
                     aSel.nEndPos++;
@@ -582,8 +554,8 @@ void OutlineViewShell::FuTemporaryModify(SfxRequest &rReq)
                     if( pField )
                     {
                         SvxFieldItem aFieldItem( *pField, EE_FEATURE_FIELD );
-                        //pOLV->DeleteSelected(); <-- fehlt leider !
-                        // Feld selektieren, so dass es beim Insert geloescht wird
+                        //pOLV->DeleteSelected(); <-- unfortunately missing!
+                        // select field, so it gets deleted on Insert
                         ESelection aSel = pOutlinerView->GetSelection();
                         BOOL bSel = TRUE;
                         if( aSel.nStartPos == aSel.nEndPos )
@@ -595,7 +567,7 @@ void OutlineViewShell::FuTemporaryModify(SfxRequest &rReq)
 
                         pOutlinerView->InsertField( aFieldItem );
 
-                        // Selektion wird wieder in den Ursprungszustand gebracht
+                        // reset selection to original state
                         if( !bSel )
                             aSel.nEndPos--;
                         pOutlinerView->SetSelection( aSel );
diff --git a/sd/source/ui/view/outlnvsh.cxx b/sd/source/ui/view/outlnvsh.cxx
index c0f2d54..b6aa876 100644
--- a/sd/source/ui/view/outlnvsh.cxx
+++ b/sd/source/ui/view/outlnvsh.cxx
@@ -106,15 +106,15 @@ using namespace sd;
 
 namespace sd {
 
-#define MIN_ZOOM              10       // Minimaler Zoomfaktor
-#define MAX_ZOOM            1000           // Maximaler Zoomfaktor
+#define MIN_ZOOM              10
+#define MAX_ZOOM            1000
 
 /************************************************************************/
 
 
 /*************************************************************************
 |*
-|* SFX-Slotmap und Standardinterface deklarieren
+|* Declare SFX-Slotmap and standard interface
 |*
 \************************************************************************/
 
@@ -139,7 +139,7 @@ TYPEINIT1( OutlineViewShell, ViewShell );
 
 /*************************************************************************
 |*
-|* gemeinsamer Initialiserungsanteil der beiden Konstruktoren
+|* common initialization part of both constructors
 |*
 \************************************************************************/
 
@@ -156,13 +156,13 @@ void OutlineViewShell::Construct(DrawDocShell* )
     GetActiveWindow()->SetMaxZoom( MAX_ZOOM );
     InitWindows(aViewOrigin, aSize, aWinPos);
     pOlView = new OutlineView(GetDocSh(), GetActiveWindow(), this);
-    mpView = pOlView;                   // Pointer der Basisklasse ViewShell
+    mpView = pOlView;                   // Pointer of base class ViewShell
 
     SetPool( &GetDoc()->GetPool() );
 
     SetZoom(69);
 
-    // Einstellungen der FrameView uebernehmen
+    // Apply settings of FrameView
     ReadFrameViewData(mpFrameView);
 
     ::Outliner* pOutl = pOlView->GetOutliner();
@@ -208,7 +208,7 @@ Reference<drawing::XDrawSubController> OutlineViewShell::CreateSubController (vo
 
 /*************************************************************************
 |*
-|* Standard-Konstruktor, Fenster duerfen nicht automatisch zentrieren
+|* Default constructor, windows must not center themselves automatically
 |*
 \************************************************************************/
 
@@ -237,7 +237,7 @@ OutlineViewShell::OutlineViewShell (
 
 /*************************************************************************
 |*
-|* Destruktor
+|* Destructor
 |*
 \************************************************************************/
 
@@ -272,8 +272,8 @@ void OutlineViewShell::Shutdown (void)
 
 /*************************************************************************
 |*
-|* Paint-Methode: das Ereignis wird vom Fenster pWindow an
-|* die Viewshell und die aktuelle Funktion weitergeleitet
+|* Paint method: the event gets forwarded from pWindow to the Viewshell
+|* and the current function
 |*
 \************************************************************************/
 
@@ -307,7 +307,7 @@ void OutlineViewShell::ArrangeGUIElements ()
         pWindow->SetMinZoomAutoCalc(FALSE);
 
 
-        // OutputArea der OutlinerView aendern
+        // change OuputArea of the OutlinerView
         OutlinerView* pOutlinerView = pOlView->GetViewByWindow(pWindow);
 
         Rectangle aWin(Point(0,0), pWindow->GetOutputSizePixel());
@@ -322,7 +322,7 @@ void OutlineViewShell::ArrangeGUIElements ()
                 pOlView->GetOutliner()->GetTextHeight()));
         aText.Bottom() += aWin.GetHeight();
 
-        if (!aWin.IsEmpty())                   // nicht beim Oeffnen
+        if (!aWin.IsEmpty())                   // not when opening
         {
             InitWindows(Point(0,0), aText.GetSize(), Point(aVis.TopLeft()));
             UpdateScrollBars();
@@ -332,7 +332,7 @@ void OutlineViewShell::ArrangeGUIElements ()
 
 /*************************************************************************
 |*
-|* SfxRequests fuer Controller bearbeiten
+|* Handle SfxRequest for the Controller
 |*
 \************************************************************************/
 
@@ -381,7 +381,7 @@ void OutlineViewShell::RemoveWindow (::sd::Window* pWin)
 
 /*************************************************************************
 |*
-|* Activate(), beim ersten Aufruf erfolgt ein Update der Felder
+|* Activate(): during the first invocation the fields get updated
 |*
 \************************************************************************/
 void OutlineViewShell::Activate( BOOL bIsMDIActivate )
@@ -421,7 +421,7 @@ void OutlineViewShell::Deactivate( BOOL bIsMDIActivate )
 
 /*************************************************************************
 |*
-|* Status von Controller-SfxSlots setzen
+|* Set status of Controller-SfxSlots
 |*
 \************************************************************************/
 void OutlineViewShell::GetCtrlState(SfxItemSet &rSet)
@@ -485,7 +485,7 @@ void OutlineViewShell::GetCtrlState(SfxItemSet &rSet)
 
 /*************************************************************************
 |*
-|* SfxRequests fuer Support-Funktionen
+|* SfxRequests for support functions
 |*
 \************************************************************************/
 
@@ -609,7 +609,6 @@ void OutlineViewShell::FuSupport(SfxRequest &rReq)
         {
             if (mpZoomList->IsPreviousPossible())
             {
-                // Vorheriges ZoomRect einstellen
                 SetZoomRect(mpZoomList->GetPreviousZoomRect());
             }
             rReq.Done ();
@@ -620,7 +619,6 @@ void OutlineViewShell::FuSupport(SfxRequest &rReq)
         {
             if (mpZoomList->IsNextPossible())
             {
-                // Naechstes ZoomRect einstellen
                 SetZoomRect(mpZoomList->GetNextZoomRect());
             }
             rReq.Done ();
@@ -717,7 +715,7 @@ void OutlineViewShell::FuSupport(SfxRequest &rReq)
 
 /*************************************************************************
 |*
-|* SfxRequests fuer permanente Funktionen
+|* SfxRequests for permanent functions
 |*
 \************************************************************************/
 
@@ -782,7 +780,7 @@ IMPL_LINK( OutlineViewShell, ClipboardChanged, TransferableDataHelper*, pDataHel
 
 /*************************************************************************
 |*
-|* Status (Enabled/Disabled) von Menue-SfxSlots setzen
+|* Set Status (Enabled/Disabled) of Menu-SfxSlots
 |*
 \************************************************************************/
 
@@ -790,7 +788,7 @@ void OutlineViewShell::GetMenuState( SfxItemSet &rSet )
 {
     ViewShell::GetMenuState(rSet);
 
-    // Vorlagenkatalog darf nicht aufgerufen werden
+    // Style catalog must not be called
     rSet.DisableItem( SID_STYLE_CATALOG );
 
     rSet.Put(SfxBoolItem(SID_DIAMODE, FALSE));
@@ -822,7 +820,7 @@ void OutlineViewShell::GetMenuState( SfxItemSet &rSet )
     if( !pOutl )
         return;
 
-    // 'Alles auswaehlen' zulassen?
+    // allow 'Select All'?
     if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_SELECTALL ) )
     {
         ULONG nParaCount = pOutl->GetParagraphCount();
@@ -839,17 +837,17 @@ void OutlineViewShell::GetMenuState( SfxItemSet &rSet )
             rSet.DisableItem(SID_SELECTALL);
     }
 
-    // Status des Lineals setzen
+    // set status of Ruler
     rSet.Put( SfxBoolItem( SID_RULER, HasRuler() ) );
 
-    // Formatierung ein oder aus?
+    // Enable formatting?
     rSet.Put( SfxBoolItem( SID_OUTLINE_FORMAT, !pOutl->IsFlatMode() ) );
 
     if( pOutl->IsFlatMode() )
         rSet.DisableItem( SID_COLORVIEW );
     else
     {
-        // Farbansicht ein/aus
+        // Enable color view?
         ULONG nCntrl = pOutl->GetControlWord();
         BOOL bNoColor = FALSE;
         if (nCntrl & EE_CNTRL_NOCOLORS)
@@ -858,8 +856,8 @@ void OutlineViewShell::GetMenuState( SfxItemSet &rSet )
         rSet.Put( SfxBoolItem( SID_COLORVIEW, bNoColor ) );
     }
 
-    // Buttons der Werkzeugleiste
-    // zunaechst selektionsabhaengige: COLLAPSE, EXPAND
+    // Buttons of toolbar
+    // first the selection dependent ones: COLLAPSE, EXPAND
     BOOL bDisableCollapse = TRUE;
     BOOL bDisableExpand   = TRUE;
     BOOL bUnique                 = TRUE;
@@ -893,8 +891,8 @@ void OutlineViewShell::GetMenuState( SfxItemSet &rSet )
     if (bDisableCollapse)
         rSet.DisableItem(SID_OUTLINE_COLLAPSE);
 
-    // ergibt die Selektion ein eindeutiges Praesentationslayout?
-    // wenn nicht, duerfen die Vorlagen nicht bearbeitet werden
+    // does the selection provide a unique presentation layout?
+    // if not, the templates must not be edited
     SfxItemSet aSet(*rSet.GetPool(), SID_STATUS_LAYOUT, SID_STATUS_LAYOUT);
     GetStatusBarState(aSet);
     String aTest(((SfxStringItem&)aSet.Get(SID_STATUS_LAYOUT)).GetValue());
@@ -907,17 +905,17 @@ void OutlineViewShell::GetMenuState( SfxItemSet &rSet )
     if (!bUnique)
         rSet.DisableItem( SID_PRESENTATIONOBJECT );
 
-    // jetzt die selektionsunabhaengigen: COLLAPSE_ALL, EXPAND_ALL
+    // now the selection independent ones: COLLAPSE_ALL, EXPAND_ALL
     BOOL bDisableCollapseAll = TRUE;
     BOOL bDisableExpandAll      = TRUE;
 
-    // wenn schon die Selektion etwas kollabierbares/expandierbares enthaelt
+    // does the selection contain something collapsable/expandable?
     if (!bDisableCollapse)
         bDisableCollapseAll = FALSE;
     if (!bDisableExpand)
         bDisableExpandAll = FALSE;
 
-    // schade, so billig kommen wir nicht davon; alle Absaetze durchsuchen
+    // otherwise look through all paragraphs
     if (bDisableCollapseAll || bDisableExpandAll)
     {
         ULONG nParaPos = 0;
@@ -973,7 +971,7 @@ void OutlineViewShell::GetMenuState( SfxItemSet &rSet )
         GetDoc()->SetChanged(TRUE);
     }
 
-    // Da ueberladen, muss hier der Status gesetzt werden
+    // the status has to be set here because of overloading
     if( !GetDocSh()->IsModified() )
     {
         rSet.DisableItem( SID_SAVEDOC );
@@ -995,7 +993,7 @@ void OutlineViewShell::GetMenuState( SfxItemSet &rSet )
         }
     }
 
-    // Feldbefehle
+    // field commands
     if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_MODIFY_FIELD ) )
     {
         const SvxFieldItem* pFldItem = pOutlinerView->GetFieldAtSelection();
@@ -1088,7 +1086,7 @@ void OutlineViewShell::GetMenuState( SfxItemSet &rSet )
         }
     }
 
-    // Starten der Praesentation moeglich?
+    // is starting the presentation possible?
     if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_PRESENTATION ) )
     {
         BOOL bDisable = TRUE;
@@ -1113,7 +1111,7 @@ void OutlineViewShell::GetMenuState( SfxItemSet &rSet )
 
 /*************************************************************************
 |*
-|* wird gerufen, wenn ScrollBar benutzt wird
+|* gets invoked when ScrollBar is used
 |*
 \************************************************************************/
 
@@ -1141,12 +1139,6 @@ long OutlineViewShell::VirtHScrollHdl(ScrollBar* pHScroll)
     return 0;
 }
 
-/*************************************************************************
-|*
-|* wird gerufen, wenn ScrollBar benutzt wird
-|*
-\************************************************************************/
-
 long OutlineViewShell::VirtVScrollHdl(ScrollBar* pVScroll)
 {
     long nThumb = pVScroll->GetThumbPos();
@@ -1174,8 +1166,8 @@ long OutlineViewShell::VirtVScrollHdl(ScrollBar* pVScroll)
 
 /*************************************************************************
 |*
-|* PrepareClose, wird gerufen, wenn die Shell zestoert werden soll,
-|* leitet den Aufruf an die View weiter
+|* PrepareClose, gets called when the Shell shall be destroyed.
+|* Forwards the invocation to the View
 |*
 \************************************************************************/
 
@@ -1190,7 +1182,7 @@ USHORT OutlineViewShell::PrepareClose( BOOL bUI, BOOL bForBrowsing )
 
 /*************************************************************************
 |*
-|* Zoomen mit Zoomfaktor, OutlinerView informieren
+|* Zoom with zoom factor. Inform OutlinerView
 |*
 \************************************************************************/
 
@@ -1201,7 +1193,7 @@ void OutlineViewShell::SetZoom(long nZoom)
     ::sd::Window* pWindow = mpContentWindow.get();
     if (pWindow)
     {
-        // OutputArea der OutlinerView aendern
+        // change OutputArea of OutlinerView
         OutlinerView* pOutlinerView = pOlView->GetViewByWindow(pWindow);
         Rectangle aWin(Point(0,0), pWindow->GetOutputSizePixel());
         aWin = pWindow->PixelToLogic(aWin);
@@ -1214,7 +1206,7 @@ void OutlineViewShell::SetZoom(long nZoom)
 
 /*************************************************************************
 |*
-|* Zoomen mit Zoomrechteck, OutlinerView informieren
+|* Zoom with zoom rectangle. Inform OutlinerView
 |*
 \************************************************************************/
 
@@ -1225,7 +1217,7 @@ void OutlineViewShell::SetZoomRect(const Rectangle& rZoomRect)
     ::sd::Window* pWindow = mpContentWindow.get();
     if (pWindow)
     {
-        // OutputArea der OutlinerView aendern
+        // change OutputArea of OutlinerView
         OutlinerView* pOutlinerView = pOlView->GetViewByWindow(pWindow);
         Rectangle aWin(Point(0,0), pWindow->GetOutputSizePixel());
         aWin = pWindow->PixelToLogic(aWin);
@@ -1238,8 +1230,8 @@ void OutlineViewShell::SetZoomRect(const Rectangle& rZoomRect)
 
 /*************************************************************************
 |*
-|* Vorm Speichern das Model der Drawing Engine aktualisieren, dann den
-|* Call weiterleiten an die ObjectShell.
+|* Before saving: Update Model of the Drawing Engine, then forward the
+|* invocation to the ObjectShell.
 |*
 \************************************************************************/
 
@@ -1299,16 +1291,16 @@ void OutlineViewShell::ReadFrameViewData(FrameView* pView)
     ::Outliner* pOutl = pOlView->GetOutliner();
 
     if ( pView->IsNoAttribs() )
-        pOutl->SetFlatMode( TRUE );   // Attribut-Darstellung ausschalten
+        pOutl->SetFlatMode( TRUE );
     else
-        pOutl->SetFlatMode( FALSE );  // Attribut-Darstellung einschalten
+        pOutl->SetFlatMode( FALSE );
 
     ULONG nCntrl = pOutl->GetControlWord();
 
     if ( pView->IsNoColors() )
-        pOutl->SetControlWord(nCntrl | EE_CNTRL_NOCOLORS);   // Farbansicht ausschalten
+        pOutl->SetControlWord(nCntrl | EE_CNTRL_NOCOLORS);
     else
-        pOutl->SetControlWord(nCntrl & ~EE_CNTRL_NOCOLORS);  // Farbansicht einschalten
+        pOutl->SetControlWord(nCntrl & ~EE_CNTRL_NOCOLORS);
 
     USHORT nPage = mpFrameView->GetSelectedPage();
     pLastPage = GetDoc()->GetSdPage( nPage, PK_STANDARD );
@@ -1342,7 +1334,7 @@ void OutlineViewShell::WriteFrameViewData()
 
 /*************************************************************************
 |*
-|* SfxRequests fuer StatusBar bearbeiten
+|* Handle SfxRequests for the StatusBar
 |*
 \************************************************************************/
 
@@ -1352,7 +1344,7 @@ void OutlineViewShell::ExecStatusBar(SfxRequest&)
 
 /*************************************************************************
 |*
-|* Statuswerte der Statusbar zurueckgeben
+|* Return state values of the StatusBar
 |*
 \************************************************************************/
 
@@ -1366,7 +1358,7 @@ void OutlineViewShell::GetStatusBarState(SfxItemSet& rSet)
 
         pZoomItem = new SvxZoomItem( SVX_ZOOM_PERCENT, nZoom );
 
-        // Bereich einschraenken
+        // limit area
         USHORT nZoomValues = SVX_ZOOM_ENABLE_ALL;
         nZoomValues &= ~SVX_ZOOM_ENABLE_OPTIMAL;
         nZoomValues &= ~SVX_ZOOM_ENABLE_WHOLEPAGE;
@@ -1393,7 +1385,7 @@ void OutlineViewShell::GetStatusBarState(SfxItemSet& rSet)
     }
 
 
-    // Seitenanzeige und Layout
+    // page view and layout
 
     USHORT     nPageCount = GetDoc()->GetSdPageCount( PK_STANDARD );
     String     aPageStr, aLayoutStr;
@@ -1411,12 +1403,12 @@ void OutlineViewShell::GetStatusBarState(SfxItemSet& rSet)
     if( !pOutliner->HasParaFlag(pLastPara, PARAFLAG_ISPAGE) )
         pLastPara = pOlView->GetPrevTitle( pLastPara );
 
-    delete pSelList;                           // die wurde extra fuer uns erzeugt
+    delete pSelList;                           // has been created only for us
 
-    // nur eine Seite selektiert?
+    // only one page selected?
     if( pFirstPara == pLastPara )
     {
-        // wieviele Seiten sind vor der selektierten Seite?
+        // how many pages are we before the selected page?
         ULONG nPos = 0L;
         while( pFirstPara )
         {
@@ -1474,7 +1466,7 @@ void OutlineViewShell::Command( const CommandEvent& rCEvt, ::sd::Window* pWin 
)
     {
         ViewShell::Command( rCEvt, pWin );
 
-        // ggfs. Preview den neuen Kontext mitteilen
+        // if necessary communicate the new context to the Preview
         Invalidate( SID_PREVIEW_STATE );
 
     }
@@ -1497,7 +1489,7 @@ BOOL OutlineViewShell::KeyInput(const KeyEvent& rKEvt, ::sd::Window* pWin)
         bReturn = GetCurrentFunction()->KeyInput(rKEvt);
     }
 
-    // nein, weiterleiten an Basisklasse
+    // no, forward to base class
     else
     {
         bReturn = ViewShell::KeyInput(rKEvt, pWin);
@@ -1511,7 +1503,7 @@ BOOL OutlineViewShell::KeyInput(const KeyEvent& rKEvt, ::sd::Window* pWin)
     Invalidate(SID_STYLE_WATERCAN);
     Invalidate(SID_STYLE_FAMILY5);
 
-    // Pruefen und Unterscheiden von CursorBewegungs- oder Eingabe-Keys
+    // check and distinguish cursor movements- or input-keys
     KeyCode aKeyGroup( rKEvt.GetKeyCode().GetGroup() );
     if( (aKeyGroup != KEYGROUP_CURSOR && aKeyGroup != KEYGROUP_FKEYS) ||
         (GetActualPage() != pLastPage) )
@@ -1525,7 +1517,7 @@ BOOL OutlineViewShell::KeyInput(const KeyEvent& rKEvt, ::sd::Window* pWin)
 
 /*************************************************************************
 |*
-|* Optimale Groesse zurueckgeben
+|* Return optimal Size
 |*
 \************************************************************************/
 
@@ -1548,7 +1540,7 @@ Size OutlineViewShell::GetOptimalSizePixel() const
         }
     }
 
-    // und jetzt jetzt das Standardgelumpe draufaddieren
+    // now add the default stuff
     aResult.Width()  += mpVerticalScrollBar->GetSizePixel().Width();
     aResult.Height() += mpHorizontalScrollBar->GetSizePixel().Height();
     return aResult;
@@ -1557,7 +1549,7 @@ Size OutlineViewShell::GetOptimalSizePixel() const
 
 /*************************************************************************
 |*
-|* Text der Selektion zurueckgeben
+|* Return text of the selection
 |*
 \************************************************************************/
 
@@ -1590,7 +1582,7 @@ String OutlineViewShell::GetSelectionText(BOOL bCompleteWords)
 
 /*************************************************************************
 |*
-|* Ist etwas selektiert?
+|* Is something selected?
 |*
 \************************************************************************/
 
@@ -1614,7 +1606,7 @@ BOOL OutlineViewShell::HasSelection(BOOL bText) const
 
 /*************************************************************************
 |*
-|* Status der Attribut-Items
+|* Status of Attribute-Items
 |*
 \************************************************************************/
 
@@ -1675,7 +1667,7 @@ void OutlineViewShell::GetAttrState( SfxItemSet& rSet )
 
                     if (!aRealStyle.Len())
                     {
-                        // Kein eindeutiger Layoutname gefunden
+                        // no unique layout name found
                         rSet.DisableItem(nWhich);
                     }
                 }
@@ -1690,8 +1682,8 @@ void OutlineViewShell::GetAttrState( SfxItemSet& rSet )
 
                 if (aESel.nStartPara != aESel.nEndPara ||
                     aESel.nStartPos  != aESel.nEndPos)
-                    // aufgespannte Selektion, also StyleSheet und/oder
-                    // Attributierung nicht zwingend eindeutig
+                    // spanned selection, i.e. StyleSheet and/or
+                    // attribution not necessarily unqiue
                     rSet.DisableItem(nWhich);
             }
             break;
@@ -1722,7 +1714,7 @@ void OutlineViewShell::GetAttrState( SfxItemSet& rSet )
 
 void OutlineViewShell::MouseButtonUp(const MouseEvent& rMEvt, ::sd::Window* pWin)
 {
-    // Zuerst die Basisklasse
+    // first the base classes
     ViewShell::MouseButtonUp(rMEvt, pWin);
 
     Invalidate(SID_STYLE_EDIT);
@@ -1733,7 +1725,7 @@ void OutlineViewShell::MouseButtonUp(const MouseEvent& rMEvt, ::sd::Window* 
pWin
     Invalidate(SID_STYLE_WATERCAN);
     Invalidate(SID_STYLE_FAMILY5);
 
-    // ggfs. Preview den neuen Kontext mitteilen
+    // if necessary communicate the new context to the Preview
     if( GetActualPage() != pLastPage )
         Invalidate( SID_PREVIEW_STATE );
 }
@@ -1749,8 +1741,8 @@ SdPage* OutlineViewShell::getCurrentPage() const
 
 /*************************************************************************
 |*
-|* Liefert die erste selektierte Seite zurueck.
-|* Wenn nichts selektiert ist, wird die erste Seite zurueckgeliefert.
+|* Returns the first selected page.
+|* If nothing is selected, the first page is returned.
 |*
 \************************************************************************/
 SdPage* OutlineViewShell::GetActualPage()
@@ -1851,7 +1843,7 @@ String OutlineViewShell::GetPageRangeString()
     if( nPageCount == 0 )
         aStrPageRange.Erase();
 
-    delete pSelList;                           // die wurde extra fuer uns erzeugt
+    delete pSelList;                           // has been created only for us
 
     return aStrPageRange;
 }
@@ -1982,7 +1974,7 @@ bool OutlineViewShell::UpdateOutlineObject( SdPage* pPage, Paragraph* pPara )
         pTO = pOlView->GetOutlineTextObject( pPage );
     }
 
-    // wieviele Absaetze in der Gliederung?
+    // how many paragraphs in the outline?
     ULONG nTitlePara    = pOutliner->GetAbsPos( pPara );
     ULONG nPara          = nTitlePara + 1;
     ULONG nParasInLayout = 0L;
@@ -1994,7 +1986,7 @@ bool OutlineViewShell::UpdateOutlineObject( SdPage* pPage, Paragraph* pPara )
     }
     if( nParasInLayout )
     {
-        // ein OutlinerParaObject erzeugen
+        // create an OutlinerParaObject
         pPara = pOutliner->GetParagraph( nTitlePara + 1 );
         pOPO  = pOutliner->CreateParaObject( (USHORT) nTitlePara + 1, (USHORT) nParasInLayout );
     }
@@ -2010,8 +2002,8 @@ bool OutlineViewShell::UpdateOutlineObject( SdPage* pPage, Paragraph* pPara )
             bNewObject = TRUE;
         }
 
-        // Seitenobjekt, Gliederungstext im Outliner:
-        // Text uebernehmen
+        // page object, outline text in Outliner:
+        // apply text
         if( pTO )
         {
             pOPO->SetVertical( pTO->IsVerticalWriting() );
@@ -2034,16 +2026,17 @@ bool OutlineViewShell::UpdateOutlineObject( SdPage* pPage, Paragraph* pPara 
)
     }
     else if( pTO )
     {
-        // Seitenobjekt, aber kein Gliederungstext:
-        // wenn Objekt in Praesentationsliste der Seite ist -> Defaulttext,
-        // sonst Objekt loeschen
+        // page object but no outline text:
+        // if the object is in the outline of the page -> default text
+
+        // otherwise delete object
         if( pPage->IsPresObj(pTO) )
         {
             if( !pTO->IsEmptyPresObj() )
             {
                 DBG_ASSERT( pOlView->isRecordingUndo(), 
"sd::OutlineViewShell::UpdateOutlineObject(), no undo for model change!?" );
 
-                // loescht auch altes OutlinerParaObject
+                // delete old OutlinerParaObject, too
                 if( pOlView->isRecordingUndo() )
                     
pOlView->AddUndo(GetDoc()->GetSdrUndoFactory().CreateUndoObjectSetText(*pTO,0));
                 pPage->RestoreDefaultText( pTO );
@@ -2066,7 +2059,7 @@ bool OutlineViewShell::UpdateOutlineObject( SdPage* pPage, Paragraph* pPara )
 
 /*************************************************************************
 |*
-|* Outliner aus Stream fuellen
+|* Fill Outliner from Stream
 |*
 \************************************************************************/
 
diff --git a/sd/source/ui/view/outlview.cxx b/sd/source/ui/view/outlview.cxx
index fea4edf..f4a0eab 100644
--- a/sd/source/ui/view/outlview.cxx
+++ b/sd/source/ui/view/outlview.cxx
@@ -88,11 +88,11 @@ using namespace ::com::sun::star::frame;
 
 namespace sd {
 
-// Breite: DIN A 4,  zwei Raender zu je 1 cm
+// width: DIN A4, zwo margins à 1 cm each
 #define OUTLINE_PAPERWIDTH 19000
 
-// beim Seitenmanipulation Fortschrittsanzeige, wenn mehr Seiten betroffen
-// sind als:
+// a progress bar gets displayed when more than
+// PROCESS_WITH_PROGRESS_THRESHOLD pages are concerned
 #define PROCESS_WITH_PROGRESS_THRESHOLD  5
 
 struct SdParaAndPos
@@ -105,7 +105,7 @@ TYPEINIT1( OutlineView, ::sd::View );
 
 /*************************************************************************
 |*
-|* Konstruktor
+|* Constructor
 |*
 \************************************************************************/
 
@@ -127,7 +127,7 @@ OutlineView::OutlineView( DrawDocShell* pDocSh, ::Window* pWindow, OutlineViewSh
 
     if (mpOutliner->GetViewCount() == 0)
     {
-        // Outliner initialisieren: Referenz-Device setzen
+        // initialize Outliner: set Reference Device
         bInitOutliner = TRUE;
         mpOutliner->Init( OUTLINERMODE_OUTLINEVIEW );
         mpOutliner->SetRefDevice( SD_MOD()->GetRefDevice( *pDocSh ) );
@@ -135,7 +135,7 @@ OutlineView::OutlineView( DrawDocShell* pDocSh, ::Window* pWindow, OutlineViewSh
         mpOutliner->SetPaperSize(Size(nWidth, 400000000));
     }
 
-    // View in Outliner einfuegen
+    // insert View into Outliner
     for (USHORT nView = 0; nView < MAX_OUTLINERVIEWS; nView++)
     {
         mpOutlinerView[nView] = NULL;
@@ -151,7 +151,7 @@ OutlineView::OutlineView( DrawDocShell* pDocSh, ::Window* pWindow, OutlineViewSh
 
     if (bInitOutliner)
     {
-        // Outliner mit Inhalt fuellen
+        // fill Outliner with contents
         FillOutliner();
     }
 
@@ -191,7 +191,7 @@ OutlineView::OutlineView( DrawDocShell* pDocSh, ::Window* pWindow, OutlineViewSh
 
 /*************************************************************************
 |*
-|* Destruktor, Links restaurieren, Outliner leeren
+|* Destructor, restore Links, clear Oultiner
 |*
 \************************************************************************/
 
@@ -206,7 +206,7 @@ OutlineView::~OutlineView()
     if( mpProgress )
         delete mpProgress;
 
-    // OutlinerViews abmelden und zerstoeren
+    // unregister OutlinerViews and destroy them
     for (USHORT nView = 0; nView < MAX_OUTLINERVIEWS; nView++)
     {
         if (mpOutlinerView[nView] != NULL)
@@ -219,10 +219,10 @@ OutlineView::~OutlineView()
 
     if (mpOutliner->GetViewCount() == 0)
     {
-        // Outliner deinitialisieren: Farbdarstellung einschalten
+        // uninitialize Outliner: enable color display
         ResetLinks();
         ULONG nCntrl = mpOutliner->GetControlWord();
-        mpOutliner->SetUpdateMode(FALSE); // sonst wird bei SetControlWord gezeichnet
+        mpOutliner->SetUpdateMode(FALSE); // otherwise there will be drawn on SetControlWord
         mpOutliner->SetControlWord(nCntrl & ~EE_CNTRL_NOCOLORS);
         SvtAccessibilityOptions aOptions;
         mpOutliner->ForceAutoColor( aOptions.GetIsAutomaticFontColor() );
@@ -255,7 +255,7 @@ void OutlineView::DisconnectFromApplication (void)
 
 /*************************************************************************
 |*
-|* Paint-Methode
+|* Paint method
 |*
 \************************************************************************/
 
@@ -280,7 +280,7 @@ void OutlineView::InvalidateSlideNumberArea()
 
 /*************************************************************************
 |*
-|* Fenster-Groesse hat sich geaendert
+|* Window size was changed
 |*
 \************************************************************************/
 
@@ -290,7 +290,7 @@ void OutlineView::AdjustPosSizePixel(const Point &,const Size &,::sd::Window*)
 
 /*************************************************************************
 |*
-|* ein Fenster hinzufuegen
+|* add a window
 |*
 \************************************************************************/
 
@@ -325,7 +325,7 @@ void OutlineView::AddWindowToPaintView(OutputDevice* pWin)
         nView++;
     }
 
-    // weisser Hintergrund im Outliner
+    // white background in Outliner
     pWin->SetBackground( Wallpaper( aWhiteColor ) );
 
     ::sd::View::AddWindowToPaintView(pWin);
@@ -333,7 +333,7 @@ void OutlineView::AddWindowToPaintView(OutputDevice* pWin)
 
 /*************************************************************************
 |*
-|* ein Fenster entfernen
+|* remove a window
 |*
 \************************************************************************/
 
@@ -366,7 +366,7 @@ void OutlineView::DeleteWindowFromPaintView(OutputDevice* pWin)
 
 /*************************************************************************
 |*
-|* Zeiger der dem Fenster entsprechenden OutlinerView zurueckgeben.
+|* Return a pointer to the OutlinerView corresponding to the window
 |*
 \************************************************************************/
 
@@ -389,7 +389,7 @@ OutlinerView* OutlineView::GetViewByWindow (::Window* pWin) const
 
 /*************************************************************************
 |*
-|* Ermittelt den Titel vor einem beliebigen Absatz.
+|* Return the title before a random paragraph
 |*
 \************************************************************************/
 
@@ -414,7 +414,7 @@ Paragraph* OutlineView::GetPrevTitle(const Paragraph* pPara)
 
 /*************************************************************************
 |*
-|* Ermittelt den Titel nach einem beliebigen Absatz.
+|* Return the title after a random paragraph
 |*
 \************************************************************************/
 
@@ -437,14 +437,12 @@ Paragraph* OutlineView::GetNextTitle(const Paragraph* pPara)
 
 /*************************************************************************
 |*
-|* Handler fuer das Einfuegen von Seiten (Absaetzen)
+|* Handler for inserting pages (paragraphs)
 |*
 \************************************************************************/
 
 IMPL_LINK( OutlineView, ParagraphInsertedHdl, ::Outliner *, pOutliner )
 {
-//     DBG_ASSERT( isRecordingUndo(), "sd::OutlineView::ParagraphInsertedHdl(), model change 
without undo?!" );
-
     // we get calls to this handler during binary insert of drag and drop contents but
     // we ignore it here and handle it later in OnEndPasteOrDrop()
     if( maDragAndDropModelGuard.get() == 0 )
@@ -475,9 +473,9 @@ SdPage* OutlineView::InsertSlideForParagraph( Paragraph* pPara )
     OutlineViewPageChangesGuard aGuard(this);
 
     mpOutliner->SetParaFlag( pPara, PARAFLAG_ISPAGE );
-    // wieviele Titel sind vor dem neuen Titelabsatz?
-    ULONG nExample = 0L;                       // Position der "Vorbild"seite
-    ULONG nTarget  = 0L;                       // Einfuegeposition
+    // how many titles are there before the new title paragraph?
+    ULONG nExample = 0L;                       // position of the "example" page
+    ULONG nTarget  = 0L;                       // position of insertion
     while(pPara)
     {
         pPara = GetPrevTitle(pPara);
@@ -485,11 +483,9 @@ SdPage* OutlineView::InsertSlideForParagraph( Paragraph* pPara )
             nTarget++;
     }
 
-
-    // was der Outliner nicht kann, muss hier wieder wettgemacht werden:
-    // wenn VOR dem ersten Absatz ein neuer Absatz mit RETURN erzeugt wird,
-    // meldet der Outliner den bereits bestehenden (jetzt nach unten
-    // gerutschten) Absatz als neuen Absatz; nicht darauf reinfallen!
+    // if a new paragraph is created via RETURN before the first paragraph, the
+    // Outliner reports the old paragraph (which was moved down) as a new
+    // paragraph
     if (nTarget == 1)
     {
         String aTest(mpOutliner->GetText( mpOutliner->GetParagraph( 0 ) ));
@@ -500,7 +496,7 @@ SdPage* OutlineView::InsertSlideForParagraph( Paragraph* pPara )
     }
 
 
-    // "Vorbild"seite ist - wenn vorhanden - die Vorgaengerseite
+    // the "example" page is the previous page - if it is available
     if (nTarget > 0)
     {
         nExample = nTarget - 1;
@@ -511,36 +507,35 @@ SdPage* OutlineView::InsertSlideForParagraph( Paragraph* pPara )
     }
 
     /**********************************************************************
-    * Es wird stets zuerst eine Standardseite und dann eine
-    * Notizseite erzeugt. Es ist sichergestellt, dass auf eine
-    * Standardseite stets die zugehoerige Notizseite folgt.
-    * Vorangestellt ist genau eine Handzettelseite
+    * All the time, a standard page is created before a notes page.
+    * It is ensured that after each standard page the corresponding notes page
+    * follows. A handout page is exactly one handout page.
     **********************************************************************/
 
-    // diese Seite hat Vorbildfunktion
+    // this page is exemplary
     SdPage* pExample = (SdPage*)mpDoc->GetSdPage((USHORT)nExample, PK_STANDARD);
     SdPage* pPage = (SdPage*)mpDoc->AllocPage(FALSE);
 
     pPage->SetLayoutName(pExample->GetLayoutName());
 
-    // einfuegen (Seite)
+    // insert (page)
     mpDoc->InsertPage(pPage, (USHORT)(nTarget) * 2 + 1);
     if( isRecordingUndo() )
         AddUndo(mpDoc->GetSdrUndoFactory().CreateUndoNewPage(*pPage));
 
-    // der Standardseite eine Masterpage zuweisen
+    // assign a master page to the standard page
     pPage->TRG_SetMasterPage(pExample->TRG_GetMasterPage());
 
-    // Seitengroesse setzen
+    // set page size
     pPage->SetSize(pExample->GetSize());
     pPage->SetBorder( pExample->GetLftBorder(),
                       pExample->GetUppBorder(),
                       pExample->GetRgtBorder(),
                       pExample->GetLwrBorder() );
 
-    // neue Praesentationsobjekte anlegen (auf <Titel> oder
-    // <Titel mit Untertitel> folgt <Titel mit Gliederung>, ansonsten
-    // wird das Layout von der Vorgaengerseite uebernommen)
+    // create new presentation objects (after <Title> or <Title with subtitle>
+    // follows <Title with outline>, otherwise apply the layout of the previous
+    // page
     AutoLayout eAutoLayout = pExample->GetAutoLayout();
     if (eAutoLayout == AUTOLAYOUT_TITLE ||
         eAutoLayout == AUTOLAYOUT_ONLY_TITLE)
@@ -553,7 +548,7 @@ SdPage* OutlineView::InsertSlideForParagraph( Paragraph* pPara )
     }
 
     /**********************************************************************
-    |* jetzt die Notizseite
+    |* now the notes page
     \*********************************************************************/
     pExample = (SdPage*)mpDoc->GetSdPage((USHORT)nExample, PK_NOTES);
     SdPage* pNotesPage = (SdPage*)mpDoc->AllocPage(FALSE);
@@ -562,22 +557,22 @@ SdPage* OutlineView::InsertSlideForParagraph( Paragraph* pPara )
 
     pNotesPage->SetPageKind(PK_NOTES);
 
-    // einfuegen (Notizseite)
+    // insert (notes page)
     mpDoc->InsertPage(pNotesPage, (USHORT)(nTarget) * 2 + 2);
     if( isRecordingUndo() )
         AddUndo(mpDoc->GetSdrUndoFactory().CreateUndoNewPage(*pNotesPage));
 
-    // der Notizseite eine Masterpage zuweisen
+    // assign a master page to the notes page
     pNotesPage->TRG_SetMasterPage(pExample->TRG_GetMasterPage());
 
-    // Seitengroesse setzen, es muss bereits eine Seite vorhanden sein
+    // set page size, there must be already one page available
     pNotesPage->SetSize(pExample->GetSize());
     pNotesPage->SetBorder( pExample->GetLftBorder(),
                            pExample->GetUppBorder(),
                            pExample->GetRgtBorder(),
                            pExample->GetLwrBorder() );
 
-    // neue Praesentationsobjekte anlegen
+    // create presentation objects
     pNotesPage->SetAutoLayout(pExample->GetAutoLayout(), TRUE);
 
     mpOutliner->UpdateFields();
@@ -587,7 +582,7 @@ SdPage* OutlineView::InsertSlideForParagraph( Paragraph* pPara )
 
 /*************************************************************************
 |*
-|* Handler fuer das Loeschen von Seiten (Absaetzen)
+|* Handler for deleting pages (paragraphs)
 |*
 \************************************************************************/
 
@@ -600,7 +595,7 @@ IMPL_LINK( OutlineView, ParagraphRemovingHdl, ::Outliner *, pOutliner )
     Paragraph* pPara = pOutliner->GetHdlParagraph();
     if( pOutliner->HasParaFlag( pPara, PARAFLAG_ISPAGE ) )
     {
-        // wieviele Titel sind vor dem fraglichen Titelabsatz?
+        // how many titles are in front of the title paragraph in question?
         ULONG nPos = 0L;
         while(pPara)
         {
@@ -608,7 +603,7 @@ IMPL_LINK( OutlineView, ParagraphRemovingHdl, ::Outliner *, pOutliner )
             if (pPara) nPos++;
         }
 
-        // Seite und Notizseite loeschen
+        // delete page and notes page
         USHORT nAbsPos = (USHORT)nPos * 2 + 1;
         SdrPage* pPage = mpDoc->GetPage(nAbsPos);
         if( isRecordingUndo() )
@@ -621,7 +616,7 @@ IMPL_LINK( OutlineView, ParagraphRemovingHdl, ::Outliner *, pOutliner )
             AddUndo(mpDoc->GetSdrUndoFactory().CreateUndoDeletePage(*pPage));
         mpDoc->RemovePage(nAbsPos);
 
-        // ggfs. Fortschrittsanzeige
+        // progress display if necessary
         if (mnPagesToProcess)
         {
             mnPagesProcessed++;
@@ -650,8 +645,8 @@ IMPL_LINK( OutlineView, ParagraphRemovingHdl, ::Outliner *, pOutliner )
 
 /*************************************************************************
 |*
-|* Handler fuer das Aendern der Einruecktiefe von Absaetzen (macht ggfs.
-|* das Einfuegen oder Loeschen von Seiten notwendig)
+|* Handler for changing the indentation depth of paragraphs (requires inserting
+|* or deleting of pages in some cases)
 |*
 \************************************************************************/
 
@@ -668,9 +663,8 @@ IMPL_LINK( OutlineView, DepthChangedHdl, ::Outliner *, pOutliner )
 
         mpOutliner->SetDepth( pPara, -1 );
 
-        // werden da etwa mehrere Level-1-Absaetze auf Level 0 gebracht und
-        // wir sollten eine Fortschrittsanzeige oder Eieruhr aufsetzen und
-        // haben es noch nicht getan?
+        // are multiple level 1 paragraphs being brought to level 0 and we
+        // should start a progress view or a timer and didn't already?
         if (mnPagesToProcess == 0)
         {
             Window*      pActWin = mpOutlineViewShell->GetActiveWindow();
@@ -685,8 +679,8 @@ IMPL_LINK( OutlineView, DepthChangedHdl, ::Outliner *, pOutliner )
                 pParagraph = (Paragraph*)pList->Next();
             }
 
-            mnPagesToProcess++;        // der Absatz, der jetzt schon auf Level 0
-                                // steht, gehoert auch dazu
+            mnPagesToProcess++;        // the paragraph being in level 0 already
+                                // should be included
             mnPagesProcessed = 0;
 
             if (mnPagesToProcess > PROCESS_WITH_PROGRESS_THRESHOLD)
@@ -708,14 +702,14 @@ IMPL_LINK( OutlineView, DepthChangedHdl, ::Outliner *, pOutliner )
 
         mnPagesProcessed++;
 
-        // muss eine Fortschrittsanzeige gepflegt werden?
+        // should there be a progress display?
         if (mnPagesToProcess > PROCESS_WITH_PROGRESS_THRESHOLD)
         {
             if (mpProgress)
                 mpProgress->SetState(mnPagesProcessed);
         }
 
-        // war das die letzte Seite?
+        // was this the last page?
         if (mnPagesProcessed == mnPagesToProcess)
         {
             if (mnPagesToProcess > PROCESS_WITH_PROGRESS_THRESHOLD && mpProgress)
@@ -744,7 +738,7 @@ IMPL_LINK( OutlineView, DepthChangedHdl, ::Outliner *, pOutliner )
             if (pParagraph)
                 nPos++;
         }
-        // Seite und Notizseite loeschen
+        // delete page and notes page
 
         USHORT nAbsPos = (USHORT)nPos * 2 + 1;
         SdrPage* pPage = mpDoc->GetPage(nAbsPos);
@@ -762,7 +756,7 @@ IMPL_LINK( OutlineView, DepthChangedHdl, ::Outliner *, pOutliner )
 
         mpOutliner->SetDepth( pPara, (pPage && (static_cast<SdPage*>(pPage)->GetAutoLayout() == 
AUTOLAYOUT_TITLE)) ?  -1 : 0 );
 
-        // ggfs. Fortschrittsanzeige
+        // progress display if necessary
         if (mnPagesToProcess)
         {
             mnPagesProcessed++;
@@ -784,7 +778,7 @@ IMPL_LINK( OutlineView, DepthChangedHdl, ::Outliner *, pOutliner )
     }
     else if ( (pOutliner->GetPrevDepth() == 1) && ( pOutliner->GetDepth( (USHORT) 
pOutliner->GetAbsPos( pPara ) ) == 2 ) )
     {
-        // wieviele Titel sind vor dem fraglichen Titelabsatz?
+        // how many titles are in front of the title paragraph in question?
         sal_Int32 nPos = -1L;
 
         Paragraph* pParagraph = pPara;
@@ -804,7 +798,7 @@ IMPL_LINK( OutlineView, DepthChangedHdl, ::Outliner *, pOutliner )
         }
 
     }
-    // wieviele Titel sind vor dem fraglichen Titelabsatz?
+    // how many titles are in front of the title paragraph in question?
     sal_Int32 nPos = -1L;
 
     Paragraph* pTempPara = pPara;
@@ -872,7 +866,7 @@ IMPL_LINK( OutlineView, DepthChangedHdl, ::Outliner *, pOutliner )
 
 /*************************************************************************
 |*
-|* Handler fuer StatusEvents
+|* Handler for StatusEvents
 |*
 \************************************************************************/
 
@@ -888,7 +882,7 @@ IMPL_LINK( OutlineView, StatusEventHdl, EditStatus *, EMPTYARG )
     Rectangle aWin(Point(0,0), pWin->GetOutputSizePixel());
     aWin = pWin->PixelToLogic(aWin);
 
-    if (!aVis.IsEmpty())               // nicht beim Oeffnen
+    if (!aVis.IsEmpty())               // not when opening
     {
         aText.Bottom() += aWin.GetHeight();
 
@@ -918,7 +912,7 @@ IMPL_LINK( OutlineView, EndDropHdl, void *, EMPTYARG )
 
 /*************************************************************************
 |*
-|* Handler fuer den Beginn einer Absatzverschiebung
+|* Handler for the start of a paragraph movement
 |*
 \************************************************************************/
 
@@ -931,7 +925,7 @@ IMPL_LINK( OutlineView, BeginMovingHdl, ::Outliner *, pOutliner )
 
     mpOldParaOrder = new List;
 
-    // Liste der selektierten Titelabsaetze
+    // list of selected title paragraphs
     mpSelectedParas = mpOutlinerView[0]->CreateSelectionList();
     Paragraph* pPara = static_cast<Paragraph*>(mpSelectedParas->First());
     while (pPara)
@@ -947,20 +941,19 @@ IMPL_LINK( OutlineView, BeginMovingHdl, ::Outliner *, pOutliner )
         }
     }
 
-    // Die zu den selektierten Absaetzen auf Ebene 0 gehoerenden Seiten
-    // selektieren
+    // select the pages belonging to the paragraphs on level 0 to select
     USHORT nPos = 0;
     ULONG nParaPos = 0;
     pPara = pOutliner->GetParagraph( 0 );
 
     while(pPara)
     {
-        if( pOutliner->HasParaFlag(pPara, PARAFLAG_ISPAGE) )                     // eine Seite?
+        if( pOutliner->HasParaFlag(pPara, PARAFLAG_ISPAGE) )                     // one page?
         {
             mpOldParaOrder->Insert(pPara, LIST_APPEND);
             SdPage* pPage = mpDoc->GetSdPage(nPos, PK_STANDARD);
             pPage->SetSelected(FALSE);
-            if (mpSelectedParas->Seek(pPara))            // selektiert?
+            if (mpSelectedParas->Seek(pPara))            // selected?
             {
                 pPage->SetSelected(TRUE);
             }
@@ -974,7 +967,7 @@ IMPL_LINK( OutlineView, BeginMovingHdl, ::Outliner *, pOutliner )
 
 /*************************************************************************
 |*
-|* Handler fuer das Ende einer Absatzverschiebung
+|* Handler for the end of a paragraph movement
 |*
 \************************************************************************/
 
@@ -986,10 +979,10 @@ IMPL_LINK( OutlineView, EndMovingHdl, ::Outliner *, pOutliner )
     DBG_ASSERT(mpOldParaOrder, "keine Absatzliste");
     DBG_ASSERT( isRecordingUndo(), "sd::OutlineView::EndMovingHdl(), model change without undo?!" 
);
 
-    // Einfuegeposition anhand des ersten Absatzes suchen
+    // look for insertion position via the first paragraph
     Paragraph* pSearchIt = (Paragraph*)mpSelectedParas->First();
 
-    // den ersten der selektierten Paragraphen in der neuen Ordnung suchen
+    // look for the first of the selected paragraphs in the new ordering
     USHORT nPosNewOrder = 0;
     ULONG nParaPos = 0;
     Paragraph* pPara = pOutliner->GetParagraph( 0 );
@@ -1004,21 +997,21 @@ IMPL_LINK( OutlineView, EndMovingHdl, ::Outliner *, pOutliner )
         pPara = pOutliner->GetParagraph( ++nParaPos );
     }
 
-    USHORT nPos = nPosNewOrder;        // nPosNewOrder nicht veraendern
+    USHORT nPos = nPosNewOrder;        // don't change nPosNewOrder
     if (nPos == 0)
     {
-        nPos = (USHORT)-1;                     // vor der ersten Seite einfuegen
+        nPos = (USHORT)-1;                     // insert before the first page
     }
     else
     {
-        // den Vorgaenger in der alten Ordnung suchen
+        // look for the predecessor in the old ordering
         nPos = (USHORT)mpOldParaOrder->GetPos(pPrev);
         DBG_ASSERT(nPos != 0xffff, "Absatz nicht gefunden");
     }
 
     mpDoc->MovePages(nPos);
 
-    // die Seiten wieder deselektieren
+    // deselect the pages again
     USHORT nPageCount = (USHORT)mpSelectedParas->Count();
     while (nPageCount)
     {
@@ -1042,7 +1035,7 @@ IMPL_LINK( OutlineView, EndMovingHdl, ::Outliner *, pOutliner )
 
 /*************************************************************************
 |*
-|* Eine Seite des Models nach dem Titeltextobjekt durchsuchen
+|* Look for the title text object in one page of the model
 |*
 \************************************************************************/
 
@@ -1068,7 +1061,7 @@ SdrTextObj* OutlineView::GetTitleTextObject(SdrPage* pPage)
 
 /*************************************************************************
 |*
-|* Eine Seite des Models nach dem Gliederungstextobjekt durchsuchen
+|* Look for the outline text object in one page of the model
 |*
 \************************************************************************/
 
@@ -1166,7 +1159,7 @@ BOOL OutlineView::PrepareClose(BOOL)
 
 /*************************************************************************
 |*
-|* Attribute des selektierten Textes setzen
+|* Set attributes of the selected text
 |*
 \************************************************************************/
 
@@ -1189,7 +1182,7 @@ BOOL OutlineView::SetAttributes(const SfxItemSet& rSet, BOOL )
 
 /*************************************************************************
 |*
-|* Attribute des selektierten Textes erfragen
+|* Get attributes of the selected text
 |*
 \************************************************************************/
 
@@ -1240,7 +1233,7 @@ void OutlineView::FillOutliner()
             pPara = mpOutliner->Insert(String());
             mpOutliner->SetDepth(pPara, -1);
 
-            // Keine harten Attribute vom vorherigen Absatz uebernehmen
+            // do not apply hard attributes from the previous paragraph
             mpOutliner->SetParaAttribs( (USHORT)mpOutliner->GetAbsPos(pPara),
                                        mpOutliner->GetEmptyItemSet() );
 
@@ -1309,7 +1302,7 @@ void OutlineView::FillOutliner()
 
 /*************************************************************************
 |*
-|* Handler fuer das Loeschen von Level-0-Absaetzen (Seiten): Warnung
+|* Handler for deleting of level 0 paragraphs (pages): Warning
 |*
 \************************************************************************/
 
@@ -1340,7 +1333,7 @@ IMPL_LINK( OutlineView, RemovingPagesHdl, OutlinerView *, EMPTYARG )
 
 /*************************************************************************
 |*
-|* Handler fuer das Einruecken von Level-0-Absaetzen (Seiten): Warnung
+|* Handler for indenting level 0 paragraphs (pages): Warning
 |*
 \************************************************************************/
 
@@ -1431,7 +1424,7 @@ void OutlineView::SetActualPage( SdPage* pActual )
 
 /*************************************************************************
 |*
-|* StyleSheet aus der Selektion besorgen
+|* Get StyleSheet from the selection
 |*
 \************************************************************************/
 
@@ -1447,13 +1440,13 @@ SfxStyleSheet* OutlineView::GetStyleSheet() const
 
 /*************************************************************************
 |*
-|* Seiten als selektiert / nicht selektiert setzen
+|* Mark pages as selected / not selected
 |*
 \************************************************************************/
 
 void OutlineView::SetSelectedPages()
 {
-    // Liste der selektierten Titelabsaetze
+    // list of selected title paragraphs
     List* pSelParas = mpOutlinerView[0]->CreateSelectionList();
     Paragraph* pPara = (Paragraph*) pSelParas->First();
 
@@ -1470,15 +1463,14 @@ void OutlineView::SetSelectedPages()
         }
     }
 
-    // Die zu den selektierten Absaetzen auf Ebene 0 gehoerenden Seiten
-    // selektieren
+    // select the pages belonging to the paragraphs on level 0 to select
     USHORT nPos = 0;
     ULONG nParaPos = 0;
     pPara = mpOutliner->GetParagraph( 0 );
 
     while(pPara)
     {
-        if( mpOutliner->HasParaFlag(pPara, PARAFLAG_ISPAGE) )                     // eine Seite?
+        if( mpOutliner->HasParaFlag(pPara, PARAFLAG_ISPAGE) )                     // one page
         {
             SdPage* pPage = mpDoc->GetSdPage(nPos, PK_STANDARD);
             DBG_ASSERT(pPage!=NULL,
@@ -1487,7 +1479,7 @@ void OutlineView::SetSelectedPages()
             {
                 pPage->SetSelected(FALSE);
 
-                if (pSelParas->Seek(pPara))            // selektiert?
+                if (pSelParas->Seek(pPara))            // selected?
                     pPage->SetSelected(TRUE);
             }
 
@@ -1501,13 +1493,13 @@ void OutlineView::SetSelectedPages()
 
 /*************************************************************************
 |*
-|* Neue Links setzen
+|* Set new links
 |*
 \************************************************************************/
 
 void OutlineView::SetLinks()
 {
-    // Benachrichtigungs-Links setzen
+    // set notification links
     mpOutliner->SetParaInsertedHdl(LINK(this, OutlineView, ParagraphInsertedHdl));
     mpOutliner->SetParaRemovingHdl(LINK(this, OutlineView, ParagraphRemovingHdl));
     mpOutliner->SetDepthChangedHdl(LINK(this, OutlineView, DepthChangedHdl));
@@ -1527,13 +1519,12 @@ void OutlineView::SetLinks()
 
 /*************************************************************************
 |*
-|* Alte Links restaurieren
+|* Restore old links
 |*
 \************************************************************************/
 
 void OutlineView::ResetLinks() const
 {
-    // alte Links restaurieren
     Link aEmptyLink;
     mpOutliner->SetParaInsertedHdl(aEmptyLink);
     mpOutliner->SetParaRemovingHdl(aEmptyLink);
diff --git a/sd/source/ui/view/zoomlist.cxx b/sd/source/ui/view/zoomlist.cxx
index 7ca7b48..34cbb44 100644
--- a/sd/source/ui/view/zoomlist.cxx
+++ b/sd/source/ui/view/zoomlist.cxx
@@ -45,7 +45,7 @@ namespace sd {
 
 /*************************************************************************
 |*
-|* Konstruktor
+|* Constructor
 |*
 \************************************************************************/
 
@@ -59,7 +59,7 @@ ZoomList::ZoomList(ViewShell* pViewShell)
 
 /*************************************************************************
 |*
-|* Destruktor
+|* Destructor
 |*
 \************************************************************************/
 
@@ -71,7 +71,7 @@ ZoomList::~ZoomList()
     for (ULONG nObject=0; nObject<Count(); nObject++)
 #endif
     {
-        // Ggf. ZoomRects loeschen
+        // delete ZoomRects if necessary
         delete ((Rectangle*) GetObject(nObject));
     }
 }
@@ -79,7 +79,7 @@ ZoomList::~ZoomList()
 
 /*************************************************************************
 |*
-|* Neues ZoomRect aufnehmen
+|* Insert new ZoomRect
 |*
 \************************************************************************/
 
@@ -111,7 +111,7 @@ void ZoomList::InsertZoomRect(const Rectangle& rRect)
 
 /*************************************************************************
 |*
-|* Naechstes ZoomRect herausgeben
+|* Return next ZoomRect
 |*
 \************************************************************************/
 
@@ -135,7 +135,7 @@ Rectangle ZoomList::GetNextZoomRect()
 
 /*************************************************************************
 |*
-|* Letztes ZoomRect herausgeben
+|* Return last ZoomRect
 |*
 \************************************************************************/
 
@@ -156,7 +156,7 @@ Rectangle ZoomList::GetPreviousZoomRect()
 
 /*************************************************************************
 |*
-|* Gibt es ein naechstes ZoomRect?
+|* Is there a next ZoomRect?
 |*
 \************************************************************************/
 
@@ -175,7 +175,7 @@ BOOL ZoomList::IsNextPossible() const
 
 /*************************************************************************
 |*
-|* Gibt es ein vorheriges ZoomRect?
+|* Is there a previous ZoomRect?
 |*
 \************************************************************************/
 
-- 
1.7.4.1


Context


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