Commits

Anonymous committed 067a633

undo some TRUE /FALSE to salTrue/False changes in autodoc comments

Comments (0)

Files changed (18)

svtools/inc/svtools/accessibletable.hxx

     virtual void dispose() = 0;
 
     /** checks whether the accessible implementation, and its context, are still alive
-        @return  <sal_True/>, if the object is not disposed or disposing.
+        @return  <TRUE/>, if the object is not disposed or disposing.
     */
     virtual sal_Bool isAlive() const = 0;
 

svtools/inc/svtools/accessibletableprovider.hxx

         @param _nColumn The column which description is in demand. */
 	virtual ::rtl::OUString			GetColumnDescription( sal_uInt16 _nColumnPos ) const = 0;
 
-    /** @return  <sal_True/>, if the object has a row header. */
+    /** @return  <TRUE/>, if the object has a row header. */
 	virtual sal_Bool				HasRowHeader() const = 0; //GetColumnId
-    /** @return  <sal_True/>, if the object can focus a cell. */
+    /** @return  <TRUE/>, if the object can focus a cell. */
 	virtual sal_Bool				IsCellFocusable() const = 0;
 	virtual sal_Bool				GoToCell( sal_Int32 _nRow, sal_uInt16 _nColumnPos ) = 0;
 
 	virtual void					SelectColumn( sal_uInt16 _nColumnPos, sal_Bool _bSelect = sal_True ) = 0;
 	virtual sal_Int32				GetSelectedRowCount() const = 0;
 	virtual sal_Int32				GetSelectedColumnCount() const = 0;
-    /** @return  <sal_True/>, if the row is selected. */
+    /** @return  <TRUE/>, if the row is selected. */
 	virtual bool					IsRowSelected( long _nRow ) const = 0;
 	virtual sal_Bool				IsColumnSelected( long _nColumnPos ) const = 0;
 	virtual void					GetAllSelectedRows( ::com::sun::star::uno::Sequence< sal_Int32 >& _rRows ) const = 0;
 	virtual void					GetAllSelectedColumns( ::com::sun::star::uno::Sequence< sal_Int32 >& _rColumns ) const = 0;
 
-    /** @return  <sal_True/>, if the cell is visible. */
+    /** @return  <TRUE/>, if the cell is visible. */
 	virtual sal_Bool				IsCellVisible( sal_Int32 _nRow, sal_uInt16 _nColumnPos ) const = 0;
 	virtual String					GetAccessibleCellText( long _nRow, sal_uInt16 _nColumnPos ) const = 0;
 
     virtual void dispose() = 0;
 
     /** checks whether the accessible implementation, and its context, are still alive
-        @return  <sal_True/>, if the object is not disposed or disposing.
+        @return  <TRUE/>, if the object is not disposed or disposing.
     */
     virtual sal_Bool isAlive() const = 0;
 

svtools/inc/svtools/brwbox.hxx

 
     /** returns the Rectangle for either the column header bar ot the row header bar
 		@param	_bIsColumnBar
-			<sal_True/> when column header bar is used
+			<TRUE/> when column header bar is used
 		@param	_bOnScreen
-			<sal_True/> when the rectangle should be calculated OnScreen
+			<TRUE/> when the rectangle should be calculated OnScreen
 		@return
 			the Rectangle
 	*/
 
 	/** calculates the Rectangle of the table
 		@param	_bOnScreen
-			<sal_True/> when the rectangle should be calculated OnScreen
+			<TRUE/> when the rectangle should be calculated OnScreen
 		@return
 			the Rectangle
 	*/
 		@param	_nColId
 			teh column id
 		@param	_bOnScreen
-			<sal_True/> when the rectangle should be calculated OnScreen
+			<TRUE/> when the rectangle should be calculated OnScreen
 		@return
 			the Rectangle
 	*/
 	virtual Rectangle GetFieldRectPixelAbs(sal_Int32 _nRowId,sal_uInt16 _nColId, sal_Bool _bIsHeader, sal_Bool _bOnScreen = sal_True);
 
