resync to DEV300_m70

10 files changed, 441 insertions, 17 deletions

diff --git a/tools/inc/tools/inetdef.hxx b/tools/inc/tools/inetdef.hxx
index 38cd8935e06b..d9861f64961d 100644
--- a/tools/inc/tools/inetdef.hxx
+++ b/tools/inc/tools/inetdef.hxx
@@ -61,8 +61,6 @@
 #define TOOLS_INETDEF_OS "FreeBSD/amd64"
 #elif defined SINIX
 #define TOOLS_INETDEF_OS "SINIX"
-#elif defined IRIX
-#define TOOLS_INETDEF_OS "IRIX"
 #else // AIX, HPUX, SOLARIS, ...
 #define TOOLS_INETDEF_OS "Unix"
 #endif // AIX, HPUX, SOLARIS, ...
diff --git a/tools/inc/tools/multisel.hxx b/tools/inc/tools/multisel.hxx
index 46fd8947e21b..9de3cc172e70 100644
--- a/tools/inc/tools/multisel.hxx
+++ b/tools/inc/tools/multisel.hxx
@@ -35,6 +35,9 @@
 #include <tools/list.hxx>
 #include <tools/string.hxx>
 
+#include <vector>
+#include <set>
+
 //------------------------------------------------------------------
 
 #ifdef _SV_MULTISEL_CXX
@@ -112,4 +115,105 @@ public:
     const Range&    GetRange( ULONG nRange ) const { return *(const Range*)aSels.GetObject(nRange); }
 };
 
