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