-	/// return <sal_True/> if and only if the accessible object for this instance has been created and is alive
+	/// return <TRUE/> if and only if the accessible object for this instance has been created and is alive
 	sal_Bool isAccessibleAlive( ) const;
 
     // ACCESSIBILITY ==========================================================
         @param rnRow  Out-paramater that takes the row index.
         @param rnColumnId  Out-paramater that takes the column ID.
         @param rPoint  The position in pixels relative to the data window.
-        @return <sal_True/>, if the point could be converted to a valid address. */
+        @return <TRUE/>, if the point could be converted to a valid address. */
     virtual sal_Bool ConvertPointToCellAddress(
         sal_Int32& rnRow, sal_uInt16& rnColumnId, const Point& rPoint );
 
         index.
         @param rnRow  Out-paramater that takes the row index.
         @param rPoint  The position in pixels relative to the header bar.
-        @return <sal_True/>, if the point could be converted to a valid index. */
+        @return <TRUE/>, if the point could be converted to a valid index. */
     virtual sal_Bool ConvertPointToRowHeader( sal_Int32& rnRow, const Point& rPoint );
 
     /** Converts a point relative to the column header bar origin to a column
         header index.
         @param rnColumnId  Out-paramater that takes the column ID.
         @param rPoint  The position in pixels relative to the header bar.
-        @return <sal_True/>, if the point could be converted to a valid index. */
+        @return <TRUE/>, if the point could be converted to a valid index. */
     virtual sal_Bool ConvertPointToColumnHeader( sal_uInt16& rnColumnPos, const Point& rPoint );
 
     /** Converts a point relative to the BrowseBox origin to the index of an
         existing control.
         @param rnRow  Out-paramater that takes the 0-based control index.
         @param rPoint  The position in pixels relative to the BrowseBox.
-        @return <sal_True/>, if the point could be converted to a valid index. */
+        @return <TRUE/>, if the point could be converted to a valid index. */
     virtual sal_Bool ConvertPointToControlIndex( sal_Int32& rnIndex, const Point& rPoint );
 
     // Object data and state --------------------------------------------------

svtools/inc/svtools/fmtfield.hxx

 
     /** enables handling of not-a-number value.
 
-        When this is set to <sal_False/> (the default), then invalid inputs (i.e. text which cannot be
+        When this is set to <FALSE/> (the default), then invalid inputs (i.e. text which cannot be
         intepreted, according to the current formatting) will be handled as if the default value
         has been entered. GetValue the will return this default value.
 
-        When set to <sal_True/>, then GetValue will return NaN (not a number, see <method scope="rtl::math">isNan</method>)
+        When set to <TRUE/>, then GetValue will return NaN (not a number, see <method scope="rtl::math">isNan</method>)
         when the current input is invalid.
 
-        Note that setting this to <sal_True/> implies that upon leaving the control, the input
+        Note that setting this to <TRUE/> implies that upon leaving the control, the input
         will *not* be corrected to a valid value. For example, if the user enters "foo" in the
         control, and then tabs out of it, the text "foo" will persist, and GetValue will
         return NaN in subsequent calls.

svtools/inc/svtools/genericunodialog.hxx

                 m_aMutex is locked
 
             @return
-                <sal_True/> if and only if m_pDialog is non-<NULL/> upon returning from the method. Note that the only
+                <TRUE/> if and only if m_pDialog is non-<NULL/> upon returning from the method. Note that the only
                 case where m_pDialog is <NULL/> is when createDialog returned <NULL/>, which is will fire an assertion
                 in non-product builds.
         */

svtools/inc/svtools/roadmapwizard.hxx

                 <member>declarePath</member> before it can be activated.
 
             @param _bDecideForIt
-                If <sal_True/>, the path will be completely activated, even if it is a conflicting path
+                If <TRUE/>, the path will be completely activated, even if it is a conflicting path
                 (i.e. there is another path which shares the first <code>k</code> states with
                 the to-be-activated path.)<br/>