+class TOOLS_DLLPUBLIC StringRangeEnumerator
+{
+    struct Range
+    {
+        sal_Int32   nFirst;
+        sal_Int32   nLast;
+
+        Range() : nFirst( -1 ), nLast( -1 ) {}
+        Range( sal_Int32 i_nFirst, sal_Int32 i_nLast ) : nFirst( i_nFirst ), nLast( i_nLast ) {}
+    };
+    std::vector< StringRangeEnumerator::Range >            maSequence;
+    sal_Int32                                              mnCount;
+    sal_Int32                                              mnMin;
+    sal_Int32                                              mnMax;
+    sal_Int32                                              mnOffset;
+
+    bool insertRange( sal_Int32 nFirst, sal_Int32 nLast, bool bSequence, bool bMayAdjust );
+    bool checkValue( sal_Int32, const std::set< sal_Int32 >* i_pPossibleValues = NULL ) const;
+public:
+    class TOOLS_DLLPUBLIC Iterator
+    {
+        const StringRangeEnumerator*      pEnumerator;
+        const std::set< sal_Int32 >*      pPossibleValues;
+        sal_Int32                         nRangeIndex;
+        sal_Int32                         nCurrent;
+
+        friend class StringRangeEnumerator;
+        Iterator( const StringRangeEnumerator* i_pEnum,
+                  const std::set< sal_Int32 >* i_pPossibleValues,
+                  sal_Int32 i_nRange,
+                  sal_Int32 i_nCurrent )
+        : pEnumerator( i_pEnum ), pPossibleValues( i_pPossibleValues )
+        , nRangeIndex( i_nRange ), nCurrent( i_nCurrent ) {}
+    public:
+        Iterator() : pEnumerator( NULL ), pPossibleValues( NULL ), nRangeIndex( -1 ), nCurrent( -1 ) {}
+        Iterator& operator++();
+        sal_Int32 operator*() const;
+        bool operator==(const Iterator&) const;
+        bool operator!=(const Iterator& i_rComp) const
+        { return ! (*this == i_rComp); }
+    };
+
+    friend class StringRangeEnumerator::Iterator;
+
+    StringRangeEnumerator() : mnCount( 0 ), mnMin( -1 ), mnMax( -1 ), mnOffset( -1 ) {}
+    StringRangeEnumerator( const rtl::OUString& i_rInput,
+                           sal_Int32 i_nMinNumber = -1,
+                           sal_Int32 i_nMaxNumber = -1,
+                           sal_Int32 i_nLogicalOffset = -1
+                           );
+
+    size_t size() const { return size_t(mnCount); }
+    Iterator begin( const std::set< sal_Int32 >* i_pPossibleValues = NULL ) const;
+    Iterator end( const std::set< sal_Int32 >* i_pPossibleValues = NULL ) const;
+
+    sal_Int32 getMin() const { return mnMin; }
+    void setMin( sal_Int32 i_nMinValue ) { mnMin = i_nMinValue; }
+    sal_Int32 getMax() const { return mnMax; }
+    void setMax( sal_Int32 i_nMaxValue ) { mnMax = i_nMaxValue; }
+    sal_Int32 getLogicalOffset() const { return mnOffset; }
+    void setLogicalOffset( sal_Int32 i_nOffset ) { mnOffset = i_nOffset; }
+
+    bool setRange( const rtl::OUString& i_rNewRange, bool i_bStrict = false );
+    bool hasValue( sal_Int32 nValue, const std::set< sal_Int32 >* i_pPossibleValues = NULL ) const;
+
+
+    /**
+    i_rPageRange:     the string to be changed into a sequence of numbers
+                      valid format example "5-3,9,9,7-8" ; instead of ',' ';' or ' ' are allowed as well
+    o_rPageVector:    the output sequence of numbers
+    i_nLogicalOffset: an offset to be applied to each number in the string before inserting it in the resulting sequence
+                      example: a user enters page numbers from 1 to n (since that is logical)
+                               of course usable page numbers in code would start from 0 and end at n-1
+                               so the logical offset would be -1
+    i_nMinNumber:     the minimum allowed number, a negative number means no minimum check
+    i_nMaxNumber:     the maximum allowed number, a negative number means no maximum check
+
+    @returns: true if the input string was valid, o_rPageVector will contain the resulting sequence
+              false if the input string was invalid, o_rPageVector will be unchanged
+
+    behavior:
+    - only non-negative sequence numbers are allowed
+    - only non-negative values in the input string are allowed
+    - the string "-3" will be either
+      * an error if no minimum is given
+      * or result in the sequence i_nMinNumber to 3
+    - the string "3-" will be either
+      * an error if no maximum is given
+      * or result in the seqeuence 3 to i_nMaxNumber
+    - an empty string as input is valid and will result in the range [min,max] if given
+      or an empty vector, if not
+    */
+    static bool getRangesFromString( const rtl::OUString& i_rPageRange,
+                                     std::vector< sal_Int32 >& o_rPageVector,
+                                     sal_Int32 i_nMinNumber = -1,
+                                     sal_Int32 i_nMaxNumber = -1,
+                                     sal_Int32 i_nLogicalOffset = -1,
+                                     std::set< sal_Int32 >* i_pPossibleValues = NULL
+                                    );
+};
+
 #endif  // _SV_MULTISEL_HXX
diff --git a/tools/inc/tools/solar.h b/tools/inc/tools/solar.h
index cd069886d8b6..195a6fd3ce87 100644
--- a/tools/inc/tools/solar.h
+++ b/tools/inc/tools/solar.h
@@ -393,8 +393,6 @@ template<typename T> inline T Abs(T a) { return (a>=0?a:-a); }
   #define __DLLEXTENSION "fi.so"
 #elif defined FREEBSD && defined X86_64
   #define __DLLEXTENSION "fx.so"
-#elif defined IRIX
-  #define __DLLEXTENSION "im.so"
 #elif defined MACOSX && defined POWERPC
   #define __DLLEXTENSION "mxp.dylib"
 #elif defined MACOSX && defined X86
diff --git a/tools/inc/tools/stream.hxx b/tools/inc/tools/stream.hxx
index bacaac89fe44..23496322fa4c 100644
--- a/tools/inc/tools/stream.hxx
+++ b/tools/inc/tools/stream.hxx
@@ -776,6 +776,9 @@ class TOOLS_DLLPUBLIC SvMemoryStream : public SvStream
     SvMemoryStream (const SvMemoryStream&);
     SvMemoryStream & operator= (const SvMemoryStream&);
 
+    friend class SvCacheStream;
+    sal_Size            GetSize() const { return nSize; }
+
 protected:
     sal_Size            nSize;
     sal_Size            nResize;
