mir/libreoffice
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fdo#39468 translate German comments

Browse Source 
Change-Id: I36e3d7950d64a927ac6f081cf4b163fccd2f4786
Reviewed-on: https://gerrit.libreoffice.org/13549
Reviewed-by: Noel Grandin <noelgrandin@gmail.com>
Tested-by: Noel Grandin <noelgrandin@gmail.com>
This commit is contained in:
Michael Weghorn
2014-12-19 16:16:28 +01:00
committed by Noel Grandin
parent 8abd002240
commit 1ac3ad7743
3 changed files with 156 additions and 155 deletions
Download Patch File Download Diff File Expand all files Collapse all files

111
include/svtools/parhtml.hxx
View File

@@ -74,44 +74,44 @@ enum HTMLScriptLanguage
struct HTMLOptionEnum
{
const sal_Char *pName; // Wert einer HTML-Option
sal_uInt16 nValue; // und der dazugehoerige Wert eines Enums
const sal_Char *pName; // value of an HTML option
sal_uInt16 nValue; // and corresponding value of an enum
};
// Repraesentation einer HTML-Option (=Atrribut in einem Start-Tag)
// Die Werte der Optionen werden immer als String gespeichert.
// Die Methoden GetNumber, ... duerfen nur aufgerufen werden, wenn
// die Option auch numerisch, ... ist.
/** Representation of an HTML option (=attribute in a start tag).
* The values of the options are always stored as strings.
* The methods GetNumber,... may only be called if the option
* is actually numerical,...
*/
class SVT_DLLPUBLIC HTMLOption
{
OUString aValue; // der Wert der Option (immer als String)
OUString aToken; // der Name der Option als String
sal_uInt16 nToken; // und das entsprechende Token
OUString aValue; // value of the option (always as string)
OUString aToken; // name of the option as string
sal_uInt16 nToken; // and respective token
public:
HTMLOption( sal_uInt16 nTyp, const OUString& rToken, const OUString& rValue );
// der Name der Option ...
sal_uInt16 GetToken() const { return nToken; } // ... als Enum
const OUString& GetTokenString() const { return aToken; } // ... als String
// name of the option...
sal_uInt16 GetToken() const { return nToken; } // ... as enum
const OUString& GetTokenString() const { return aToken; } // ... as string
// der Wert der Option ...
const OUString& GetString() const { return aValue; } // ... als String
// value of the option ...
const OUString& GetString() const { return aValue; } // ... as string
sal_uInt32 GetNumber() const; // ... als Zahl
sal_Int32 GetSNumber() const; // ... als Zahl
void GetNumbers( std::vector<sal_uInt32> &rNumbers, // ... als Zahlen
sal_uInt32 GetNumber() const; // ... as number
sal_Int32 GetSNumber() const; // ... as number
void GetNumbers( std::vector<sal_uInt32> &rNumbers, // ... as numbers
bool bSpaceDelim=false ) const;
void GetColor( Color& ) const; // ... als Farbe
void GetColor( Color& ) const; // ... as color
// ... als Enum pOptEnums ist ein HTMLOptionEnum-Array
// ... as enum; pOptEnums is an HTMLOptionEnum array
sal_uInt16 GetEnum( const HTMLOptionEnum *pOptEnums,
sal_uInt16 nDflt=0 ) const;
bool GetEnum( sal_uInt16 &rEnum, const HTMLOptionEnum *pOptEnums ) const;
// ... und als ein par spezielle Enums
// ... and as a few special enums
HTMLInputType GetInputType() const; // <INPUT TYPE=...>
HTMLTableFrame GetTableFrame() const; // <TABLE FRAME=...>
HTMLTableRules GetTableRules() const; // <TABLE RULES=...>
@@ -123,37 +123,37 @@ typedef ::boost::ptr_vector<HTMLOption> HTMLOptions;
class SVT_DLLPUBLIC HTMLParser : public SvParser
{
private:
mutable HTMLOptions maOptions; // die Optionen des Start-Tags
mutable HTMLOptions maOptions; // options of the start tag
bool bNewDoc : 1; // neues Doc lesen ?
bool bIsInHeader : 1; // scanne Header-Bereich
bool bIsInBody : 1; // scanne Body-Bereich
bool bReadListing : 1; // Lese Listings
bool bReadXMP : 1; // Lese XMP
bool bReadPRE : 1; // Lese preformatted Text
bool bReadTextArea : 1; // Lese TEXTAREA
bool bReadScript : 1; // Lesen von <SCRIPT>
bool bReadStyle : 1; // Lesen von <STYLE>
bool bEndTokenFound : 1; // </SCRIPT> oder </STYLE> gefunden
bool bNewDoc : 1; // read new Doc?
bool bIsInHeader : 1; // scan header section
bool bIsInBody : 1; // scan body section
bool bReadListing : 1; // read listings
bool bReadXMP : 1; // read XMP
bool bReadPRE : 1; // read preformatted text
bool bReadTextArea : 1; // read TEXTAREA
bool bReadScript : 1; // read <SCRIPT>
bool bReadStyle : 1; // read <STYLE>
bool bEndTokenFound : 1; // found </SCRIPT> or </STYLE>
bool bPre_IgnoreNewPara : 1; // Flags fuers lesen von PRE-Absaetzen
bool bReadNextChar : 1; // true: NextChar nochmals lesen (JavaScript!)
bool bReadComment : 1; // true: NextChar nochmals lesen (JavaScript!)
bool bPre_IgnoreNewPara : 1; // flags for reading of PRE paragraphs
bool bReadNextChar : 1; // true: read NextChar again(JavaScript!)
bool bReadComment : 1; // true: read NextChar again (JavaScript!)
sal_uInt32 nPre_LinePos; // Pos in der Line im PRE-Tag
sal_uInt32 nPre_LinePos; // Pos in the line in the PRE-Tag
int mnPendingOffToken; ///< OFF token pending for a <XX.../> ON/OFF ON token
OUString aEndToken;
protected:
OUString sSaveToken; // das gelesene Tag als String
OUString sSaveToken; // the read tag as string
int ScanText( const sal_Unicode cBreak = 0U );
int _GetNextRawToken();
// scanne das naechste Token,
// scan next token
virtual int _GetNextToken() SAL_OVERRIDE;
virtual ~HTMLParser();
@@ -163,7 +163,7 @@ protected:
public:
HTMLParser( SvStream& rIn, bool bReadNewDoc = true );
virtual SvParserState CallParser() SAL_OVERRIDE; // Aufruf des Parsers
virtual SvParserState CallParser() SAL_OVERRIDE;
bool IsNewDoc() const { return bNewDoc; }
bool IsInHeader() const { return bIsInHeader; }
@@ -177,8 +177,7 @@ public:
void SetReadNextChar() { bReadNextChar = true; }
// PRE-/LISTING oder XMP-Modus starten/beenden oder Tags entsprechend
// filtern
// start PRE-/LISTING or XMP mode or filter tags respectively
inline void StartPRE( bool bRestart=false );
void FinishPRE() { bReadPRE = false; }
int FilterPRE( int nToken );
@@ -193,30 +192,30 @@ public:
void FinishTextArea() { bReadTextArea = false; }
// PRE-/LSITING- und XMP-Modus beenden
// finish PRE-/LISTING- and XMP mode
void FinishPREListingXMP() { bReadPRE = bReadListing = bReadXMP = false; }
// Das aktuelle Token dem aktuellen Modus (PRE, XMP, ...) entsprechend
// Filtern und die Flags setzen. Wird von Continue aufgerufen, bevor
// NextToken gerufen wird. Wer eigene Schleifen implementiert bzw.
// selbst NextToken aufruft, sollte diese Methode vorher rufen.
// Filter the current token according to the current mode
// (PRE, XMP, ...) and set the flags. Is called by Continue before
// NextToken is called. If you implement own loops or call
// NextToken yourself, you should call this method beforehand.
int FilterToken( int nToken );
// Scannen eines Scripts beenden (sollte nur unmittelbar nach dem
// Lesen eines <SCRIPT> aufgerufen werden
// end scanning of a script (should only be called right after
// reading of a <SCRIPT>)
void EndScanScript() { bReadScript = false; }
void ReadRawData( const OUString &rEndToken ) { aEndToken = rEndToken; }
// Token ohne \-Sequenzen
// Token without \-sequences
void UnescapeToken();
// Ermitteln der Optionen. pNoConvertToken ist das optionale Token
// einer Option, fuer die CR/LFs nicht aus dem Wert der Option
// geloescht werden.
// Determine the options. pNoConvertToken is the optional token
// of an option, for which the CR/LFs are not deleted from the value
// of the option.
const HTMLOptions& GetOptions( sal_uInt16 *pNoConvertToken=0 );
// fuers asynchrone lesen aus dem SvStream
// for asynchronous reading from the SvStream
virtual void Continue( int nToken ) SAL_OVERRIDE;
@@ -244,9 +243,9 @@ public:
bool ParseScriptOptions( OUString& rLangString, const OUString&, HTMLScriptLanguage& rLang,
OUString& rSrc, OUString& rLibrary, OUString& rModule );
// Einen Kommentar um den Inhalt von <SCRIPT> oder <STYLE> entfernen
// Bei 'bFull' wird ggf. die gesammte Zeile hinter einem "<!--"
// entfernt (fuer JavaSript)
// remove a comment around the content of <SCRIPT> or <STYLE>
// In case of 'bFull', the whole line behind a "<!--" might
// be deleted (for JavaSript)
static void RemoveSGMLComment( OUString &rString, bool bFull );
static bool InternalImgToPrivateURL( OUString& rURL );

6
include/svtools/rtfkeywd.hxx
View File

@@ -705,7 +705,7 @@
#define OOO_STRING_SVTOOLS_RTF_ZWJ "\\zwj"
#define OOO_STRING_SVTOOLS_RTF_ZWNJ "\\zwnj"
// neue Tokens zur 1.5
// new tokens for 1.5
#define OOO_STRING_SVTOOLS_RTF_ABSLOCK "\\abslock"
#define OOO_STRING_SVTOOLS_RTF_ADJUSTRIGHT "\\adjustright"
#define OOO_STRING_SVTOOLS_RTF_AFTNNCHOSUNG "\\aftnnchosung"
@@ -1060,7 +1060,7 @@
#define OOO_STRING_SVTOOLS_RTF_NOOVERFLOW "\\nooverflow"
#define OOO_STRING_SVTOOLS_RTF_ASPALPHA "\\aspalpha"
// SWG spezifische Attribute
// SWG-specific attributes
#define OOO_STRING_SVTOOLS_RTF_GRFALIGNV "\\grfalignv"
#define OOO_STRING_SVTOOLS_RTF_GRFALIGNH "\\grfalignh"
#define OOO_STRING_SVTOOLS_RTF_GRFMIRROR "\\grfmirror"
@@ -1077,7 +1077,7 @@
#define OOO_STRING_SVTOOLS_RTF_PRTDATA "\\prtdata"
#define OOO_STRING_SVTOOLS_RTF_BKMKKEY "\\bkmkkey"
// Attribute fuer die freifliegenden Rahmen
// attributes for free-flying frames
#define OOO_STRING_SVTOOLS_RTF_FLYPRINT "\\flyprint"
#define OOO_STRING_SVTOOLS_RTF_FLYOPAQUE "\\flyopaque"
#define OOO_STRING_SVTOOLS_RTF_FLYPRTCTD "\\flyprtctd"

194
include/svx/svddrgv.hxx
View File

@@ -59,8 +59,8 @@ protected:
bool bInsObjPointMode : 1;
bool bInsGluePointMode : 1;
bool bNoDragXorPolys : 1;
bool bAutoVertexCon : 1; // Automatische Konnektorgenerierung an den Scheitelpunkten
bool bAutoCornerCon : 1; // Automatische Konnektorgenerierung an den Eckpunkten
bool bAutoVertexCon : 1; // automatic generation of connectors at the vertices
bool bAutoCornerCon : 1; // automatic geneartion of connectors at the corners
bool bRubberEdgeDragging : 1;
bool bDetailedEdgeDragging : 1;
@@ -86,21 +86,21 @@ public:
virtual void BrkAction() SAL_OVERRIDE;
virtual void TakeActionRect(Rectangle& rRect) const SAL_OVERRIDE;
// Spezialimplementation fuer den Writer:
// TakeDragObjAnchorPos() liefert die Position an der ein Objekt
// beim Draggen einer Einfachselektion ungefaehr landet wenn es
// "losgelassen" wird (EndDrag).
// In der Regel ist das die linke obere Ecke des zu erwartenden neuen
// SnapRects. Ausnahme: CaptionObj. Dort ist es die Position des
// "Schwanzendes".
// Bei Returncode sal_False konnte ich die Position nicht bestimmen
// (z.B. Punktverschiebung, Mehrfachselektion, Schieben der
// Spiegelschse, ...)
// special implementation for Writer:
// TakeDragObjAnchorPos() returns the position at which an object
// approximately ends up during dragging when it is "released"
// (EndDrag).
// As a general rule, this is the left upper corner of the expected
// new SnapRect. Exception: CaptionObj. There, it is the position
// of the "tail end".
// In case of return value 'false', the position could not be
// determined (e.g. point shift, multiple selection, shift of the
// mirror axis,...)
bool TakeDragObjAnchorPos(Point& rPos, bool bTopRight = false ) const;
// Wird pForcedMeth uebergeben, so wird pHdl, ... nicht ausgewerten, sondern diese
// Drag-Methode verwendet. Die Instanz geht dabei ins Eigentum der View ueber und
// wird zum Ende des Draggings destruiert.
// If pForcedMeth is passed, then pHdl, ... is not evaluated, but this Drag
// method is used. In this, the ownership of the instance passes
// to the View and is destroyed at the end of the dragging.
virtual bool BegDragObj(const Point& rPnt, OutputDevice* pOut=NULL, SdrHdl* pHdl=NULL, short nMinMov=-3, SdrDragMethod* pForcedMeth=NULL);
void MovDragObj(const Point& rPnt);
bool EndDragObj(bool bCopy=false);
@@ -111,16 +111,16 @@ public:
bool IsDraggingPoints() const { return eDragHdl==HDL_POLY; }
bool IsDraggingGluePoints() const { return eDragHdl==HDL_GLUE; }
// Wer das beim BegDrag oder mittendrin schon festlegen will.
// (Wird bei jedem BegDrag auf sal_False zurueckgesetzt, also nach
// BegDrag setzen.)
// If you want to define that already during BegDrag
// or in the middle.
// (Is reset to 'false' on each BegDrag, so set it after BegDrag.)
void SetDragWithCopy(bool bOn) { bDragWithCopy = bOn; }
bool IsDragWithCopy() const { return bDragWithCopy; }
void SetInsertGluePoint(bool bOn) { bInsGluePoint = bOn; }
bool IsInsertGluePoint() const { return bInsGluePoint; }
// Interaktives einfuegen eines neuen Punktes. nIdx=0 => vor dem ersten Punkt.
// Interactive insertion of a new point. nIdx=0 => in front of the first point
bool IsInsObjPointPossible() const;
bool BegInsObjPoint(const Point& rPnt, bool bNewObj) { return ImpBegInsObjPoint(false, 0L, rPnt, bNewObj, 0L); }
void MovInsObjPoint(const Point& rPnt) { MovDragObj(rPnt); }
@@ -128,8 +128,8 @@ public:
void BrkInsObjPoint() { BrkDragObj(); }
bool IsInsObjPoint() const { return mpCurrentSdrDragMethod && bInsPolyPoint; }
// Fuer die App zum Verwalten des Status. GetPreferredPointer() wird
// spaeter vielleicht einen passenden Pointer dafuer liefern
// For the app to manage the status. GetPreferredPointer() is
// possibly going to deliver a matching pointer for it.
void SetInsObjPointMode(bool bOn) { bInsObjPointMode = bOn; }
bool IsInsObjPointMode() const { return bInsObjPointMode; }
@@ -140,142 +140,144 @@ public:
void BrkInsGluePoint() { BrkDragObj(); }
bool IsInsGluePoint() const { return mpCurrentSdrDragMethod && bInsGluePoint; }
// Fuer die App zum Verwalten des Status. GetPreferredPointer() wird
// spaeter vielleicht einen passenden Pointer dafuer liefern
// For the app to manage the status. GetPreferredPointer() is
// possibly going to deliver a matching pointer for it.
void SetInsGluePointMode(bool bOn) { bInsGluePointMode = bOn; }
bool IsInsGluePointMode() const { return bInsGluePointMode; }
// Begrenzungslinien ueber's gesamte Win waehrend des Draggens
// Persistent. Default=FALSE.
// border lines over the whole win persistent during the
// whole dragging. Default=FALSE.
void SetDragStripes(bool bOn);
bool IsDragStripes() const { return bDragStripes; }
// Handles waehrend des Draggens verstecken
// hide handles during dragging
//HMHvoid SetDragHdlHide(bool bOn);
//HMHBOOL IsDragHdlHide() const { return bNoDragHdl; }
// Beim Draggen von Polygonpunkten und Klebepunkten
// die Maus verstecken. Default=FALSE
// Hide the mouse when dragging polygon points or glue points.
// Default=false
void SetMouseHideWhileDraggingPoints(bool bOn) { bMouseHideWhileDraggingPoints = bOn; }
bool IsMouseHideWhileDraggingPoints() const { return bMouseHideWhileDraggingPoints; }
// Beim Draggen werden i.d.R. die Konturen der markierten Objekte
// als Xor-Polygone dargestellt. Wird dieses Flag hier gesetzt,
// wird (z.B. bei Mehrfachselektion) nur ein Xor-Frame gezeichnet.
// Bei objektspeziefischem Dragging (Polygonpunkte,Eckenradius,...
// hat diese Einstellung keine Auswirkung.
// Auch waerend des Draggens umschaltbar.
// As a general rule, the contours of the selected objects
// are displayed as Xor-polygons. If this flag is set, only one
// Xor-Frame is drawn (e.g. in case of multiple selection).
// In case of object-specific dragging (polygon points, corner radius,...),
// this setting has no influence.
// Also changeable during the dragging.
// Default=Off
void SetNoDragXorPolys(bool bOn);
bool IsNoDragXorPolys() const { return bNoDragXorPolys; }
// Uebersteigt die Anzahl der markierten Objekte den hier eingestellten
// Wert, wird implizit (temporaer) auf NoDragPolys geschaltet.
// PolyPolygone etc werden entsprechend als mehrere Objekte gewertet.
// If the number of selected objects exceeds te value set here,
// NoDragPolys is (temporarily) activated implicitely.
// PolyPolygons etc. are regarded as multiple objects respectively.
// Default=100
void SetDragXorPolyLimit(sal_uIntPtr nObjAnz) { nDragXorPolyLimit=nObjAnz; }
sal_uIntPtr GetDragXorPolyLimit() const { return nDragXorPolyLimit; }
// Wie DragXorPolyLimit, jedoch bezogen auf die Gesamtpunktanzahl
// aller Polygone. Default=500.
// Auf NoDragPolys wird (temporaer) geschaltet, wenn eins der Limits
// ueberstiegen wird.
// Like DragXorPolyLimit, but in respect to the total number of
// all polygons. Default=500.
// NoDragPolys is (temporarily) activated, if one of the limits
// is exceeded.
void SetDragXorPointLimit(sal_uIntPtr nPntAnz) { nDragXorPointLimit=nPntAnz; }
sal_uIntPtr GetDragXorPointLimit() const { return nDragXorPointLimit; }
void SetSolidDragging(bool bOn);
bool IsSolidDragging() const;
// Dragging/Creating von Verbindern:
// Dragging/Creation of connectors:
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Verbinder an Objektscheitelpunkte ankleben
// Default=sal_True=Ja
// Stick Connectors to vertices
// Default=true=Yes
void SetAutoVertexConnectors(bool bOn) { bAutoVertexCon = bOn; }
bool IsAutoVertexConnectors() const { return bAutoVertexCon; }
// Verbinder an Objektecken ankleben
// Default=sal_False=Nein
// Stick Connectors to Corners
// Default=false=No
void SetAutoCornerConnectors(bool bOn) { bAutoCornerCon = bOn; }
bool IsAutoCornerConnectors() const { return bAutoCornerCon; }
// Dragging von verbundenen Objekten (Nodes):
// Dragging of connected objects (Nodes):
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// DetailedEdgeDraggingLimit: Wie RubberEdgeDraggingLimit, jedoch bezieht
// sich dieses Limit auf die detalierte Darstellung, d.h. nicht nur
// Gummibaender sondern komplette Neuberechnunen sind beim Draggen sichtbar.
// Diese detalierte Darstellung ist eh nur beim MoveDrag moeglich.
// Defaultwert ist 10
// DetailedEdgeDraggingLimit: like RubberEdgeDraggingLimit,
// but this limit refers to the detailed depiction, i.e. not
// only rubber bands but total recalculations are visible while
// dragging. This detailed depiction is only possible in MoveDrag.
// Default value: 10
bool IsDetailedEdgeDragging() const { return bDetailedEdgeDragging; }
sal_uInt16 GetDetailedEdgeDraggingLimit() const { return nDetailedEdgeDraggingLimit; }
// EdgeDraggingLimit: Sind mehr als nEdgeObjAnz Kanten betroffen, werden
// diese beim interaktiven Draggen nicht mit angezeigt.
// Gemeint sind hier die "Gummibaender", die weniger Rechenzeit benoetigen
// als die kompletten Neuberechnungen beim DetailedEdgeDragging.
// Defaultwert ist 100
// EdgeDraggingLimit: If more than nEdgeObjCount edges are affected,
// they are not shown in the interactive dragging.
// This here talks about the "rubber bands", which take less computing time
// than the complete recalculations in the DetailedEdgeDragging.
// default value: 100
bool IsRubberEdgeDragging() const { return bRubberEdgeDragging; }
// Verbinderhandling also zu deutsch wie folgt (bei Defaulteinstellungen):
// - Sind bis max 10 Verbinder betroffen werden diese bei jedem
// MouseMove neu berechnet
// - Sind zwischen 11 und 100 Verbinder betroffen werden die
// Verbindungen beim Draggen als gerade Linien dargestellt.
// - Bei mehr als 100 betroffenen Verbindern wird beim Draggen nichts
// mehr gezeichnet was auf Verbinder hinweist.
// Connector handling is thus as follows (when using default settings):
// - If at most 10 Connectors are affected, they are recalculated
// on each MouseMove.
// - If 11 to 100 Connectors are affected, the connections
// are shown as straight lines while dragging.
// - In case of more than 100 affected Connectors, nothing that refers
// to the Connectors is drawn while dragging.
// Ist ein spezieller Dragmode eingeschaltet, wie Rotate, Mirror oder Crook,
// dann leitet ein Hit auf das markierte Objekt genau dieses Dragging ein.
// Setzt man MarkedHitMovesAlways auf sal_True, so leitet ein Hit auf das
// markierte Objekt immer ein Moven ein, unabhaengig vom gesetzten DragMode.
// Dieses Flag ist persistent und sollte von der App fuer den Anwender
// konfigurierbar sein!
// If a special drag mode like Rotate, Mirror or Crook is enabled,
// then a Hit on the selected object triggers exactly this dragging.
// If MarkedHitMovesAlways is set to 'true', a Hit on the selected
// object always triggers a Move, independent of the DragMode that is
// set. This flag is persistent and should be configurable in the app
// by the user!
void SetMarkedHitMovesAlways(bool bOn) { bMarkedHitMovesAlways = bOn; }
bool IsMarkedHitMovesAlways() const { return bMarkedHitMovesAlways; }
// Beim Draggen der Spiegelachse das Spiegelbild der markierten Objekte
// als Xor darstellen? Persistent. Noch nicht implementiert. Default TRUE.
// Show the mirror image of the selected objects as Xor while dragging
// the mirror axis? Persistent. Not yet implemented. Default: true
void SetMirrRefDragObj(bool bOn) { bMirrRefDragObj = bOn; }
bool IsMirrRefDragObj() const { return bMirrRefDragObj; }
bool IsOrthoDesired() const;
// Beim Resize die Mitte als Referenz
// center as reference on Resize
// Default=FALSE.
bool IsResizeAtCenter() const { return bResizeAtCenter; }
void SetResizeAtCenter(bool bOn) { bResizeAtCenter = bOn; }
// Symmetrisches Crook
// symmetric Crook
// Default=FALSE.
bool IsCrookAtCenter() const { return bCrookAtCenter; }
void SetCrookAtCenter(bool bOn) { bCrookAtCenter = bOn; }
// Begrenzung des Arbeitsbereichs. Die Begrenzung bezieht sich auf die
// View, nicht auf die einzelnen PageViews. Von der View wird diese
// Begrenzung nur bei Interaktionen wie Dragging und Create ausgewertet.
// Bei von der App algorithmisch oder UI-gesteuerte Aktionen (SetGeoAttr,
// MoveMarkedObj, ...) muss die App dieses Limit selbst beruecksichtigen.
// Ferner ist dieses Limit als Grob-Limit zu sehen. U.U. koennen Objekte
// (z.B. beim Drehen) nicht exakt bis an dieses Limit herangedraggt werden,
// koennen Objekte durch Rundungsfehler doch etwas ueberstehen, ... .
// Default=EmptyRect=keine Begrenzung.
// erst z.T. impl.
// (besser in die DragView?)
// Limitation of the working area. The limitation refers to the View,
// not to the single PageViews. This limitation is only evaluated by
// the View on interactions like Dragging and Create.
// In case of actions controlled by the app through algorithms or
// UI-controlled actions (SetGeoAttr, MoveMarkedObj, ...), the
// app must honor this limit itself.
// Furthermore, this limit is to be seen as a rough limit. In certain
// cases (e.g. while rotating), objects cannot be dragged exactly
// up to this limit, objects can overlap a bit because of rounding
// errors,...
// Default=EmptyRect=no limitation
// only partially implemented
void SetWorkArea(const Rectangle& rRect) { aMaxWorkArea=rRect; }
const Rectangle& GetWorkArea() const { return aMaxWorkArea; }
// Das DragLimit ist bezogen auf die Page des Objekts.
// (Oder auf die View??? Muss ich mal^^^^recherchieren. Joe.)
// sal_False=Kein Limit.
// Das Rueckgabe-Rect muss absolute Koordinaten enthalten. Der Maximale
// Dragbereich wird von der View dann so gewaehlt, dass das SnapRect des
// Objekts bis Maximal auf die Kante des LimitRects gemoved bzw. gesized
// wird. Bei Objekten wie Bezierkurven, gedrehten Rechtecken ist zu beachten
// das durch anschliessende Neuberechnung des SnapRects (bei Resize)
// Rundungsfehler auftreten koennen, wodurch das LimitRect minnimal
// ueberschritten werden koennte...
// Implementiert fuer Move und Resize.
// The DragLimit refers to the Page of the object.
// (TODO or to the View?? - must be researched...)
// 'false' = no limit
// The return Rect must contain absolute coordinates. The maximum
// drag area is then selected by the View in a way that the object's
// SnapRect is moved or resized at most up to the corner of the
// LimitRect. For objects like Bezier curves, rotated rectangles,
// it must be taken into account that because of subsequent
// recalculation of the SnapRect (on Resize), rounding errors can
// occur, because of which the LimitRect might be exceeded by a
// very small extent....
// Implemented for Move and Resize
virtual bool TakeDragLimit(SdrDragMode eMode, Rectangle& rRect) const;
};