-                If <sal_False/>, then the new path is checked for conflicts with other paths. If such
+                If <FALSE/>, then the new path is checked for conflicts with other paths. If such
                 conflicts exists, the path is not completely activated, but only up to the point
                 where it does <em>not</em> conflict.<br/>
                 With the paths in the example above, if you activate the second path (when both are

svtools/inc/svtools/stringtransfer.hxx

 		SVT_DLLPUBLIC static void			CopyString( const ::rtl::OUString& _rContent, Window* _pWindow = NULL );
 
 		/** extracts a string from the system clipboard given
-			@return <sal_True/> if the extraction was successfull, i.e. if the clipboard contained a string content
+			@return <TRUE/> if the extraction was successfull, i.e. if the clipboard contained a string content
 		*/
 		SVT_DLLPUBLIC static sal_Bool		PasteString( ::rtl::OUString& _rContent, Window* _pWindow = NULL );
 

svtools/inc/svtools/svlbox.hxx

         @see MnemonicEngine
 
         @return
-            <sal_True/> if the event has been consumed, <sal_False/> otherwise.
+            <TRUE/> if the event has been consumed, <FALSE/> otherwise.
     */
 	bool            HandleKeyInput( const KeyEvent& rKEvt );
 

svtools/inc/svtools/svtabbx.hxx

         @param _nColumn The column which description is in demand. */
 	virtual ::rtl::OUString			GetColumnDescription( sal_uInt16 _nColumn ) const;
 
-    /** @return  <sal_True/>, if the object has a row header. */
+    /** @return  <TRUE/>, if the object has a row header. */
 	virtual sal_Bool				HasRowHeader() const; //GetColumnId
-    /** @return  <sal_True/>, if the object can focus a cell. */
+    /** @return  <TRUE/>, if the object can focus a cell. */
 	virtual sal_Bool				IsCellFocusable() const;
 	virtual sal_Bool				GoToCell( sal_Int32 _nRow, sal_uInt16 _nColumn );
 
 	virtual void					SelectColumn( sal_uInt16 _nColumn, sal_Bool _bSelect = sal_True );
 	virtual sal_Int32				GetSelectedRowCount() const;
 	virtual sal_Int32				GetSelectedColumnCount() const;
-    /** @return  <sal_True/>, if the row is selected. */
+    /** @return  <TRUE/>, if the row is selected. */
 	virtual bool					IsRowSelected( long _nRow ) const;
 	virtual sal_Bool				IsColumnSelected( long _nColumn ) const;
 	virtual void					GetAllSelectedRows( ::com::sun::star::uno::Sequence< sal_Int32 >& _rRows ) const;
 	virtual void					GetAllSelectedColumns( ::com::sun::star::uno::Sequence< sal_Int32 >& _rColumns ) const;
 
-    /** @return  <sal_True/>, if the cell is visible. */
+    /** @return  <TRUE/>, if the cell is visible. */
 	virtual sal_Bool				IsCellVisible( sal_Int32 _nRow, sal_uInt16 _nColumn ) const;
 	virtual String					GetAccessibleCellText( long _nRow, sal_uInt16 _nColumnPos ) const;
 

svtools/inc/svtools/table/tablecontrolinterface.hxx

         /** dispatches an action to the table control
 
             @return
-                <sal_True/> if the action could be dispatched successfully, <sal_False/> otherwise. Usual
+                <TRUE/> if the action could be dispatched successfully, <FALSE/> otherwise. Usual
                 failure conditions include some other instance vetoing the action, or impossibility
                 to execute the action at all (for instance moving up one row when already positioned
                 on the very first row).

svtools/inc/svtools/table/tableinputhandler.hxx

     public:
         // all those methods have the same semantics as the equal-named methods of ->Window,
         // with the additional option to return a boolean value indicating whether
-        // the event should be further processed by the ->Window implementations (<sal_False/>),
+        // the event should be further processed by the ->Window implementations (<FALSE/>),
         // or whether it has been sufficiently handled by the ->ITableInputHandler instance
-        // (<sal_False/>).
+        // (<FALSE/>).
 
         virtual bool    MouseMove       ( ITableControl& _rControl, const MouseEvent& rMEvt ) = 0;
         virtual bool    MouseButtonDown ( ITableControl& _rControl, const MouseEvent& rMEvt ) = 0;

svtools/inc/svtools/table/tablemodel.hxx

         /** sets a new column ID
 
             @return
-                <sal_True/> if setting the new ID was successfull. A possible error
+                <TRUE/> if setting the new ID was successfull. A possible error
                 conditions is if you try to set an ID which is already used
                 by another column within the same table.
 
 
         /** determines whether the table has column headers
 
-            If this method returns <sal_True/>, the renderer returned by
+            If this method returns <TRUE/>, the renderer returned by
             ->getRenderer must be able to render column headers.
 
             @see IColumnRenderer
 
         /** determines whether the table has row headers
 
-            If this method returns <sal_True/>, the renderer returned by
+            If this method returns <TRUE/>, the renderer returned by
             ->getRenderer must be able to render row headers.
 
             @see IColumnRenderer
         /** determines the height of the column header row
 
             This method is not to be called if ->hasColumnHeaders()
-            returned <sal_False/>.
+            returned <FALSE/>.
 
             @return
                 the logical height of the column header row, in app-font units.
         /** determines the width of the row header column
 
             This method is not to be called if ->hasRowHeaders()
-            returned <sal_False/>.
+            returned <FALSE/>.
 
             @return
                 the logical width of the row header column, in app-font units.

svtools/inc/svtools/table/tablerenderer.hxx

             There are two flags specifying whether the to-be-painted area is part of the column
             and/or row header area.
             <ul><li>If both are <TRUE/>, the intersection of both areas is to be painted.</li>
-                <li>If ->_bIsColHeaderArea is <TRUE/> and ->_bIsRowHeaderArea is <sal_False/>,
+                <li>If ->_bIsColHeaderArea is <TRUE/> and ->_bIsRowHeaderArea is <FALSE/>,
                     then ->_rArea denotes the column header area <em>excluding</em> the
                     intersection between row and column header area.</li>
-                <li>Equivalently for ->_bIsColHeaderArea being <sal_False/> and ->_bIsRowHeaderArea
+                <li>Equivalently for ->_bIsColHeaderArea being <FALSE/> and ->_bIsRowHeaderArea
                     being <TRUE/></li>
             </ul>
             Note that it's not possible for both ->_bIsColHeaderArea and ->_bIsRowHeaderArea
-            to be <sal_False/> at the same time.
+            to be <FALSE/> at the same time.
 
             @param _rDevice
                 the device to paint onto

svtools/inc/svtools/templatefoldercache.hxx

 	public:
 		/** ctor.
 		@param _bAutoStoreState
-			Set this to <sal_True/> if you want the instance to automatically store the state of the template folders upon
+			Set this to <TRUE/> if you want the instance to automatically store the state of the template folders upon
 			destruction.<br/>
-			If set to <sal_False/>, you would epplicitly need to call <method>storeState</method> to do this.<br/>
+			If set to <FALSE/>, you would epplicitly need to call <method>storeState</method> to do this.<br/>
 			If the current state is not known (e.g. because you did not call needsUpdate, which retrieves it),
 			it is not retrieved in the dtor, regardless of the <arg>_bAutoStoreState</arg> flag.
 		*/
 
 		/** determines whether or not the template configuration needs to be updated
 		@param _bForceCheck
-			set this to <sal_True/> if you want the object to rescan the template folders in every case. The default (<sal_False/>)
+			set this to <TRUE/> if you want the object to rescan the template folders in every case. The default (<FALSE/>)
 			means that once the information has been retrieved in a first call, every second call returns the same result
 			as the first one, even if in the meantime the template folders changed.
 		@return
-			<sal_True/> if the template configuration needs to be updated
+			<TRUE/> if the template configuration needs to be updated
 		*/
 		sal_Bool	needsUpdate( sal_Bool _bForceCheck = sal_False );
 
 		/** stores the current state of the template folders in the cache
 		@param _bForceRetrieval
-			if set to <sal_True/>, the current state of the template folders is retrieved again, even if it is already known.
-			Usually, you set this to <sal_False/>: After calling <method>needsUpdate</method>, the state is know and does not
+			if set to <TRUE/>, the current state of the template folders is retrieved again, even if it is already known.
+			Usually, you set this to <FALSE/>: After calling <method>needsUpdate</method>, the state is know and does not
 			need to be read again.
 		*/
 		void		storeState( sal_Bool _bForceRetrieval = sal_False );

svtools/inc/svtools/wizardmachine.hxx

             You should make this dependent on the current state of the page only, not on 
             states on other pages of the whole dialog.
 
-            The default implementation always returns <sal_True/>.
+            The default implementation always returns <TRUE/>.
         */
 		virtual bool    canAdvance() const = 0;
 	};
             @param _eReason
                 The reason why the state is to be left.
             @return