@@ -817,7 +820,7 @@ public:
 
     virtual void    ResetError();
 
-    sal_Size            GetSize() const { return nSize; }
+    sal_Size        GetEndOfData() const { return nEndOfData; }
     const void*     GetData() { Flush(); return pBuf; }
     operator const  void*() { Flush(); return pBuf; }
     virtual sal_uInt16  IsA() const;
diff --git a/tools/source/fsys/unx.cxx b/tools/source/fsys/unx.cxx
index 76910683df13..4a2e3c6ad76a 100644
--- a/tools/source/fsys/unx.cxx
+++ b/tools/source/fsys/unx.cxx
@@ -36,7 +36,7 @@
 #include <stdlib.h>
 #include <unistd.h>
 #include <utime.h>
-#if defined HPUX || defined LINUX || defined IRIX
+#if defined HPUX || defined LINUX
 #include <mntent.h>
 #define mnttab mntent
 #elif defined SCO
diff --git a/tools/source/fsys/urlobj.cxx b/tools/source/fsys/urlobj.cxx
index f7ffed5e4dd1..e0f711bd2883 100644
--- a/tools/source/fsys/urlobj.cxx
+++ b/tools/source/fsys/urlobj.cxx
@@ -1022,16 +1022,14 @@ bool INetURLObject::setAbsURIRef(rtl::OUString const & rTheAbsURIRef,
                     if (pEnd - pPos >= 2 && pPos[0] == '/' && pPos[1] == '/')
                     {
                         sal_Unicode const * p1 = pPos + 2;
-                        if (
-                             p1 == pEnd || *p1 == nFragmentDelimiter || *p1 == '/' ||
-                             (
-                               (
-                                 scanDomain(p1, pEnd) > 0 ||
-                                 scanIPv6reference(p1, pEnd)
-                               ) &&
-                               (p1 == pEnd || *p1 == nFragmentDelimiter || *p1 == '/')
-                             )
-                           )
+                        while (p1 != pEnd && *p1 != '/' &&
+                               *p1 != nFragmentDelimiter)
+                        {
+                            ++p1;
+                        }
+                        if (parseHostOrNetBiosName(
+                                pPos + 2, p1, bOctets, ENCODE_ALL,
+                                RTL_TEXTENCODING_DONTKNOW, true, NULL))
                         {
                             aSynAbsURIRef.
                                 appendAscii(RTL_CONSTASCII_STRINGPARAM("//"));
diff --git a/tools/source/generic/poly.cxx b/tools/source/generic/poly.cxx
index 7f1eb94b646d..509d2ab4969d 100644
--- a/tools/source/generic/poly.cxx
+++ b/tools/source/generic/poly.cxx
@@ -1615,7 +1615,16 @@ void Polygon::Clip( const Rectangle& rRect, BOOL bPolygon )
 Rectangle Polygon::GetBoundRect() const
 {
     DBG_CHKTHIS( Polygon, NULL );
-    DBG_ASSERT( !mpImplPolygon->mpFlagAry, "GetBoundRect could fail with beziers!" );
+    // Removing the assert. Bezier curves have the attribute that each single
+    // curve segment defined by four points can not exit the four-point polygon
+    // defined by that points. This allows to say that the curve segment can also
+    // never leave the Range of it's defining points.
+    // The result is that Polygon::GetBoundRect() may not create the minimal
+    // BoundRect of the Polygon (to get that, use basegfx::B2DPolygon classes),
+    // but will always create a valid BoundRect, at least as long as this method
+    // 'blindly' travels over all points, including control points.
+    //
+    // DBG_ASSERT( !mpImplPolygon->mpFlagAry, "GetBoundRect could fail with beziers!" );
 
     USHORT  nCount = mpImplPolygon->mnPoints;
     if( ! nCount )
diff --git a/tools/source/memtools/makefile.mk b/tools/source/memtools/makefile.mk
index 037dadbf4a46..51d831ec0fed 100644
--- a/tools/source/memtools/makefile.mk
+++ b/tools/source/memtools/makefile.mk
@@ -47,6 +47,8 @@ SLOFILES=	$(SLO)$/contnr.obj	\
             $(SLO)$/mempool.obj \
             $(SLO)$/multisel.obj
 
+EXCEPTIONSFILES= $(SLO)$/multisel.obj $(OBJ)$/multisel.obj
+
 OBJFILES=	$(OBJ)$/contnr.obj	 \
             $(OBJ)$/table.obj	 \
             $(OBJ)$/unqidx.obj	 \
diff --git a/tools/source/memtools/multisel.cxx b/tools/source/memtools/multisel.cxx
index 6b32badc283e..5fe920b6998a 100644
--- a/tools/source/memtools/multisel.cxx
+++ b/tools/source/memtools/multisel.cxx
@@ -41,12 +41,16 @@
 #include <tools/debug.hxx>
 #include <tools/multisel.hxx>
 
+#include "rtl/ustrbuf.hxx"
+
 #ifdef MI_DEBUG
 #define DBG(x) x
 #else
 #define DBG(x)
 #endif
 
+using namespace rtl;
+
 //==================================================================
 
 #ifdef MI_DEBUG
@@ -865,3 +869,297 @@ void MultiSelection::SetTotalRange( const Range& rTotRange )
     bCurValid = FALSE;
     nCurIndex = 0;
 }
+
+// -----------------------------------------------------------------------
+//
+// StringRangeEnumerator
+//
+// -----------------------------------------------------------------------
+StringRangeEnumerator::StringRangeEnumerator( const rtl::OUString& i_rInput,
+                                              sal_Int32 i_nMinNumber,
+                                              sal_Int32 i_nMaxNumber,
+                                              sal_Int32 i_nLogicalOffset
+                                              )
+    : mnCount( 0 )
+    , mnMin( i_nMinNumber )
+    , mnMax( i_nMaxNumber )
+    , mnOffset( i_nLogicalOffset )
+{
+    setRange( i_rInput );
+}
+
+bool StringRangeEnumerator::checkValue( sal_Int32 i_nValue, const std::set< sal_Int32 >* i_pPossibleValues ) const
+{
+    if( mnMin >= 0 && i_nValue < mnMin )
+        return false;
+    if( mnMax >= 0 && i_nValue > mnMax )
+        return false;
+    if( i_nValue < 0 )
+        return false;
+    if( i_pPossibleValues && i_pPossibleValues->find( i_nValue ) == i_pPossibleValues->end() )
+        return false;
+    return true;
+}
+
+bool StringRangeEnumerator::insertRange( sal_Int32 i_nFirst, sal_Int32 i_nLast, bool bSequence, bool bMayAdjust )
+{
+    bool bSuccess = true;
+    if( bSequence )
+    {
+        if( i_nFirst == -1 )
+            i_nFirst = mnMin;
+        if( i_nLast == -1 )
+            i_nLast = mnMax;
+        if( bMayAdjust )
+        {
+            if( i_nFirst < mnMin )
+                i_nFirst = mnMin;
+            if( i_nFirst > mnMax )
+                i_nFirst = mnMax;
+            if( i_nLast < mnMin )
+                i_nLast = mnMin;
+            if( i_nLast > mnMax )
+                i_nLast = mnMax;
+        }
+        if( checkValue( i_nFirst ) && checkValue( i_nLast ) )
+        {
+            maSequence.push_back( Range( i_nFirst, i_nLast ) );
+            sal_Int32 nNumber = i_nLast - i_nFirst;
+            nNumber = nNumber < 0 ? -nNumber : nNumber;
+            mnCount += nNumber + 1;
+        }
+        else
+            bSuccess = false;
+    }
+    else
+    {
+        if( i_nFirst >= 0 )
+        {
+            if( checkValue( i_nFirst ) )
+            {
+                maSequence.push_back( Range( i_nFirst, i_nFirst ) );
+                mnCount++;
+            }
+            else
+                bSuccess = false;
+        }
+        if( i_nLast >= 0 )
+        {
+            if( checkValue( i_nLast ) )
+            {
+                maSequence.push_back( Range( i_nLast, i_nLast ) );
+                mnCount++;
+            }
+            else
+                bSuccess = false;
+        }
+    }
+
+    return bSuccess;
+}
+
+bool StringRangeEnumerator::setRange( const rtl::OUString& i_rNewRange, bool i_bStrict )
+{
+    mnCount = 0;
+    maSequence.clear();
+
+    // we love special cases
+    if( i_rNewRange.getLength() == 0 )
+    {
+        if( mnMin >= 0 && mnMax >= 0 )
+        {
+            insertRange( mnMin, mnMax, mnMin != mnMax, ! i_bStrict );
+        }
+        return true;
+    }
+
+    const sal_Unicode* pInput = i_rNewRange.getStr();
+    rtl::OUStringBuffer aNumberBuf( 16 );
+    sal_Int32 nLastNumber = -1, nNumber = -1;
+    bool bSequence = false;
+    bool bSuccess = true;
+    while( *pInput )
+    {
+        while( *pInput >= sal_Unicode('0') && *pInput <= sal_Unicode('9') )
+            aNumberBuf.append( *pInput++ );
+        if( aNumberBuf.getLength() )
+        {
+            if( nNumber != -1 )
+            {
+                if( bSequence )
+                {
+                    if( ! insertRange( nLastNumber, nNumber, true, ! i_bStrict ) && i_bStrict )
+                    {
+                        bSuccess = false;
+                        break;
+                    }
+                    nLastNumber = -1;
+                }
+                else
+                {
+                    if( ! insertRange( nNumber, nNumber, false, ! i_bStrict ) && i_bStrict )
+                    {
+                        bSuccess = false;
+                        break;
+                    }
+                }
+            }
+            nNumber = aNumberBuf.makeStringAndClear().toInt32();
+            nNumber += mnOffset;
+        }
+        bool bInsertRange = false;
+        if( *pInput == sal_Unicode('-') )
+        {
+            nLastNumber = nNumber;
+            nNumber = -1;
+            bSequence = true;
+        }
+        else if( *pInput == ' ' )
+        {
+        }
+        else if( *pInput == sal_Unicode(',') || *pInput == sal_Unicode(';') )
+            bInsertRange = true;
+        else if( *pInput )
+        {
+
+            bSuccess = false;
+            break; // parse error
+        }
+
+        if( bInsertRange )
+        {
+            if( ! insertRange( nLastNumber, nNumber, bSequence, ! i_bStrict ) && i_bStrict )
+            {
+                bSuccess = false;
+                break;
+            }
+            nNumber = nLastNumber = -1;
+            bSequence = false;
+        }
+        if( *pInput )
+            pInput++;
+    }
+    // insert last entries
+    insertRange( nLastNumber, nNumber, bSequence, ! i_bStrict );
+
+    return bSuccess;
+}
+
+bool StringRangeEnumerator::hasValue( sal_Int32 i_nValue, const std::set< sal_Int32 >* i_pPossibleValues ) const
+{
+    if( i_pPossibleValues && i_pPossibleValues->find( i_nValue ) == i_pPossibleValues->end() )
+        return false;
+    size_t n = maSequence.size();
+    for( size_t i= 0; i < n; ++i )
+    {
+        const StringRangeEnumerator::Range rRange( maSequence[i] );
+        if( rRange.nFirst < rRange.nLast )
+        {
+            if( i_nValue >= rRange.nFirst && i_nValue <= rRange.nLast )
+                return true;
+        }
+        else
+        {
+            if( i_nValue >= rRange.nLast && i_nValue <= rRange.nFirst )
+                return true;
+        }
+    }
+    return false;
+}
+
+StringRangeEnumerator::Iterator& StringRangeEnumerator::Iterator::operator++()
+{
+    if( nRangeIndex >= 0 && nCurrent >= 0 && pEnumerator )
+    {
+        const StringRangeEnumerator::Range& rRange( pEnumerator->maSequence[nRangeIndex] );
+        bool bRangeChange = false;
+        if( rRange.nLast < rRange.nFirst )
+        {
+            // backward range
+            if( nCurrent > rRange.nLast )
+                nCurrent--;
+            else
+                bRangeChange = true;
+        }
+        else
+        {
+            // forward range
+            if( nCurrent < rRange.nLast )
+                nCurrent++;
+            else
+                bRangeChange = true;
+        }
+        if( bRangeChange )
+        {
+            nRangeIndex++;
+            if( size_t(nRangeIndex) == pEnumerator->maSequence.size() )
+            {
+                // reached the end
+                nRangeIndex = nCurrent = -1;
+            }
+            else
+                nCurrent = pEnumerator->maSequence[nRangeIndex].nFirst;
+        }
+        if( nRangeIndex != -1 && nCurrent != -1 )
+        {
+            if( ! pEnumerator->checkValue( nCurrent, pPossibleValues ) )
+                return ++(*this);
+        }
+    }
+    return *this;
+}
+
+sal_Int32 StringRangeEnumerator::Iterator::operator*() const
+{
+    return nCurrent;
+}
+
+bool StringRangeEnumerator::Iterator::operator==( const Iterator& i_rCompare ) const
+{
+    return i_rCompare.pEnumerator == pEnumerator && i_rCompare.nRangeIndex == nRangeIndex && i_rCompare.nCurrent == nCurrent;
+}
+
+StringRangeEnumerator::Iterator StringRangeEnumerator::begin( const std::set< sal_Int32 >* i_pPossibleValues ) const
+{
+    StringRangeEnumerator::Iterator it( this,
+                                        i_pPossibleValues,
+                                        maSequence.empty() ? -1 : 0,
+                                        maSequence.empty() ? -1 : maSequence[0].nFirst );
+    if( ! checkValue(*it, i_pPossibleValues ) )
+        ++it;
+    return it;
+}
+
+StringRangeEnumerator::Iterator StringRangeEnumerator::end( const std::set< sal_Int32 >* i_pPossibleValues ) const
+{
+    return StringRangeEnumerator::Iterator( this, i_pPossibleValues, -1, -1 );
+}
+
+bool StringRangeEnumerator::getRangesFromString( const OUString& i_rPageRange,
+                                                 std::vector< sal_Int32 >& o_rPageVector,
+                                                 sal_Int32 i_nMinNumber,
+                                                 sal_Int32 i_nMaxNumber,
+                                                 sal_Int32 i_nLogicalOffset,
+                                                 std::set< sal_Int32 >* i_pPossibleValues
+                                               )
+{
+    StringRangeEnumerator aEnum;
+    aEnum.setMin( i_nMinNumber );
+    aEnum.setMax( i_nMaxNumber );
+    aEnum.setLogicalOffset( i_nLogicalOffset );
+
+    bool bRes = aEnum.setRange( i_rPageRange );
+    if( bRes )
+    {
+        o_rPageVector.clear();
+        o_rPageVector.reserve( aEnum.size() );
+        for( StringRangeEnumerator::Iterator it = aEnum.begin( i_pPossibleValues );
+             it != aEnum.end( i_pPossibleValues ); ++it )
+        {
+            o_rPageVector.push_back( *it );
+        }
+    }
+
+    return bRes;
+}
+
diff --git a/tools/workben/urltest.cxx b/tools/workben/urltest.cxx
index a232f8ebdd93..0e9d22081cb4 100644
--- a/tools/workben/urltest.cxx
+++ b/tools/workben/urltest.cxx
@@ -1629,6 +1629,20 @@ main()
             rtl::OUString(urlobj.GetMainURL(INetURLObject::NO_DECODE)));
     }
 
+    if (true) { // #i53184#
+        rtl::OUString url(RTL_CONSTASCII_USTRINGPARAM("file://comp_name/path"));
+        bSuccess &= assertEqual(
+            rtl::OUString(
+                RTL_CONSTASCII_USTRINGPARAM("#i53184# smart INET_PROT_FILE")),
+            INetURLObject(url, INET_PROT_FILE).GetMainURL(
+                INetURLObject::NO_DECODE),
+            url);
+        bSuccess &= assertEqual(
+            rtl::OUString(
+                RTL_CONSTASCII_USTRINGPARAM("#i53184# strict")),
+            INetURLObject(url).GetMainURL(INetURLObject::NO_DECODE), url);
+    }
+
     if (true) {
         rtl::OUString path;
         path = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("/a/b/c"));