//Test to see if this begins with xml and if so run it through

                // DesignScience Equation Editor MathType 3.0

				//the MathML filter. There are all sorts of things wrong with

				//this approach, to be fixed at a better level than here

                        // #124636# detection should not only check for xml, but at least also for

                        // MathML. The SAX parser expects the 'math' root element incl.

                        // the math start element and the MathML URL. Additionally take their order

                        // the namespace URL. Neither '<?xml' prolog nor <!doctype is needed.

                        // into account. Also allow the case where the start element has a namespace

                        // If the math element has a prefix (e.g. <bla:math), the

                        // (e.g. <bla:math), but in that case ensure that it is in front of an evtl.

                        // prefix has to be defined in the namespace attribut

                        // xmlns:math namespace declaration and thus not part of that

                        // (e.g. xmlns:bla="http://www.w3.org/1998/Math/MathML")

                        const sal_uInt16 nReadSize(4095);

                        // #124636 is fixed too.

                        sal_Char aBuffer[nReadSize+1];

                        const sal_uLong nBytesRead(pStrm->Read( aBuffer, nReadSize ));

                        const size_t nBufSize=2048;

                        sal_uInt16 aBuffer[nBufSize]; // will be casted to an Unicode-Array below

                        if(nBytesRead > (5 + 1 + 34 + 5)) // xml + '>' + URL + '(<|:)math'

                        sal_uInt8* pByte = reinterpret_cast<sal_uInt8*>(aBuffer);

                        const sal_uLong nBytesRead(pStrm->Read( pByte, nBufSize * 2 ) );

                        const sal_uLong nUnicodeCharsRead (nBytesRead / 2 );

                        // For backwards searching an OUString is used. The conversion needs an

                        // encoding information. Default endocing is UTF-8, UTF-16 is possible

                        // (e.g. from MS "Math Input Control"), others are unlikely.

                        // Looking for Byte Order Mark

                        rtl_TextEncoding eEncoding = RTL_TEXTENCODING_UTF8;

                        bool bIsUnicode = false;

                        if (nBytesRead >= 2 && (aBuffer[0]==0xfffe || aBuffer[0]==0xfeff) )

                            // end string with null

                            eEncoding = RTL_TEXTENCODING_UNICODE;

                            aBuffer[nBytesRead + 1] = 0;

                            bIsUnicode = true;

                        }

                            // is it a xml file? 

                            const sal_Char* pXML = strstr(aBuffer, "<?xml");

                            bool isMathFile(false);

                            if(pXML)

                        bool isMathFile(false);

                        if ( nBytesRead > 56) // minimal length of 'math' element incl. namespace URL in UTF-8

                        {

                            const sal_Char* pChar = reinterpret_cast<sal_Char*>(aBuffer);

                            sal_Unicode* pUnicode = (sal_Unicode*) aBuffer;

                            OUString sFragment( (bIsUnicode)  ?

                                     OUString( pUnicode , nUnicodeCharsRead )

                                   : OUString( pChar, nBytesRead, eEncoding) );

                            // look for MathML URL

                            OUString sURL( OUString::createFromAscii("http://www.w3.org/1998/Math/MathML"));

                            sal_Int32 nPosURL;

                            nPosURL = sFragment.indexOf(sURL);

                            if (nPosURL >= 0)

                                // does it have the MathML URL?

                                // The URL has to be value of an xmlns attribute

                                const sal_Char* pURL = strstr(aBuffer, "http://www.w3.org/1998/Math/MathML");

                                sal_Int32 nPosEQ;

                                nPosEQ = sFragment.lastIndexOf(OUString::createFromAscii("="),nPosURL);

                                // URL has to be after XML start

                                if (nPosEQ >= 0)

                                if(pURL && pURL > pXML)

                                    // look if we have a direct math start element

                                    OUString sXMLNS( OUString::createFromAscii("xmlns"));

                                    sal_Char* pMathStart = strstr(aBuffer, "<math");

                                    sal_Int32 nPosXMLNS;

                                    nPosXMLNS = sFragment.lastIndexOf(sXMLNS,nPosEQ);

                                    if(!pMathStart)

                                    if(nPosXMLNS >= 0)

                                        // if not, look if we have a math start element in another namespace

                                        // a prefix might be defined

                                        pMathStart = strstr(aBuffer, ":math");

                                        OUString sPrefix = (sFragment.copy(nPosXMLNS+5,nPosEQ-(nPosXMLNS+5))).trim();

                                        // such prefix definition must start with colon (will be removed below)

                                        if(pMathStart)

                                        bool bHasPrefix( (sPrefix.isEmpty()) ? false : sPrefix.toChar() == sal_Unicode(':') );

                                        // now look for math element start '<prefix:math' or '<math'

                                        OUString sMathStart( (bHasPrefix) ?

                                                    OUString::createFromAscii("<") + sPrefix.copy(1,sPrefix.getLength()-1) + OUString::createFromAscii(":math")

                                                :   OUString::createFromAscii("<math") );

                                        sal_Int32 nPosMath;

                                        nPosMath = sFragment.lastIndexOf(sMathStart,nPosXMLNS);

                                        if( nPosMath >= 0)

                                            // if found, this has to be in front of the evtl. also existing namespace

                                            isMathFile = true;

                                            // declaration also containing :math to be the start element

                                            sal_Char* pNamespaceMath = strstr(aBuffer, "xmlns:math");

                                            if(pNamespaceMath && pMathStart > pNamespaceMath)

                                            {

                                                // invalid :math found (probably part of the namespace declaration)

                                                // -> this cannot be the math start element

                                                pMathStart = 0;

                                            }