-				<sal_True/> if and only if the page is allowed to be left
+				<TRUE/> if and only if the page is allowed to be left
 		*/
         virtual sal_Bool    prepareLeaveCurrentState( CommitPageReason _eReason );
 
             changing this return type is too incompatible at the moment ...
 
             @return
-				<sal_True/> if and only if the page is allowed to be left
+				<TRUE/> if and only if the page is allowed to be left
 		*/
 		virtual	sal_Bool	leaveState( WizardState _nState );
 
 
         /** enables the automatic enabled/disabled state of the "Next" button
 
-            If this is <sal_True/>, then upon entering a new state, the "Next" button will automatically be
+            If this is <TRUE/>, then upon entering a new state, the "Next" button will automatically be
             enabled if and only if determineNextState does not return WZS_INVALID_STATE.
         */
         void                enableAutomaticNextButtonState( bool _bEnable = true );
 			method is able to determine the next state without actually having the page of the current state.
 
             @return
-                <sal_True/> if and only if traveling was successfull
+                <TRUE/> if and only if traveling was successfull
 
             @see skipUntil
             @see skipBackwardUntil
 			The skipped states appear in the state history, so <method>travelPrevious</method> will make use of them.
 
             @return
-                <sal_True/> if and only if traveling was successfull
+                <TRUE/> if and only if traveling was successfull
 
             @see skip
             @see skipBackwardUntil
             you from this.
 
             @return
-                <sal_True/> if and only if traveling was successfull
+                <TRUE/> if and only if traveling was successfull
 
             @see skipUntil
             @see skip

svtools/source/brwbox/ebbcontrols.cxx

 
         if ( bHandled ) // the view claimed it handled the key input
         {
-            // unfortunately, KeyInput also returns <sal_True/> (means "I handled this key input")
+            // unfortunately, KeyInput also returns <TRUE/> (means "I handled this key input")
             // when nothing really changed. Let's care for this.
             Selection aNewSelection( GetSelection() );
             if  (  aNewSelection != aOldSelection   // selection changed

svtools/source/misc/templatefoldercache.cxx

 		static	sal_Int32	getMagicNumber();
 		static	void		normalize( TemplateFolderContent& _rState );
 
-		// @return <sal_True/> if the states equal
+		// @return <TRUE/> if the states equal
 		static	sal_Bool	equalStates( const TemplateFolderContent& _rLHS, const TemplateFolderContent& _rRHS );
 
         // late initialize m_xOfficeInstDirs

svtools/source/table/tablecontrol_impl.hxx

         /** moves the cursor to the cell with the given coordinates
 
             To ease the caller's code, the coordinates must not necessarily denote a
-            valid position. If they don't, <sal_False/> will be returned.
+            valid position. If they don't, <FALSE/> will be returned.
         */
         bool    goTo( ColPos _nColumn, RowPos _nRow );
 
                 the row position which should be visibleMust be non-negative, and smaller
                 than the row count.
             @param _bAcceptPartialVisibility
-                <sal_True/> if it's okay that the given cooordinate is only partially visible
+                <TRUE/> if it's okay that the given cooordinate is only partially visible
         */
         void    ensureVisible( ColPos _nColumn, RowPos _nRow, bool _bAcceptPartialVisibility );
 
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.