1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_filter.hxx"
26 
27 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil -*- */
28 #include <com/sun/star/uno/Any.h>
29 #include <com/sun/star/text/VertOrientation.hpp>
30 #include <com/sun/star/text/XText.hpp>
31 #ifndef _COM_SUN_STAR_LANG_XSERVICEINFO_HDL_
32 #include <com/sun/star/lang/XServiceInfo.hpp>
33 #endif
34 #include <com/sun/star/text/TextContentAnchorType.hpp>
35 #include <com/sun/star/drawing/XShape.hpp>
36 #include <com/sun/star/beans/XPropertySet.hpp>
37 #include <com/sun/star/drawing/XDrawPage.hpp>
38 #include <com/sun/star/drawing/XShapes.hpp>
39 #include <com/sun/star/drawing/XControlShape.hpp>
40 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
41 #include <com/sun/star/container/XIndexContainer.hpp>
42 #include <com/sun/star/drawing/XDrawPageSupplier.hpp>
43 #include <com/sun/star/form/XFormsSupplier.hpp>
44 #include <com/sun/star/form/XForm.hpp>
45 #include <com/sun/star/form/FormComponentType.hpp>
46 #include <com/sun/star/awt/FontWeight.hpp>
47 #include <com/sun/star/awt/FontSlant.hpp>
48 #include <com/sun/star/awt/FontUnderline.hpp>
49 #include <com/sun/star/awt/FontStrikeout.hpp>
50 #include <com/sun/star/awt/ScrollBarOrientation.hpp>
51 #include <com/sun/star/style/VerticalAlignment.hpp>
52 #include <comphelper/extract.hxx>
53 #include <com/sun/star/awt/XControlModel.hpp>
54 #include <com/sun/star/io/XInputStreamProvider.hpp>
55 #include <rtl/ustrbuf.hxx>
56 #include <vcl/svapp.hxx>
57 #include <sfx2/objsh.hxx>
58 #include <xmlscript/xmldlg_imexp.hxx>
59 #include <filter/msfilter/msocximex.hxx>
60 #include <osl/file.hxx>
61 #include <unotools/ucbstreamhelper.hxx>
62 #include <com/sun/star/embed/XStorage.hpp>
63 #include <com/sun/star/embed/XTransactedObject.hpp>
64 #include <com/sun/star/embed/ElementModes.hpp>
65 #include <comphelper/processfactory.hxx> // shouldn't be needed
66 #include <com/sun/star/ucb/XSimpleFileAccess.hpp>
67 #include <algorithm>
68 #include <memory>
69 
70 #ifndef C2S
71 #define C2S(cChar)	String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM(cChar))
72 #endif
73 #ifndef C2U
74 #define C2U(cChar)	rtl::OUString::createFromAscii(cChar)
75 #endif
76 
77 using namespace ::com::sun::star;
78 using namespace ::rtl;
79 using namespace cppu;
80 
81 
82 #define WW8_ASCII2STR(s) String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM(s))
83 
84 
85 static char sWW8_form[] = "WW-Standard";
86 
87 
88 struct SortOrderByTabPos
89 {
operator ()SortOrderByTabPos90     bool operator()( const OCX_Control* a, const OCX_Control* b )
91     {
92         return a->mnTabPos < b->mnTabPos;
93     }
94 };
95 
96 
97 sal_uInt8 __READONLY_DATA OCX_Control::aObjInfo[4] = { 0x00, 0x12, 0x03, 0x00 };
98 
ReadAlign(SvStorageStream * pS,long nPos,int nAmount)99 long ReadAlign(SvStorageStream *pS, long nPos, int nAmount)
100 {
101 	if (long nAlign = nPos % nAmount)
102 	{
103 
104         long nLen = nAmount - nAlign;
105     	pS->SeekRel(nLen);
106         return nLen;
107 	}
108     return 0;
109 }
110 
111 
112 // NP - Images in controls in OO2.0/SO8 exist as links, e.g. they are not part of the document so are
113 // referenced externally. On import from ms document try to save images for controls here.
114 // Images are stored in directory called temp in the user installation directory. Next version of OO/SO
115 // hopefully will address this issue and allow a choice e.g. images for controls to be stored as links
116 // or embedded in the document.
117 
118 // [out]location     path to the stream to where the image is to be stored,
119 //               if same name exists in folder then this function calculates a new name
120 // [in] data     raw bytes of image to be stored.
121 // [in] dataLen  no. byte to be stored
122 //
123 // returns, true if successful
124 
storePictureInFileSystem(OUString & location,sal_uInt8 * data,sal_uInt32 dataLen)125 bool storePictureInFileSystem( OUString& location, sal_uInt8* data, sal_uInt32 dataLen )
126 {
127     bool result = true;
128     OUString origPath = location;
129     try
130     {
131         uno::Reference<lang::XMultiServiceFactory > xMSF( ::comphelper::getProcessServiceFactory(),
132                                                       uno::UNO_QUERY_THROW );
133         uno::Reference< com::sun::star::ucb::XSimpleFileAccess> xSFA( xMSF->createInstance(
134                                                        OUString::createFromAscii( "com.sun.star.ucb.SimpleFileAccess") ),
135                                                        uno::UNO_QUERY_THROW );
136         OUString ext;
137         sal_Int32 index = 0;
138         while (  xSFA->exists( location ) )
139         {
140             ext = OUString::valueOf( ++index );
141             location = origPath + ext;
142         }
143 
144         SvStream*  pStream = ::utl::UcbStreamHelper::CreateStream( location, STREAM_WRITE | STREAM_TRUNC );
145         if ( pStream )
146         {
147             pStream->Write(data, dataLen);
148             delete pStream;
149         }
150         else
151         {
152             result = false;
153         }
154     }
155     catch( uno::Exception& )
156     {
157         result = false;
158     }
159     return result;
160 }
161 
162 // NP - Images in controls in OO2.0/SO8 exist as links, e.g. they are not part of the document so are
163 // referenced externally. On import from ms document try to save images from controls here so this
164 // at least a macro programmer has a chance to accessed them manually later. Next version of OO/SO
165 // hopefully will address this issue.
166 // Images will be stored in a top level folder in the document package, folder is named "MigratedImages"
167 
168 // [in] pDocSh*  the document shell.
169 // [in] name     name of stream image to stored in.
170 // [in] data     raw bytes of image to be stored.
171 // [in] dataLen  no. byte to be stored
172 
storePictureInDoc(SfxObjectShell * pDocSh,OUString & name,sal_uInt8 * data,sal_uInt32 dataLen)173 bool storePictureInDoc( SfxObjectShell* pDocSh, OUString& name, sal_uInt8* data, sal_uInt32 dataLen )
174 {
175     uno::Reference < embed::XStorage > xStor;
176     if (pDocSh)
177     {
178         xStor = pDocSh->GetStorage();
179         if( xStor.is() )
180         {
181             try
182             {
183                 uno::Reference< embed::XStorage > xPictures = xStor->openStorageElement(
184                     OUString( RTL_CONSTASCII_USTRINGPARAM( "MigratedImages" ) ),
185                     embed::ElementModes::READWRITE );
186                 uno::Reference< beans::XPropertySet > xPropSet( xPictures, uno::UNO_QUERY );
187 
188                 // Set media type of folder MigratedImages to something ( that is unknown ) so that
189                 // it will get copied to exported OO/SO format after SaveAs
190                 if ( xPropSet.is() )
191                 {
192                     OUString aMediaType = C2U("MigrationImages");
193                     uno::Any a;
194                     a <<= aMediaType;
195                     xPropSet->setPropertyValue( C2U("MediaType"), a );
196                 }
197 
198                 uno::Reference< io::XStream > xObjReplStr = xPictures->openStreamElement(
199                         name,
200                         embed::ElementModes::READWRITE | embed::ElementModes::TRUNCATE );
201                 uno::Reference< io::XOutputStream > xOutStream( xObjReplStr->getOutputStream(), uno::UNO_QUERY_THROW );
202                 uno::Sequence< sal_Int8 > imageBytes( (sal_Int8*)data, dataLen );
203                 xOutStream->writeBytes( imageBytes );
204                 xOutStream->closeOutput();
205 
206                 uno::Reference< embed::XTransactedObject > xTransact( xPictures, uno::UNO_QUERY );
207                 if ( xTransact.is() )
208                 {
209                     xTransact->commit();
210                 }
211             }
212             catch( uno::Exception& )
213             {
214                 return false;
215             }
216 
217         }
218         else
219         {
220             // no storage something wrong
221             return false;
222         }
223     }
224     else
225     {
226         //No doc shell
227         return false;
228     }
229     return true;
230 }
231 
WriteAlign(SvStorageStream * pS,int nAmount)232 long WriteAlign(SvStorageStream *pS, int nAmount)
233 {
234 	if (long nAlign = pS->Tell() % nAmount)
235 	{
236         long nLen = nAmount - nAlign;
237 		for (long i=0; i< nLen; ++i)
238 			*pS << sal_uInt8(0x00);
239         return nLen;
240 	}
241     return 0;
242 }
243 // string import/export =======================================================
244 /** #117832#  import of form control names
245 * control name is located in stream ("\3OCXNAME")
246 * a strings in "\3OCXNAME" stream seem to be terminated by 4 trailing bytes of 0's.
247 *                              ====
248 * Note: If the string in the stream is overwritten by a shorter string
249 * some characters from the original string may remain, the new string however
250 * will still be terminated in the same way e.g. by 4 bytes with value 0.
251 */
252 
writeOCXNAME(const OUString & sOCXName,SvStorageStream * pStream)253 bool writeOCXNAME( const OUString& sOCXName, SvStorageStream* pStream )
254 {
255     const sal_Unicode* buffer = sOCXName.getStr();
256     for ( sal_Int32 index=0; index < sOCXName.getLength(); index++ )
257     {
258         sal_uInt16 ch = static_cast< sal_uInt16 >( buffer[ index ] );
259         *pStream << ch;
260     }
261     // write
262     *pStream << sal_uInt32(0);
263     return ( SVSTREAM_OK == pStream->GetError() );
264 
265 }
266 
readOCXNAME(OUString & sCName,SvStorageStream * pStream)267 bool readOCXNAME( OUString& sCName, SvStorageStream* pStream )
268 {
269     /*
270     * Read uniCode until no data or 0 encountered
271     */
272     OUStringBuffer buf(40);
273     do
274     {
275         sal_uInt16 ch = 0;
276         *pStream >> ch;
277         sal_Unicode uni = static_cast< sal_Unicode >( ch );
278         if ( uni == 0 )
279         {
280             break;
281         }
282         buf.append( &uni, 1 );
283 
284     } while ( !pStream->IsEof() );
285 
286     sCName = buf.makeStringAndClear();
287     return ( SVSTREAM_OK == pStream->GetError() );
288 }
289 
290 
291 /*  #110435# (DR, 2003-11-12) ** Import of Unicode strings in form controls **
292 
293     Strings may be stored either as compressed or uncompressed Unicode
294     character array. There are no encoded byte strings anywhere.
295 
296     The string length field stores the length of the character array (not the
297     character count of the string) in the lower 31 bits, and the compression
298     state in the highest bit.
299 
300     A set bit means the character array is compressed. This means all Unicode
301     characters are <=0xFF. Therefore the high bytes of all characters are left
302     out, and the character array size is equal to the string length.
303 
304     A cleared bit means the character array is not compressed. The buffer
305     contains Little-Endian Unicode characters, and the resulting string length
306     is half the buffer size.
307 
308     TODO: This implementation of the new string import is a hack to keep
309     msocximex.hxx unchanged. A better implementation would replace the char*
310     members of all classes by something more reasonable.
311  */
312 
313 namespace {
314 
315 const sal_uInt32 SVX_MSOCX_SIZEMASK     = 0x7FFFFFFF;   /// Mask for character buffer size.
316 const sal_uInt32 SVX_MSOCX_COMPRESSED   = 0x80000000;   /// 1 = compressed Unicode array.
317 
318 
319 /** Returns true, if the passed length field specifies a compressed character array.
320  */
lclIsCompressed(sal_uInt32 nLenFld)321 inline bool lclIsCompressed( sal_uInt32 nLenFld )
322 {
323     return (nLenFld & SVX_MSOCX_COMPRESSED) != 0;
324 }
325 
326 
327 /** Extracts and returns the memory size of the character buffer.
328     @return  Character buffer size (may differ from resulting string length!).
329  */
lclGetBufferSize(sal_uInt32 nLenFld)330 inline sal_uInt32 lclGetBufferSize( sal_uInt32 nLenFld )
331 {
332     return nLenFld & SVX_MSOCX_SIZEMASK;
333 }
334 
335 
336 // import ---------------------------------------------------------------------
337 
338 /** Reads the character array of a string in a form control.
339 
340     Creates a new character array containing the character data.
341     The length field must be read before and passed to this function.
342     Aligns stream position to multiple of 4 before.
343 
344     @param rStrm
345         The input stream.
346 
347     @param rpcCharArr
348         (out-param) Will point to the created character array,
349         or will be 0 if string is empty. The array is NOT null-terminated.
350         If the passed pointer points to an old existing array, it will be
351         deleted before. Caller must delete the returned array.
352 
353     @param nLenFld
354         The corresponding string length field read somewhere before.
355  */
lclReadCharArray(SvStorageStream & rStrm,char * & rpcCharArr,sal_uInt32 nLenFld,long nPos)356 void lclReadCharArray( SvStorageStream& rStrm, char*& rpcCharArr, sal_uInt32 nLenFld, long nPos )
357 {
358     delete[] rpcCharArr;
359     rpcCharArr = 0;
360     sal_uInt32 nBufSize = lclGetBufferSize( nLenFld );
361     DBG_ASSERT( nBufSize <= 0xFFFF, "lclReadCharArray - possible read error: char array is too big" );
362     if( nBufSize && nBufSize <= 0xFFFF )
363     {
364         rpcCharArr = new char[ nBufSize ];
365         if( rpcCharArr )
366         {
367             ReadAlign( &rStrm, nPos, 4 );
368             rStrm.Read( rpcCharArr, nBufSize );
369         }
370     }
371 }
372 
373 
374 /** Creates an OUString from a character array created with lclReadCharArray().
375 
376     The passed parameters must match, that means the length field must be the
377     same used to create the passed character array.
378 
379     @param pcCharArr
380         The character array returned by lclReadCharArray(). May be compressed
381         or uncompressed, next parameter nLenFld will specify this.
382 
383     @param nLenFld
384         MUST be the same string length field that has been passed to
385         lclReadCharArray() to create the character array in previous parameter
386         pcCharArr.
387 
388     @return
389         An OUString containing the decoded string data. Will be empty if
390         pcCharArr is 0.
391  */
lclCreateOUString(const char * pcCharArr,sal_uInt32 nLenFld)392 OUString lclCreateOUString( const char* pcCharArr, sal_uInt32 nLenFld )
393 {
394     OUStringBuffer aBuffer;
395     sal_uInt32 nBufSize = lclGetBufferSize( nLenFld );
396     if( lclIsCompressed( nLenFld ) )
397     {
398         // buffer contains compressed Unicode, not encoded bytestring
399         sal_Int32 nStrLen = static_cast< sal_Int32 >( nBufSize );
400         aBuffer.setLength( nStrLen );
401         const char* pcCurrChar = pcCharArr;
402         for( sal_Int32 nChar = 0; nChar < nStrLen; ++nChar, ++pcCurrChar )
403             /*  *pcCurrChar may contain negative values and therefore MUST be
404                 casted to unsigned char, before assigned to a sal_Unicode. */
405             aBuffer.setCharAt( nChar, static_cast< unsigned char >( *pcCurrChar ) );
406     }
407     else
408     {
409         // buffer contains Little-Endian Unicode
410         sal_Int32 nStrLen = static_cast< sal_Int32 >( nBufSize ) / 2;
411         aBuffer.setLength( nStrLen );
412         const char* pcCurrChar = pcCharArr;
413         for( sal_Int32 nChar = 0; nChar < nStrLen; ++nChar )
414         {
415             /*  *pcCurrChar may contain negative values and therefore MUST be
416                 casted to unsigned char, before assigned to a sal_Unicode. */
417             sal_Unicode cChar = static_cast< unsigned char >( *pcCurrChar++ );
418             cChar |= (static_cast< unsigned char >( *pcCurrChar++ ) << 8);
419             aBuffer.setCharAt( nChar, cChar );
420         }
421     }
422     return aBuffer.makeStringAndClear();
423 }
424 
425 // export ---------------------------------------------------------------------
426 
427 /** This class implements writing a character array from a Unicode string.
428 
429     Usage:
430     1)  Construct an instance, either directly with an OUString, or with an UNO
431         Any containing an OUString.
432     2)  Check with HasData(), if there is something to write.
433     3)  Write the string length field with WriteLenField() at the right place.
434     4)  Write the encoded character array with WriteCharArray().
435  */
436 class SvxOcxString
437 {
438 public:
439     /** Constructs an empty string. String data may be set later by assignment. */
SvxOcxString()440     inline explicit             SvxOcxString() : mnLenFld( 0 ) {}
441     /** Constructs the string from the passed OUString. */
SvxOcxString(const OUString & rStr)442     inline explicit             SvxOcxString( const OUString& rStr ) { Init( rStr ); }
443     /** Constructs the string from the passed UNO Any. */
SvxOcxString(const uno::Any & rAny)444     inline explicit             SvxOcxString( const uno::Any& rAny ) { Init( rAny ); }
445 
446     /** Assigns the passed string to the object. */
operator =(const OUString & rStr)447     inline SvxOcxString&        operator=( const OUString& rStr ) { Init( rStr ); return *this; }
448     /** Assigns the string in the passed UNO Any to the object. */
operator =(const uno::Any & rAny)449     inline SvxOcxString&        operator=( const uno::Any& rAny ) { Init( rAny ); return *this; }
450 
451     /** Returns true, if the string contains at least one character to write. */
HasData() const452     inline bool                 HasData() const { return maString.getLength() > 0; }
453 
454     /** Writes the encoded 32-bit string length field. Aligns stream position to mult. of 4 before. */
455     void                        WriteLenField( SvStorageStream& rStrm ) const;
456     /** Writes the encoded character array. Aligns stream position to mult. of 4 before. */
457     void                        WriteCharArray( SvStorageStream& rStrm ) const;
458 
459 private:
Init(const OUString & rStr)460     inline void                 Init( const OUString& rStr ) { maString = rStr; Init(); }
461     void                        Init( const uno::Any& rAny );
462     void                        Init();
463 
464     OUString                    maString;       /// The initial string data.
465     sal_uInt32                  mnLenFld;       /// The encoded string length field.
466 };
467 
Init(const uno::Any & rAny)468 void SvxOcxString::Init( const uno::Any& rAny )
469 {
470     if( !(rAny >>= maString) )
471         maString = OUString();
472     Init();
473 }
474 
Init()475 void SvxOcxString::Init()
476 {
477     mnLenFld = static_cast< sal_uInt32 >( maString.getLength() );
478     bool bCompr = true;
479     // try to find a character >= 0x100 -> character array will be stored uncompressed then
480     if( const sal_Unicode* pChar = maString.getStr() )
481         for( const sal_Unicode* pEnd = pChar + maString.getLength(); bCompr && (pChar < pEnd); ++pChar )
482             bCompr = (*pChar < 0x100);
483     if( bCompr )
484         mnLenFld |= SVX_MSOCX_COMPRESSED;
485     else
486         mnLenFld *= 2;
487 }
488 
WriteLenField(SvStorageStream & rStrm) const489 void SvxOcxString::WriteLenField( SvStorageStream& rStrm ) const
490 {
491     if( HasData() )
492     {
493         WriteAlign( &rStrm, 4);
494         rStrm << mnLenFld;
495     }
496 }
497 
WriteCharArray(SvStorageStream & rStrm) const498 void SvxOcxString::WriteCharArray( SvStorageStream& rStrm ) const
499 {
500     if( HasData() )
501     {
502         const sal_Unicode* pChar = maString.getStr();
503         const sal_Unicode* pEnd = pChar + maString.getLength();
504         bool bCompr = lclIsCompressed( mnLenFld );
505 
506         WriteAlign( &rStrm, 4);
507         for( ; pChar < pEnd; ++pChar )
508         {
509             // write compressed Unicode (not encoded bytestring), or Little-Endian Unicode
510             rStrm << static_cast< sal_uInt8 >( *pChar );
511             if( !bCompr )
512                 rStrm << static_cast< sal_uInt8 >( *pChar >> 8 );
513         }
514     }
515 }
516 
517 const sal_uInt16 USERFORM = (sal_uInt16)0xFF;
518 const sal_uInt16 STDCONTAINER = (sal_uInt16)0xFE;
519 
520 const sal_uInt16 PAGE = (sal_uInt16)0x07;
521 
522 const sal_uInt16 IMAGE = (sal_uInt16)0x0C;
523 const sal_uInt16 FRAME = (sal_uInt16)0x0E;
524 
525 const sal_uInt16 SPINBUTTON = (sal_uInt16)0x10;
526 const sal_uInt16 CMDBUTTON = (sal_uInt16)0x11;
527 const sal_uInt16 TABSTRIP = (sal_uInt16)0x12;
528 
529 const sal_uInt16 LABEL = (sal_uInt16)0x15;
530 
531 const sal_uInt16 TEXTBOX = (sal_uInt16)0x17;
532 const sal_uInt16 LISTBOX = (sal_uInt16)0x18;
533 const sal_uInt16 COMBOBOX = (sal_uInt16)0x19;
534 const sal_uInt16 CHECKBOX = (sal_uInt16)0x1A;
535 
536 const sal_uInt16 OPTIONBUTTON = (sal_uInt16)0x1B;
537 const sal_uInt16 TOGGLEBUTTON = (sal_uInt16)0x1C;
538 
539 const sal_uInt16 SCROLLBAR = (sal_uInt16)0x2F;
540 
541 const sal_uInt16 MULTIPAGE = (sal_uInt16)0x39;
542 const sal_uInt16 PROGRESSBAR = (sal_uInt16)0x8000;
543 
544 typedef std::vector< ContainerRecord > ContainerRecordList;
545 
546 class ContainerRecReader
547 {
548     public:
549 
~ContainerRecReader()550     virtual ~ContainerRecReader() {}
551 
Read(OCX_ContainerControl * pContainerControl,SvStorageStream * pS)552     virtual bool Read( OCX_ContainerControl* pContainerControl, SvStorageStream *pS)
553     {
554         *pS >> nNoRecords;
555         *pS >> nTotalLen;
556 
557         if ( isMultiPage )
558         {
559             if ( !handleMultiPageHdr( pS ) )
560             {
561                 return false;
562             }
563         }
564         else
565         {
566             if ( !handleStandardHdr( pS ) )
567             {
568                 return false;
569             }
570         }
571 
572         records.clear();
573         for (sal_uInt32 nRecord = 0; nRecord < nNoRecords; ++nRecord)
574         {
575             // DR #134146# redo loading of FrameChild data
576 
577             ContainerRecord rec;
578 
579             // record header
580             sal_uInt16 nId, nSize;
581             *pS >> nId >> nSize;
582             sal_Size nStartPos = pS->Tell();
583 
584             // content flags
585             sal_uInt32 nContentFlags;
586             *pS >> nContentFlags;
587 
588             // length of control name
589             sal_uInt32 nNameLen = 0;
590             if( nContentFlags & 0x00000001 )
591                 *pS >> nNameLen;
592             // length of control tag
593             sal_uInt32 nTagLen = 0;
594             if( nContentFlags & 0x00000002 )
595                 *pS >> nTagLen;
596             // substorage id for frames
597             if( nContentFlags & 0x00000004 )
598                 *pS >> rec.nSubStorageId;
599             // help-context id
600             if( nContentFlags & 0x00000008 )
601                 pS->SeekRel( 4 );
602             // option flags
603             if( nContentFlags & 0x00000010 )
604             {
605                 sal_uInt32 nBitFlags = 0;
606                 *pS >> nBitFlags;
607                 rec.bVisible = ( ( nBitFlags & 0x02 ) == 0x02 );
608             }
609             // substream size
610             if( nContentFlags & 0x00000020 )
611                 *pS >> rec.nSubStreamLen;
612             // tabstop position
613             if( nContentFlags & 0x00000040 )
614                 *pS >> rec.nTabPos;
615             // control type
616             if( nContentFlags & 0x00000080 )
617                 *pS >> rec.nTypeIdent;
618             // length of infotip
619             sal_uInt32 nTipLen = 0;
620             if( nContentFlags & 0x00000800 )
621             {
622                 ReadAlign( pS, pS->Tell() - nStartPos, 4 );
623                 *pS >> nTipLen;
624             }
625 
626             sal_uInt32 nCntrlIdLen = 0;
627             if( nContentFlags & 0x00001000 )
628                 *pS >> nCntrlIdLen;
629 
630             // length of control source name
631             sal_uInt32 nCtrlSrcLen = 0;
632             if( nContentFlags & 0x00002000 )
633             {
634                 ReadAlign( pS, pS->Tell() - nStartPos, 4 );
635                 *pS >> nCtrlSrcLen;
636             }
637 
638             // length of row source name
639             sal_uInt32 nRowSrcLen = 0;
640             if( nContentFlags & 0x00004000 )
641             {
642                 ReadAlign( pS, pS->Tell() - nStartPos, 4 );
643                 *pS >> nRowSrcLen;
644             }
645 
646             // control name
647             sal_Char* pName = 0;
648             sal_uInt32 nNameBufSize = lclGetBufferSize( nNameLen );
649             if( nNameBufSize > 0 )
650             {
651                 pName = new char[ nNameBufSize ];
652                 ReadAlign( pS, pS->Tell() - nStartPos, 4 );
653                 pS->Read( pName, nNameBufSize );
654             }
655             // control tag
656             sal_uInt32 nTagBufSize = lclGetBufferSize( nTagLen );
657             if( nTagBufSize > 0 )
658             {
659                 ReadAlign( pS, pS->Tell() - nStartPos, 4 );
660                 pS->SeekRel( nTagBufSize );
661             }
662 
663             // control position
664             if( nContentFlags & 0x00000100 )
665             {
666                 ReadAlign( pS, pS->Tell() - nStartPos, 4 );
667                 *pS >> rec.nLeft >> rec.nTop;
668             }
669 
670             // control infotip
671             sal_uInt32 nTipBufSize = lclGetBufferSize( nTipLen );
672             if( nTipBufSize > 0 )
673             {
674                 std::auto_ptr< sal_Char > pTipName;
675                 pTipName.reset( new sal_Char[ nTipBufSize ] );
676                 ReadAlign( pS, pS->Tell() - nStartPos, 4 );
677                 pS->Read( pTipName.get(), nTipBufSize );
678             	rec.controlTip = lclCreateOUString( pTipName.get(), nTipLen );
679             }
680             // control id
681             sal_uInt32 nCntrlIdSize = lclGetBufferSize( nCntrlIdLen );
682             if( nCntrlIdSize > 0 )
683             {
684                 ReadAlign( pS, pS->Tell() - nStartPos, 4 );
685                 pS->SeekRel( nCntrlIdSize );
686             }
687             // control source name
688             sal_uInt32 nCtrlSrcBufSize = lclGetBufferSize( nCtrlSrcLen );
689             if( nCtrlSrcBufSize > 0 )
690             {
691                 ReadAlign( pS, pS->Tell() - nStartPos, 4 );
692                 pS->SeekRel( nCtrlSrcBufSize );
693             }
694             // row source name
695             sal_uInt32 nRowSrcBufSize = lclGetBufferSize( nRowSrcLen );
696             if( nRowSrcBufSize > 0 )
697             {
698                 ReadAlign( pS, pS->Tell() - nStartPos, 4 );
699                 pS->SeekRel( nRowSrcBufSize );
700             }
701 
702             // seek to end of data
703             pS->Seek( nStartPos + nSize );
704 
705             rec.cName = lclCreateOUString(pName, nNameLen);
706             delete[] pName;
707 
708             OCX_Control* pControl = NULL;
709             if( pContainerControl->createFromContainerRecord( rec, pControl ) &&
710                 pControl )
711             {
712                 // propagate doc shell from parent
713                 pControl->pDocSh = pContainerControl->pDocSh;
714                 pContainerControl->ProcessControl( pControl, pS, rec );
715             }
716             else
717             {
718                 DBG_ERROR("Terminating import, unexpected error");
719                 return false;
720             }
721         }
722         return true;
723     }
724 
725     protected:
ContainerRecReader()726     ContainerRecReader() : isMultiPage(false){}
727     bool isMultiPage;
728 	sal_uInt32 nNoRecords;
729 	sal_uInt32 nTotalLen;
730 
731     private:
handleStandardHdr(SvStorageStream * pS)732     bool handleStandardHdr( SvStorageStream* pS )
733     {
734         sal_uInt8 aUnknown11[4];
735         pS->Read(aUnknown11, sizeof(aUnknown11));
736         return true;
737     }
738 
handleMultiPageHdr(SvStorageStream * pS)739     bool handleMultiPageHdr( SvStorageStream* pS )
740     {
741         sal_uInt32 nUnknown_32b; // unknown 32 bit structure, flags ?
742         sal_uInt16 nUnknown_16b; // unknown 16 bit structure
743         sal_uInt16 nMysteryLen; // length of unknown sub record
744 
745         *pS >> nUnknown_32b;
746         *pS >> nUnknown_16b;
747         *pS >> nMysteryLen;
748 
749         pS->SeekRel( nMysteryLen );
750         return true;
751     }
752     ContainerRecordList records;
753 };
754 
755 class StdContainerRecReader : public ContainerRecReader
756 {
757     public:
StdContainerRecReader()758     StdContainerRecReader(){}
759 };
760 
761 class MultiPageContainerRecReader : public ContainerRecReader
762 {
763     public:
MultiPageContainerRecReader()764     MultiPageContainerRecReader()
765     {
766         // NP ( 27-01-05 )
767         // Strictly speaking this approach shouldn't be necessary.
768         // It should be possible to have a common routine read the
769         // container record array and by examining the flags present in
770         // the record to determine we expect to read or not.
771         // In this case for a MultPage control there is no Top or Left
772         // values in the control record array, however time contraints
773         // and associated risk prevent further investigation of this
774         // at the moment.
775         // similar situation exists for the start of the container record
776         // which in the case of the MultiPage is different from
777         // UserForm & Frame ( the other containers )
778 
779         isMultiPage = true; // tell the base class skip
780     }
781 };
782 
783 class ContainerRecordReaderFac
784 {
785     public:
instance(sal_uInt32 containerType)786     static ContainerRecReader* instance( sal_uInt32 containerType )
787     {
788         switch( containerType )
789         {
790             case PAGE:
791             case FRAME:
792             case USERFORM:
793             case STDCONTAINER:
794                 return new StdContainerRecReader();
795             case MULTIPAGE:
796                 return new MultiPageContainerRecReader();
797             default:
798                 DBG_ERROR("Illegal container type for factory");
799                 return NULL;
800         }
801     }
802     private:
803     ContainerRecordReaderFac();
804 };
805 
806 } // namespace
807 
808 // ============================================================================
809 
add(OCX_Control * pRB)810 void RBGroup::add(OCX_Control* pRB)
811 {
812     // The tab index for the group is calculated as
813     // the lowest tab index found in the list of RadioButtons
814     if ( pRB->mnTabPos < mRBGroupPos )
815     {
816         mRBGroupPos = pRB->mnTabPos;
817         CtrlIterator aEnd = mpControls.end();
818         for (CtrlIterator aIter = mpControls.begin(); aIter != aEnd; ++ aIter )
819         {
820             (*aIter)->mnTabPos = mRBGroupPos;
821         }
822     }
823     mpControls.push_back( pRB );
824 }
825 
826 struct SortGroupByTabPos
827 {
operator ()SortGroupByTabPos828     bool operator()( const RBGroup* a, const RBGroup* b )
829     {
830         return a->tabPos() < b->tabPos();
831     }
832 };
833 
RBGroupManager(String & defaultName)834 RBGroupManager::RBGroupManager( String& defaultName ):mSDefaultName( defaultName ),
835     numRadioButtons(0)
836 {
837     groupList.reserve( 8 ); // reserve far more than we expect
838 }
839 
~RBGroupManager()840 RBGroupManager::~RBGroupManager()
841 {
842     for ( GroupIterator gIter=groupList.begin(); gIter!=groupList.end(); ++gIter )
843     {
844         delete( *gIter );
845     }
846 }
847 
848 // Loose description of the method below ( I sure there is a better way to do
849 // this )
850 // In order to "fake" MS grouping behavior for OptionButtons the OptionButtons
851 // in the same group need to have consecutive tab indices ( regardless of the
852 // imported tab indices of the RadioButtons ). Additionally if two
853 // groups of OptionButtons end up having all consecutive indices they
854 // will be treated as a single group by OpenOffice. In this case
855 // a dummy seperator control needs to be inserted between the groups.
856 //
857 // This method returns a new list "destinationList" containing the controls
858 // passed in "sourceList" and the OptionButtons contained in the various
859 // Groups maintained by this  class.
860 // Controls are ordered in the destination list by tab index.
861 // Each RadioButtonGroup has a tab index associated with it.
862 // ( Tab index of a RadioGroup is determined as the tab index of the
863 // OptionButton control with the lowest tab index in the group )
864 
865 
addRadioButton(OCX_OptionButton * pRButton)866 void RBGroupManager::addRadioButton( OCX_OptionButton* pRButton )
867 {
868     if ( pRButton )
869     {
870         OUString groupName = mSDefaultName;
871         if ( pRButton->nGroupNameLen )
872         {
873             groupName =
874                 lclCreateOUString(pRButton->pGroupName,
875                     pRButton->nGroupNameLen);
876         }
877         ++numRadioButtons;
878         RBGroupHash::iterator iter = rbGroups.find( groupName );
879         if ( iter != rbGroups.end() )
880         {
881             iter->second->controls().push_back( pRButton );
882         }
883         else
884         {
885             RBGroup* newGroup = new RBGroup(pRButton->mnTabPos);
886             newGroup->controls().push_back( pRButton );
887             rbGroups[ groupName ] = newGroup;
888             groupList.push_back( newGroup );
889         }
890 
891     }
892 }
893 
insertGroupsIntoControlList(const CtrlList & sourceList)894 CtrlList RBGroupManager::insertGroupsIntoControlList( const CtrlList& sourceList )
895 {
896     ::std::sort( groupList.begin(), groupList.end(), SortGroupByTabPos() );
897     std::vector<OCX_Control*> destinationList;
898     if ( groupList.size() )
899     {
900         destinationList.reserve( sourceList.size() + numRadioButtons );
901 
902         GroupIterator groupEnd = groupList.end();
903         CtrlIteratorConst sourceEnd = sourceList.end();
904 
905         size_t prevGroupListSize = 0;
906 
907         CtrlIteratorConst containees = sourceList.begin();
908         GroupIterator groupIter=groupList.begin();
909         while ( containees != sourceEnd ||
910                 groupIter != groupEnd )
911         {
912             bool addGroupSeperator = false;
913             if ( containees != sourceEnd )
914             {
915                 if ( groupIter != groupEnd )
916                 {
917                     sal_Int16 groupTabPos = (*groupIter)->tabPos();
918                     if ( (*containees)->mnTabPos >= groupTabPos )
919                     {
920                        if ( !(destinationList.size() >=  prevGroupListSize ))
921                         {
922                             addGroupSeperator = true;
923                         }
924                         copyList( (*groupIter)->controls(), destinationList, addGroupSeperator );
925                         ++groupIter;
926 
927                         prevGroupListSize = destinationList.size();
928                     }
929                 }
930                 destinationList.push_back(*containees);
931                 ++containees;
932             }
933             else
934             {
935                if ( groupIter != groupEnd )
936                {
937                     if ( !(destinationList.size() >  prevGroupListSize ))
938                     {
939                         addGroupSeperator = true;
940                     }
941                     copyList( (*groupIter)->controls(), destinationList, addGroupSeperator );
942                     ++groupIter;
943                     prevGroupListSize = destinationList.size();
944                 }
945             }
946         }
947     }
948     else
949     {
950         destinationList = sourceList;
951     }
952     return destinationList;
953 
954 }
955 
956 
addSeperator(std::vector<OCX_Control * > & dest)957 void RBGroupManager::addSeperator( std::vector< OCX_Control* >& dest )
958 {
959     OCX_Control* seperator = new OCX_CommandButton;
960     seperator->SetInDialog(true);
961     seperator->sName = C2S("GroupSeperator");
962     dest.push_back( seperator );
963 }
964 
copyList(std::vector<OCX_Control * > & src,std::vector<OCX_Control * > & dest,bool addGroupSeperator)965 void RBGroupManager::copyList( std::vector< OCX_Control* >& src,
966     std::vector< OCX_Control* >& dest,
967     bool addGroupSeperator )
968 {
969     if ( addGroupSeperator )
970     {
971         addSeperator( dest );
972     }
973 
974     for ( CtrlIterator rbIter = src.begin(); rbIter != src.end(); ++rbIter )
975     {
976         dest.push_back( *rbIter );
977     }
978 }
979 
980 class OCX_UserFormLabel : public OCX_Label
981 {
982 public:
OCX_UserFormLabel(OCX_Control * pParent)983     OCX_UserFormLabel(OCX_Control* pParent ) : OCX_Label( pParent )
984     {
985         mnForeColor = 0x80000012L;
986         mnBackColor = 0x8000000FL;
987     }
988 };
989 
990 
991 sal_uInt16 OCX_Control::nStandardId(0x0200);
992 sal_uInt16 OCX_FontData::nStandardId(0x0200);
993 
994 sal_uInt32 OCX_Control::pColor[25] = {
995 0xC0C0C0, 0x008080, 0x000080, 0x808080, 0xC0C0C0, 0xFFFFFF, 0x000000,
996 0x000000, 0x000000, 0xFFFFFF, 0xC0C0C0, 0xC0C0C0, 0x808080, 0x000080,
997 0xFFFFFF, 0xC0C0C0, 0x808080, 0x808080, 0x000000, 0xC0C0C0, 0xFFFFFF,
998 0x000000, 0xC0C0C0, 0x000000, 0xFFFFC0 };
999 
FillSystemColors()1000 void OCX_Control::FillSystemColors()
1001 {
1002     // overwrite the predefined colors with available system colors
1003     const StyleSettings& rSett = Application::GetSettings().GetStyleSettings();
1004 
1005     pColor[ 0x00 ] = rSett.GetFaceColor().GetColor();
1006     pColor[ 0x01 ] = rSett.GetWorkspaceColor().GetColor();
1007     pColor[ 0x02 ] = rSett.GetActiveColor().GetColor();
1008     pColor[ 0x03 ] = rSett.GetDeactiveColor().GetColor();
1009     pColor[ 0x04 ] = rSett.GetMenuBarColor().GetColor();
1010     pColor[ 0x05 ] = rSett.GetWindowColor().GetColor();
1011     pColor[ 0x07 ] = rSett.GetMenuTextColor().GetColor();
1012     pColor[ 0x08 ] = rSett.GetWindowTextColor().GetColor();
1013     pColor[ 0x09 ] = rSett.GetActiveTextColor().GetColor();
1014     pColor[ 0x0A ] = rSett.GetActiveBorderColor().GetColor();
1015     pColor[ 0x0B ] = rSett.GetDeactiveBorderColor().GetColor();
1016     pColor[ 0x0C ] = rSett.GetWorkspaceColor().GetColor();
1017     pColor[ 0x0D ] = rSett.GetHighlightColor().GetColor();
1018     pColor[ 0x0E ] = rSett.GetHighlightTextColor().GetColor();
1019     pColor[ 0x0F ] = rSett.GetFaceColor().GetColor();
1020     pColor[ 0x10 ] = rSett.GetShadowColor().GetColor();
1021     pColor[ 0x12 ] = rSett.GetButtonTextColor().GetColor();
1022     pColor[ 0x13 ] = rSett.GetDeactiveTextColor().GetColor();
1023     pColor[ 0x14 ] = rSett.GetHighlightColor().GetColor();
1024     pColor[ 0x15 ] = rSett.GetDarkShadowColor().GetColor();
1025     pColor[ 0x16 ] = rSett.GetShadowColor().GetColor();
1026     pColor[ 0x17 ] = rSett.GetHelpTextColor().GetColor();
1027     pColor[ 0x18 ] = rSett.GetHelpColor().GetColor();
1028 }
1029 
ImportColor(sal_uInt32 nColor) const1030 sal_uInt32 OCX_Control::ImportColor(sal_uInt32 nColor) const
1031 {
1032 	sal_uInt8 nUpper = (sal_uInt8)( nColor >> 24 );
1033 	if (nUpper & 0x80) //Palette color, should be switch on bottom 24 bits
1034 	{
1035 		/*Might as well use my systems ones in the absence of any other ideas*/
1036 		nColor = nColor&0x00FFFFFF;
1037 		DBG_ASSERT (nColor <= 24,"Unknown Palette Index");
1038 		if (nColor > 24)
1039 			nColor = 0xFFFFFF;
1040 		else
1041 			nColor = pColor[nColor];
1042 	}
1043 	else
1044 	{
1045 		//Stored in bgr! rather than rgb
1046 		nColor = SwapColor(nColor);
1047 	}
1048 	return nColor;
1049 }
1050 
ImportAlign(sal_uInt8 _nJustification) const1051 sal_Int16 OCX_FontData::ImportAlign(sal_uInt8 _nJustification) const
1052 {
1053 	sal_Int16 nRet;
1054 	switch (_nJustification)
1055 	{
1056 	default:
1057 	case 1:
1058 		nRet = 0;
1059 		break;
1060 	case 2:
1061 		nRet = 2;
1062 		break;
1063 	case 3:
1064 		nRet = 1;
1065 		break;
1066 	}
1067 	return nRet;
1068 }
1069 
ExportAlign(sal_Int16 nAlign) const1070 sal_uInt8 OCX_FontData::ExportAlign(sal_Int16 nAlign) const
1071 {
1072 	sal_Int8 nRet;
1073 	switch (nAlign)
1074 	{
1075 	default:
1076 	case 0:
1077 		nRet = 1;
1078 		break;
1079 	case 2:
1080 		nRet = 2;
1081 		break;
1082 	case 1:
1083 		nRet = 3;
1084 		break;
1085 	}
1086 	return nRet;
1087 }
1088 
SwapColor(sal_uInt32 nColor) const1089 sal_uInt32 OCX_Control::SwapColor(sal_uInt32 nColor) const
1090 {
1091 	sal_uInt8
1092 		r(static_cast<sal_uInt8>(nColor&0xFF)),
1093 		g(static_cast<sal_uInt8>(((nColor)>>8)&0xFF)),
1094 		b(static_cast<sal_uInt8>((nColor>>16)&0xFF));
1095 	nColor = (r<<16) + (g<<8) + b;
1096 	return nColor;
1097 }
1098 
ExportColor(sal_uInt32 nColor) const1099 sal_uInt32 OCX_Control::ExportColor(sal_uInt32 nColor) const
1100 {
1101 	sal_uInt8 nUpper = (sal_uInt8)( nColor >> 24 );
1102 	if (nUpper & 0x80) //Palette color, should be switch on bottom 24 bits
1103 	{
1104 		/*Might as well use my systems ones in the absence of any other ideas*/
1105 		nColor = nColor&0x00FFFFFF;
1106 		DBG_ASSERT (nColor <= 24,"Unknown Palette Index");
1107 		if (nColor > 24)
1108 			nColor = 0xFFFFFF;
1109 		else
1110 			nColor = pColor[nColor];
1111 	}
1112 
1113 	//Stored in bgr! rather than rgb
1114 	nColor = SwapColor(nColor);
1115 	return nColor;
1116 }
1117 
Import(const uno::Reference<lang::XMultiServiceFactory> & rServiceFactory,uno::Reference<form::XFormComponent> & rFComp,awt::Size & rSz)1118 sal_Bool OCX_Control::Import(
1119 	const uno::Reference< lang::XMultiServiceFactory > &rServiceFactory,
1120 	uno::Reference< form::XFormComponent >  &rFComp, awt::Size &rSz)
1121 {
1122 
1123     if(msFormType.getLength() == 0)
1124         return sal_False;
1125 
1126 	rSz.Width = nWidth;
1127 	rSz.Height = nHeight;
1128 
1129 	uno::Reference<uno::XInterface> xCreate =
1130 		rServiceFactory->createInstance(msFormType);
1131 	if (!xCreate.is())
1132 		return sal_False;
1133 
1134 	rFComp = uno::Reference<form::XFormComponent>(xCreate,uno::UNO_QUERY);
1135 	if (!rFComp.is())
1136 		return sal_False;
1137     uno::Reference<beans::XPropertySet> xPropSet(xCreate,uno::UNO_QUERY);
1138     if (!xPropSet.is())
1139         return sal_False;
1140     return Import(xPropSet);
1141 }
1142 
Import(uno::Reference<container::XNameContainer> & rDialog)1143 sal_Bool OCX_Control::Import(uno::Reference<container::XNameContainer> &rDialog
1144     )
1145 {
1146     uno::Reference<lang::XMultiServiceFactory>
1147         xFactory(rDialog, uno::UNO_QUERY);
1148 
1149 	uno::Reference<uno::XInterface> xCreate =
1150         xFactory->createInstance(msDialogType);
1151 	if (!xCreate.is())
1152 		return sal_False;
1153 
1154 	uno::Reference<awt::XControlModel> xModel(xCreate, uno::UNO_QUERY);
1155 	if (!xModel.is())
1156 		return sal_False;
1157 
1158     /*  #147900# sometimes insertion of a control fails due to existing name,
1159         do not break entire form import then... */
1160     try
1161     {
1162         rDialog->insertByName(sName, uno::makeAny(xModel));
1163     }
1164     catch( uno::Exception& )
1165     {
1166         DBG_ERRORFILE(
1167             ByteString( "OCX_Control::Import - cannot insert control \"" ).
1168             Append( ByteString( sName, RTL_TEXTENCODING_UTF8 ) ).
1169             Append( '"' ).GetBuffer() );
1170     }
1171 
1172     uno::Reference<beans::XPropertySet> xPropSet(xCreate, uno::UNO_QUERY);
1173     if (!xPropSet.is())
1174         return sal_False;
1175 
1176     if (!Import(xPropSet))
1177         return sal_False;
1178 
1179     uno::Any aTmp;
1180     aTmp <<= sal_Int32((mnLeft * 2) / 100);
1181     xPropSet->setPropertyValue(WW8_ASCII2STR("PositionX"), aTmp);
1182     aTmp <<= sal_Int32((mnTop * 2) / 100);
1183     xPropSet->setPropertyValue(WW8_ASCII2STR("PositionY"), aTmp);
1184     aTmp <<= sal_Int32((nWidth * 2) / 100);
1185     xPropSet->setPropertyValue(WW8_ASCII2STR("Width"), aTmp);
1186     aTmp <<= sal_Int32((nHeight * 2) / 100);
1187     xPropSet->setPropertyValue(WW8_ASCII2STR("Height"), aTmp);
1188     if ( msToolTip.Len() > 0 )
1189 		xPropSet->setPropertyValue(WW8_ASCII2STR("HelpText"), uno::Any(OUString(msToolTip)));
1190 
1191     if ( mnStep )
1192     {
1193         aTmp <<= mnStep;
1194         xPropSet->setPropertyValue(WW8_ASCII2STR("Step"), aTmp);
1195     }
1196 
1197     try
1198     {
1199         xPropSet->setPropertyValue(WW8_ASCII2STR("EnableVisible"), uno::makeAny( mbVisible ) );
1200     }
1201     catch( uno::Exception& )
1202     {
1203     }
1204     return sal_True;
1205 }
1206 
ImportBorder(sal_uInt16 nSpecialEffect,sal_uInt16 nBorderStyle) const1207 sal_Int16 OCX_Control::ImportBorder(sal_uInt16 nSpecialEffect,
1208 	sal_uInt16 nBorderStyle) const
1209 {
1210 	if ((nSpecialEffect == 0) && (nBorderStyle == 0))
1211 		return 0;	//No Border
1212 	else if ((nSpecialEffect == 0) && (nBorderStyle == 1))
1213 		return 2;	//Flat Border
1214 	return 1;	//3D Border
1215 }
1216 
ExportBorder(sal_uInt16 nBorder,sal_uInt8 & rBorderStyle) const1217 sal_uInt8 OCX_Control::ExportBorder(sal_uInt16 nBorder,sal_uInt8 &rBorderStyle)
1218 	const
1219 {
1220 	sal_uInt8 nRet;
1221 	switch(nBorder)
1222 	{
1223 		case 0:
1224 			nRet = rBorderStyle = 0;
1225 			break;
1226 		default:
1227 		case 1:
1228 			nRet = 2;
1229             rBorderStyle = 0;
1230 			break;
1231 		case 2:
1232             nRet = 0;
1233 			rBorderStyle = 1;
1234 			break;
1235 	}
1236 	return nRet;
1237 }
1238 
ImportSpecEffect(sal_uInt8 nSpecialEffect) const1239 sal_Int16 OCX_Control::ImportSpecEffect( sal_uInt8 nSpecialEffect ) const
1240 {
1241     return (nSpecialEffect == 0) ? 2 : 1;
1242 }
1243 
ExportSpecEffect(sal_Int16 nApiEffect) const1244 sal_uInt8 OCX_Control::ExportSpecEffect( sal_Int16 nApiEffect ) const
1245 {
1246     return (nApiEffect == 2) ? 0 : 2;
1247 }
1248 
ReadFontData(SvStorageStream * pS)1249 sal_Bool OCX_Control::ReadFontData(SvStorageStream *pS)
1250 {
1251     return aFontData.Read(pS);
1252 }
1253 
1254 
1255 const uno::Reference< drawing::XDrawPage >&
GetDrawPage()1256 	SvxMSConvertOCXControls::GetDrawPage()
1257 {
1258 	if( !xDrawPage.is() && pDocSh )
1259 	{
1260 		uno::Reference< drawing::XDrawPageSupplier > xTxtDoc(pDocSh->GetModel(),
1261 			uno::UNO_QUERY);
1262 		DBG_ASSERT(xTxtDoc.is(),"XDrawPageSupplier nicht vom XModel erhalten");
1263 		xDrawPage = xTxtDoc->getDrawPage();
1264 		DBG_ASSERT( xDrawPage.is(), "XDrawPage nicht erhalten" );
1265 	}
1266 
1267 	return xDrawPage;
1268 }
1269 
1270 
1271 const uno::Reference< lang::XMultiServiceFactory >&
GetServiceFactory()1272 	SvxMSConvertOCXControls::GetServiceFactory()
1273 {
1274 	if( !xServiceFactory.is() && pDocSh )
1275 	{
1276 		xServiceFactory = uno::Reference< lang::XMultiServiceFactory >
1277 			(pDocSh->GetBaseModel(), uno::UNO_QUERY);
1278 		DBG_ASSERT( xServiceFactory.is(),
1279 				"XMultiServiceFactory nicht vom Model erhalten" );
1280 	}
1281 
1282 	return xServiceFactory;
1283 }
1284 
GetShapes()1285 const uno::Reference< drawing::XShapes >& SvxMSConvertOCXControls::GetShapes()
1286 {
1287 	if( !xShapes.is() )
1288 	{
1289 		GetDrawPage();
1290 		if( xDrawPage.is() )
1291 		{
1292 
1293 			xShapes = uno::Reference< drawing::XShapes >(xDrawPage,
1294 				uno::UNO_QUERY);
1295 			DBG_ASSERT( xShapes.is(), "XShapes nicht vom XDrawPage erhalten" );
1296 		}
1297 	}
1298 	return xShapes;
1299 }
1300 
1301 const uno::Reference< container::XIndexContainer >&
GetFormComps()1302 	SvxMSConvertOCXControls::GetFormComps()
1303 {
1304 	if( !xFormComps.is() )
1305 	{
1306 		GetDrawPage();
1307 		if( xDrawPage.is() )
1308 		{
1309 			uno::Reference< form::XFormsSupplier > xFormsSupplier( xDrawPage,
1310 				uno::UNO_QUERY );
1311 			DBG_ASSERT( xFormsSupplier.is(),
1312 					"XFormsSupplier nicht vom XDrawPage erhalten" );
1313 
1314 			uno::Reference< container::XNameContainer >  xNameCont =
1315 				xFormsSupplier->getForms();
1316 
1317 			// Das Formular bekommt einen Namen wie "WW-Standard[n]" und
1318 			// wird in jedem Fall neu angelegt.
1319 			UniString sName( sWW8_form, RTL_TEXTENCODING_MS_1252 );
1320 			sal_uInt16 n = 0;
1321 
1322 			while( xNameCont->hasByName( sName ) )
1323 			{
1324 				sName.AssignAscii( sWW8_form );
1325 				sName += String::CreateFromInt32( ++n );
1326 			}
1327 
1328 			const uno::Reference< lang::XMultiServiceFactory > &rServiceFactory
1329 				= GetServiceFactory();
1330 			if( !rServiceFactory.is() )
1331 				return xFormComps;
1332 
1333 			uno::Reference< uno::XInterface >  xCreate =
1334 				rServiceFactory->createInstance(WW8_ASCII2STR(
1335 					"com.sun.star.form.component.Form"));
1336 			if( xCreate.is() )
1337 			{
1338 				uno::Reference< beans::XPropertySet > xFormPropSet( xCreate,
1339 					uno::UNO_QUERY );
1340 
1341 				uno::Any aTmp(&sName,getCppuType((OUString *)0));
1342 				xFormPropSet->setPropertyValue( WW8_ASCII2STR("Name"), aTmp );
1343 
1344 				uno::Reference< form::XForm > xForm( xCreate, uno::UNO_QUERY );
1345 				DBG_ASSERT(xForm.is(), "keine Form?");
1346 
1347 				uno::Reference< container::XIndexContainer > xForms( xNameCont,
1348 					uno::UNO_QUERY );
1349 				DBG_ASSERT( xForms.is(), "XForms nicht erhalten" );
1350 
1351 				aTmp.setValue( &xForm,
1352 					::getCppuType((uno::Reference < form::XForm >*)0));
1353 				xForms->insertByIndex( xForms->getCount(), aTmp );
1354 
1355 				xFormComps = uno::Reference< container::XIndexContainer >
1356 					(xCreate, uno::UNO_QUERY);
1357 			}
1358 		}
1359 	}
1360 
1361 	return xFormComps;
1362 }
1363 
Import(com::sun::star::uno::Reference<com::sun::star::beans::XPropertySet> & rPropSet)1364 sal_Bool OCX_CommandButton::Import( com::sun::star::uno::Reference<
1365     com::sun::star::beans::XPropertySet> &rPropSet)
1366 {
1367 	uno::Any aTmp(&sName,getCppuType((OUString *)0));
1368 	rPropSet->setPropertyValue( WW8_ASCII2STR("Name"), aTmp );
1369 
1370 	aTmp <<= ImportColor(mnForeColor);
1371 	rPropSet->setPropertyValue( WW8_ASCII2STR("TextColor"), aTmp);
1372 
1373 	//fBackStyle is a flag. 1 means with background color. 0 means default.
1374 	if( fBackStyle )
1375 		aTmp <<= ImportColor(mnBackColor);
1376 	else
1377 		aTmp = uno::Any();
1378 	rPropSet->setPropertyValue( WW8_ASCII2STR("BackgroundColor"), aTmp);
1379 
1380 	sal_Bool bTemp;
1381 	if ((!(fEnabled)) || (fLocked))
1382 		bTemp = sal_False;
1383 	else
1384 		bTemp = sal_True;
1385 	aTmp = bool2any(bTemp);
1386 
1387 	rPropSet->setPropertyValue( WW8_ASCII2STR("Enabled"), aTmp);
1388 
1389     bTemp = fWordWrap != 0;
1390     aTmp = bool2any(bTemp);
1391     rPropSet->setPropertyValue( WW8_ASCII2STR("MultiLine"), aTmp);
1392 
1393 	if (pCaption)
1394 	{
1395         aTmp <<= lclCreateOUString( pCaption, nCaptionLen );
1396 		rPropSet->setPropertyValue( WW8_ASCII2STR("Label"), aTmp);
1397 	}
1398 
1399     aTmp = bool2any( mbTakeFocus );
1400     rPropSet->setPropertyValue( WW8_ASCII2STR( "FocusOnClick" ), aTmp );
1401 
1402 	aFontData.Import(rPropSet);
1403 	return sal_True;
1404 }
1405 
Export(SvStorageRef &,const uno::Reference<beans::XPropertySet> &,const awt::Size &)1406 sal_Bool OCX_GroupBox::Export(SvStorageRef& /* rObj */,
1407 	const uno::Reference< beans::XPropertySet >& /* rPropSet */,
1408 	const awt::Size& /* rSize */ )
1409 {
1410 	sal_Bool bRet=sal_True;
1411 	return bRet;
1412 }
1413 
WriteContents(SvStorageStreamRef &,const uno::Reference<beans::XPropertySet> &,const awt::Size &)1414 sal_Bool OCX_GroupBox::WriteContents(SvStorageStreamRef& /* rObj */,
1415 	const uno::Reference< beans::XPropertySet >& /* rPropSet */,
1416 	const awt::Size& /* rSize */)
1417 {
1418 	sal_Bool bRet=sal_True;
1419 	return bRet;
1420 }
1421 
WriteContents(SvStorageStreamRef & rContents,const uno::Reference<beans::XPropertySet> & rPropSet,const awt::Size & rSize)1422 sal_Bool OCX_CommandButton::WriteContents(SvStorageStreamRef& rContents,
1423 	const uno::Reference< beans::XPropertySet >& rPropSet,
1424 	const awt::Size& rSize )
1425 {
1426 	sal_Bool bRet=sal_True;
1427 
1428     sal_uInt32 nOldPos = rContents->Tell();
1429 	rContents->SeekRel(8);
1430 
1431 	uno::Any aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("TextColor"));
1432     if (aTmp.hasValue())
1433 	    aTmp >>= mnForeColor;
1434 	*rContents << ExportColor(mnForeColor);
1435 
1436 	//fBackStyle is a flag. 1 means with background color. 0 means default.
1437 	aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("BackgroundColor"));
1438     if (aTmp.hasValue())
1439 	    aTmp >>= mnBackColor;
1440 	else
1441 		fBackStyle = 0;
1442 	*rContents << ExportColor(mnBackColor);
1443 
1444 	aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("Enabled"));
1445 	fEnabled = any2bool(aTmp);
1446 	sal_uInt8 nTemp=0;//fEnabled;
1447 	if (fEnabled)
1448 		nTemp |= 0x02;//has enabled prop
1449     if (fBackStyle)
1450         nTemp |= 0x08;//has background color
1451 	*rContents << nTemp;
1452 	*rContents << sal_uInt8(0x00);
1453 
1454     nTemp = 0;
1455     aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("MultiLine"));
1456     fWordWrap = any2bool(aTmp);
1457     if (fWordWrap)
1458         nTemp |= 0x80;
1459     *rContents << nTemp;
1460 	*rContents << sal_uInt8(0x00);
1461 
1462     SvxOcxString aCaption( rPropSet->getPropertyValue(WW8_ASCII2STR("Label")) );
1463     aCaption.WriteLenField( *rContents );
1464     aCaption.WriteCharArray( *rContents );
1465 
1466 	WriteAlign(rContents,4);
1467 
1468 	*rContents << rSize.Width;
1469 	*rContents << rSize.Height;
1470 
1471     // "take focus on click" is directly in content flags, not in option field...
1472     mbTakeFocus = any2bool( rPropSet->getPropertyValue( WW8_ASCII2STR( "FocusOnClick" ) ) );
1473 
1474     nFixedAreaLen = static_cast<sal_uInt16>(rContents->Tell()-nOldPos-4);
1475 	aFontData.nDefaultAlign = 1;
1476 	bRet = aFontData.Export(rContents,rPropSet);
1477 
1478     rContents->Seek(nOldPos);
1479 	*rContents << nStandardId;
1480 	*rContents << nFixedAreaLen;
1481 
1482 	sal_uInt8 nTmp = 0x27;
1483     if (aCaption.HasData())
1484 		nTmp |= 0x08;
1485 	*rContents << nTmp;
1486     nTmp = 0x00;
1487     if( !mbTakeFocus )  // flag is set, if option is off
1488         nTmp |= 0x02;
1489     *rContents << nTmp;
1490 	*rContents << sal_uInt8(0x00);
1491 	*rContents << sal_uInt8(0x00);
1492 
1493 	DBG_ASSERT((rContents.Is() && (SVSTREAM_OK==rContents->GetError())),"damn");
1494 	return bRet;
1495 }
1496 
1497 
1498 
Export(SvStorageRef & rObj,const uno::Reference<beans::XPropertySet> & rPropSet,const awt::Size & rSize)1499 sal_Bool OCX_CommandButton::Export(SvStorageRef &rObj,
1500 	const uno::Reference< beans::XPropertySet > &rPropSet,
1501 	const awt::Size &rSize)
1502 {
1503 	static sal_uInt8 __READONLY_DATA aCompObj[] = {
1504 			0x01, 0x00, 0xFE, 0xFF, 0x03, 0x0A, 0x00, 0x00,
1505 			0xFF, 0xFF, 0xFF, 0xFF, 0x40, 0x32, 0x05, 0xD7,
1506 			0x69, 0xCE, 0xCD, 0x11, 0xA7, 0x77, 0x00, 0xDD,
1507 			0x01, 0x14, 0x3C, 0x57, 0x22, 0x00, 0x00, 0x00,
1508 			0x4D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66,
1509 			0x74, 0x20, 0x46, 0x6F, 0x72, 0x6d, 0x73, 0x20,
1510 			0x32, 0x2e, 0x30, 0x20, 0x43, 0x6F, 0x6D, 0x6D,
1511 			0x61, 0x6E, 0x64, 0x42, 0x75, 0x74, 0x74, 0x6F,
1512 			0x6E, 0x00, 0x10, 0x00, 0x00, 0x00, 0x45, 0x6D,
1513 			0x62, 0x65, 0x64, 0x64, 0x65, 0x64, 0x20, 0x4F,
1514 			0x62, 0x6A, 0x65, 0x63, 0x74, 0x00, 0x16, 0x00,
1515 			0x00, 0x00, 0x46, 0x6F, 0x72, 0x6D, 0x73, 0x2E,
1516 			0x43, 0x6F, 0x6D, 0x6D, 0x61, 0x6E, 0x64, 0x42,
1517 			0x75, 0x74, 0x74, 0x6F, 0x6E, 0x2E, 0x31, 0x00,
1518 			0xF4, 0x39, 0xB2, 0x71, 0x00, 0x00, 0x00, 0x00,
1519 			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
1520 		};
1521 
1522 	{
1523 	SvStorageStreamRef xStor( rObj->OpenSotStream( C2S("\1CompObj")));
1524 	xStor->Write(aCompObj,sizeof(aCompObj));
1525 	DBG_ASSERT((xStor.Is() && (SVSTREAM_OK == xStor->GetError())),"damn");
1526 	}
1527 
1528 	{
1529 	SvStorageStreamRef xStor3( rObj->OpenSotStream( C2S("\3ObjInfo")));
1530 	xStor3->Write(aObjInfo,sizeof(aObjInfo));
1531 	DBG_ASSERT((xStor3.Is() && (SVSTREAM_OK == xStor3->GetError())),"damn");
1532 	}
1533 
1534 	static sal_uInt8 __READONLY_DATA aOCXNAME[] = {
1535 		0x43, 0x00, 0x6F, 0x00, 0x6D, 0x00, 0x6D, 0x00,
1536 		0x61, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x42, 0x00,
1537 		0x75, 0x00, 0x74, 0x00, 0x74, 0x00, 0x6F, 0x00,
1538 		0x6E, 0x00, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00
1539 	};
1540 
1541 	{
1542 	SvStorageStreamRef xStor2( rObj->OpenSotStream( C2S("\3OCXNAME")));
1543 	xStor2->Write(aOCXNAME,sizeof(aOCXNAME));
1544 	DBG_ASSERT((xStor2.Is() && (SVSTREAM_OK == xStor2->GetError())),"damn");
1545 	}
1546 
1547 	SvStorageStreamRef xContents( rObj->OpenSotStream( C2S("contents")));
1548 
1549 	return WriteContents(xContents,rPropSet,rSize);
1550 }
1551 
WriteContents(SvStorageStreamRef & rContents,const uno::Reference<beans::XPropertySet> & rPropSet,const awt::Size & rSize)1552 sal_Bool OCX_ImageButton::WriteContents(SvStorageStreamRef &rContents,
1553 	const uno::Reference< beans::XPropertySet > &rPropSet,
1554 	const awt::Size &rSize)
1555 {
1556 	sal_Bool bRet=sal_True;
1557 
1558     sal_uInt32 nOldPos = rContents->Tell();
1559 	rContents->SeekRel(8);
1560 
1561 	uno::Any aTmp=rPropSet->getPropertyValue(WW8_ASCII2STR("BackgroundColor"));
1562     if (aTmp.hasValue())
1563 	    aTmp >>= mnBackColor;
1564 	*rContents << ExportColor(mnBackColor);
1565 
1566 	aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("Enabled"));
1567 	fEnabled = any2bool(aTmp);
1568 	sal_uInt8 nTemp=0;//fEnabled;
1569 	if (fEnabled)
1570 		nTemp |= 0x02;
1571 	*rContents << nTemp;
1572 	*rContents << sal_uInt8(0x00);
1573 	*rContents << sal_uInt8(0x00);
1574 	*rContents << sal_uInt8(0x00);
1575 
1576 	WriteAlign(rContents,4);
1577 
1578 	*rContents << rSize.Width;
1579 	*rContents << rSize.Height;
1580 
1581     nFixedAreaLen = static_cast<sal_uInt16>(rContents->Tell()-nOldPos-4);
1582 
1583 	bRet = aFontData.Export(rContents,rPropSet);
1584 
1585     rContents->Seek(nOldPos);
1586 	*rContents << nStandardId;
1587 	*rContents << nFixedAreaLen;
1588 
1589 	sal_uInt8 nTmp = 0x26;
1590 	*rContents << nTmp;
1591 	*rContents << sal_uInt8(0x00);
1592 	*rContents << sal_uInt8(0x00);
1593 	*rContents << sal_uInt8(0x00);
1594 
1595 	DBG_ASSERT((rContents.Is() && (SVSTREAM_OK==rContents->GetError())),"damn");
1596 	return bRet;
1597 }
1598 
1599 
1600 
Export(SvStorageRef & rObj,const uno::Reference<beans::XPropertySet> & rPropSet,const awt::Size & rSize)1601 sal_Bool OCX_ImageButton::Export(SvStorageRef &rObj,
1602 	const uno::Reference< beans::XPropertySet > &rPropSet,
1603 	const awt::Size &rSize)
1604 {
1605 	static sal_uInt8 __READONLY_DATA aCompObj[] = {
1606 			0x01, 0x00, 0xFE, 0xFF, 0x03, 0x0A, 0x00, 0x00,
1607 			0xFF, 0xFF, 0xFF, 0xFF, 0x40, 0x32, 0x05, 0xD7,
1608 			0x69, 0xCE, 0xCD, 0x11, 0xA7, 0x77, 0x00, 0xDD,
1609 			0x01, 0x14, 0x3C, 0x57, 0x22, 0x00, 0x00, 0x00,
1610 			0x4D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66,
1611 			0x74, 0x20, 0x46, 0x6F, 0x72, 0x6d, 0x73, 0x20,
1612 			0x32, 0x2e, 0x30, 0x20, 0x43, 0x6F, 0x6D, 0x6D,
1613 			0x61, 0x6E, 0x64, 0x42, 0x75, 0x74, 0x74, 0x6F,
1614 			0x6E, 0x00, 0x10, 0x00, 0x00, 0x00, 0x45, 0x6D,
1615 			0x62, 0x65, 0x64, 0x64, 0x65, 0x64, 0x20, 0x4F,
1616 			0x62, 0x6A, 0x65, 0x63, 0x74, 0x00, 0x16, 0x00,
1617 			0x00, 0x00, 0x46, 0x6F, 0x72, 0x6D, 0x73, 0x2E,
1618 			0x43, 0x6F, 0x6D, 0x6D, 0x61, 0x6E, 0x64, 0x42,
1619 			0x75, 0x74, 0x74, 0x6F, 0x6E, 0x2E, 0x31, 0x00,
1620 			0xF4, 0x39, 0xB2, 0x71, 0x00, 0x00, 0x00, 0x00,
1621 			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
1622 		};
1623 
1624 	{
1625 	SvStorageStreamRef xStor( rObj->OpenSotStream( C2S("\1CompObj")));
1626 	xStor->Write(aCompObj,sizeof(aCompObj));
1627 	DBG_ASSERT((xStor.Is() && (SVSTREAM_OK == xStor->GetError())),"damn");
1628 	}
1629 
1630 	{
1631 	SvStorageStreamRef xStor3( rObj->OpenSotStream( C2S("\3ObjInfo")));
1632 	xStor3->Write(aObjInfo,sizeof(aObjInfo));
1633 	DBG_ASSERT((xStor3.Is() && (SVSTREAM_OK == xStor3->GetError())),"damn");
1634 	}
1635 
1636 	static sal_uInt8 __READONLY_DATA aOCXNAME[] = {
1637 		0x43, 0x00, 0x6F, 0x00, 0x6D, 0x00, 0x6D, 0x00,
1638 		0x61, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x42, 0x00,
1639 		0x75, 0x00, 0x74, 0x00, 0x74, 0x00, 0x6F, 0x00,
1640 		0x6E, 0x00, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00
1641 	};
1642 
1643 	{
1644 	SvStorageStreamRef xStor2( rObj->OpenSotStream( C2S("\3OCXNAME")));
1645 	xStor2->Write(aOCXNAME,sizeof(aOCXNAME));
1646 	DBG_ASSERT((xStor2.Is() && (SVSTREAM_OK == xStor2->GetError())),"damn");
1647 	}
1648 
1649 	SvStorageStreamRef xContents( rObj->OpenSotStream( C2S("contents")));
1650 	return WriteContents(xContents,rPropSet,rSize);
1651 }
1652 
1653 
Import(com::sun::star::uno::Reference<com::sun::star::beans::XPropertySet> & rPropSet)1654 sal_Bool OCX_OptionButton::Import(com::sun::star::uno::Reference<
1655         com::sun::star::beans::XPropertySet> &rPropSet)
1656 {
1657 	uno::Any aTmp(&sName,getCppuType((OUString *)0));
1658 	rPropSet->setPropertyValue( WW8_ASCII2STR("Name"), aTmp );
1659 
1660     // background color: fBackStyle==0 -> transparent
1661     if( fBackStyle )
1662         aTmp <<= ImportColor(mnBackColor);
1663     else
1664         aTmp = uno::Any();
1665     rPropSet->setPropertyValue( WW8_ASCII2STR("BackgroundColor"), aTmp);
1666 
1667 	sal_Bool bTemp;
1668 	if ((!(fEnabled)) || (fLocked))
1669 		bTemp = sal_False;
1670 	else
1671 		bTemp = sal_True;
1672 	aTmp = bool2any(bTemp);
1673 	rPropSet->setPropertyValue( WW8_ASCII2STR("Enabled"), aTmp);
1674 
1675     bTemp = fWordWrap != 0;
1676     aTmp = bool2any(bTemp);
1677     rPropSet->setPropertyValue( WW8_ASCII2STR("MultiLine"), aTmp);
1678 
1679 	aTmp <<= ImportColor(mnForeColor);
1680 	rPropSet->setPropertyValue( WW8_ASCII2STR("TextColor"), aTmp);
1681 
1682     aTmp <<= ImportSpecEffect( nSpecialEffect );
1683     rPropSet->setPropertyValue( WW8_ASCII2STR("VisualEffect"), aTmp);
1684 
1685 	if (pValue && !bSetInDialog)
1686 	{
1687 		sal_Int16 nTmp = pValue[0]-0x30;
1688 		aTmp <<= nTmp;
1689 		rPropSet->setPropertyValue( WW8_ASCII2STR("DefaultState"), aTmp);
1690 	}
1691 
1692 	if (pCaption)
1693 	{
1694         aTmp <<= lclCreateOUString( pCaption, nCaptionLen );
1695 		rPropSet->setPropertyValue( WW8_ASCII2STR("Label"), aTmp);
1696 	}
1697 
1698     // #i40279# always centered vertically
1699     aTmp <<= ::com::sun::star::style::VerticalAlignment_MIDDLE;
1700     rPropSet->setPropertyValue( WW8_ASCII2STR("VerticalAlign"), aTmp );
1701 
1702 	aFontData.Import(rPropSet);
1703 	return sal_True;
1704 }
1705 
WriteContents(SvStorageStreamRef & rContents,const uno::Reference<beans::XPropertySet> & rPropSet,const awt::Size & rSize)1706 sal_Bool OCX_OptionButton::WriteContents(SvStorageStreamRef &rContents,
1707 	const uno::Reference< beans::XPropertySet > &rPropSet,
1708 	const awt::Size &rSize)
1709 {
1710 	sal_Bool bRet=sal_True;
1711 
1712     sal_uInt32 nOldPos = rContents->Tell();
1713 	rContents->SeekRel(12);
1714 
1715 	pBlockFlags[0] = 0;
1716 	pBlockFlags[1] = 0x01;
1717 	pBlockFlags[2] = 0;
1718 	pBlockFlags[3] = 0x80;
1719 	pBlockFlags[4] = 0;
1720 	pBlockFlags[5] = 0;
1721 	pBlockFlags[6] = 0;
1722 	pBlockFlags[7] = 0;
1723 
1724 	uno::Any aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("Enabled"));
1725 	fEnabled = any2bool(aTmp);
1726 
1727     aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("BackgroundColor"));
1728     if (aTmp.hasValue())
1729         aTmp >>= mnBackColor;
1730     else
1731         fBackStyle = 0;
1732 
1733 	sal_uInt8 nTemp=0;//=fEnabled;
1734 	if (fEnabled)
1735 		nTemp |= 0x02;
1736     if (fBackStyle)
1737         nTemp |= 0x08;
1738 	*rContents << nTemp;
1739 	pBlockFlags[0] |= 0x01;
1740 	*rContents << sal_uInt8(0x00);
1741     nTemp = 0;
1742     aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("MultiLine"));
1743     fWordWrap = any2bool(aTmp);
1744     if (fWordWrap)
1745         nTemp |= 0x80;
1746     *rContents << nTemp;
1747     *rContents << sal_uInt8(0x00);
1748 
1749     *rContents << ExportColor(mnBackColor);
1750     pBlockFlags[0] |= 0x02;
1751 
1752 	aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("TextColor"));
1753     if (aTmp.hasValue())
1754 	    aTmp >>= mnForeColor;
1755 	*rContents << ExportColor(mnForeColor);
1756 	pBlockFlags[0] |= 0x04;
1757 
1758 	nStyle = 5;
1759 	*rContents << nStyle;
1760 	pBlockFlags[0] |= 0x40;
1761 
1762 	WriteAlign(rContents,4);
1763     nValueLen = 1|SVX_MSOCX_COMPRESSED;
1764 	aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("DefaultState"));
1765 	sal_Int16 nDefault = sal_Int16();
1766 	aTmp >>= nDefault;
1767 	*rContents << nValueLen;
1768 	pBlockFlags[2] |= 0x40;
1769 
1770 
1771     SvxOcxString aCaption( rPropSet->getPropertyValue(WW8_ASCII2STR("Label")) );
1772     if (aCaption.HasData())
1773 		pBlockFlags[2] |= 0x80;
1774     aCaption.WriteLenField( *rContents );
1775 
1776     aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("VisualEffect"));
1777     if (aTmp.hasValue())
1778     {
1779         sal_Int16 nApiSpecEffect = sal_Int16();
1780         aTmp >>= nApiSpecEffect;
1781         nSpecialEffect = ExportSpecEffect( nApiSpecEffect );
1782     }
1783     *rContents << nSpecialEffect;
1784     pBlockFlags[3] |= 0x04;
1785 
1786 	WriteAlign(rContents,4);
1787 	*rContents << rSize.Width;
1788 	*rContents << rSize.Height;
1789 
1790 	nDefault += 0x30;
1791 	*rContents << sal_uInt8(nDefault);
1792 	*rContents << sal_uInt8(0x00);
1793 
1794     aCaption.WriteCharArray( *rContents );
1795 
1796 	WriteAlign(rContents,4);
1797     nFixedAreaLen = static_cast<sal_uInt16>(rContents->Tell()-nOldPos-4);
1798 	bRet = aFontData.Export(rContents,rPropSet);
1799 
1800     rContents->Seek(nOldPos);
1801 	*rContents << nStandardId;
1802 	*rContents << nFixedAreaLen;
1803 
1804 	*rContents << pBlockFlags[0];
1805 	*rContents << pBlockFlags[1];
1806 	*rContents << pBlockFlags[2];
1807 	*rContents << pBlockFlags[3];
1808 	*rContents << pBlockFlags[4];
1809 	*rContents << pBlockFlags[5];
1810 	*rContents << pBlockFlags[6];
1811 	*rContents << pBlockFlags[7];
1812 
1813 	DBG_ASSERT((rContents.Is() &&
1814 		(SVSTREAM_OK==rContents->GetError())),"damn");
1815 	return bRet;
1816 }
1817 
1818 
1819 
Export(SvStorageRef & rObj,const uno::Reference<beans::XPropertySet> & rPropSet,const awt::Size & rSize)1820 sal_Bool OCX_OptionButton::Export(SvStorageRef &rObj,
1821 	const uno::Reference< beans::XPropertySet > &rPropSet,
1822 	const awt::Size &rSize)
1823 {
1824 	static sal_uInt8 __READONLY_DATA aCompObj[] = {
1825 		0x01, 0x00, 0xFE, 0xFF, 0x03, 0x0A, 0x00, 0x00,
1826 		0xFF, 0xFF, 0xFF, 0xFF, 0x50, 0x1D, 0xD2, 0x8B,
1827 		0x42, 0xEC, 0xCE, 0x11, 0x9E, 0x0D, 0x00, 0xAA,
1828 		0x00, 0x60, 0x02, 0xF3, 0x21, 0x00, 0x00, 0x00,
1829 		0x4D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66,
1830 		0x74, 0x20, 0x46, 0x6F, 0x72, 0x6D, 0x73, 0x20,
1831 		0x32, 0x2E, 0x30, 0x20, 0x4F, 0x70, 0x74, 0x69,
1832 		0x6F, 0x6E, 0x42, 0x75, 0x74, 0x74, 0x6F, 0x6E,
1833 		0x00, 0x10, 0x00, 0x00, 0x00, 0x45, 0x6D, 0x62,
1834 		0x65, 0x64, 0x64, 0x65, 0x64, 0x20, 0x4F, 0x62,
1835 		0x6A, 0x65, 0x63, 0x74, 0x00, 0x15, 0x00, 0x00,
1836 		0x00, 0x46, 0x6F, 0x72, 0x6D, 0x73, 0x2E, 0x4F,
1837 		0x70, 0x74, 0x69, 0x6F, 0x6E, 0x42, 0x75, 0x74,
1838 		0x74, 0x6F, 0x6E, 0x2E, 0x31, 0x00, 0xF4, 0x39,
1839 		0xB2, 0x71, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1840 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00
1841 		};
1842 
1843 	{
1844 	SvStorageStreamRef xStor( rObj->OpenSotStream( C2S("\1CompObj")));
1845 	xStor->Write(aCompObj,sizeof(aCompObj));
1846 	DBG_ASSERT((xStor.Is() && (SVSTREAM_OK == xStor->GetError())),"damn");
1847 	}
1848 
1849 	{
1850 	SvStorageStreamRef xStor3( rObj->OpenSotStream( C2S("\3ObjInfo")));
1851 	xStor3->Write(aObjInfo,sizeof(aObjInfo));
1852 	DBG_ASSERT((xStor3.Is() && (SVSTREAM_OK == xStor3->GetError())),"damn");
1853 	}
1854 
1855 	static sal_uInt8 __READONLY_DATA aOCXNAME[] = {
1856 			0x4F, 0x00, 0x70, 0x00, 0x74, 0x00, 0x69, 0x00,
1857 			0x6F, 0x00, 0x6E, 0x00, 0x42, 0x00, 0x75, 0x00,
1858 			0x74, 0x00, 0x74, 0x00, 0x6F, 0x00, 0x6E, 0x00,
1859 			0x31, 0x00, 0x00, 0x00, 0x00, 0x00
1860 			};
1861 
1862 	{
1863 	SvStorageStreamRef xStor2( rObj->OpenSotStream( C2S("\3OCXNAME")));
1864 	xStor2->Write(aOCXNAME,sizeof(aOCXNAME));
1865 	DBG_ASSERT((xStor2.Is() && (SVSTREAM_OK == xStor2->GetError())),"damn");
1866 	}
1867 
1868 	SvStorageStreamRef xContents( rObj->OpenSotStream( C2S("contents")));
1869 	return WriteContents(xContents, rPropSet, rSize);
1870 }
1871 
1872 
Import(com::sun::star::uno::Reference<com::sun::star::beans::XPropertySet> & rPropSet)1873 sal_Bool OCX_TextBox::Import(com::sun::star::uno::Reference<
1874     com::sun::star::beans::XPropertySet> &rPropSet)
1875 {
1876 	uno::Any aTmp(&sName,getCppuType((OUString *)0));
1877 	rPropSet->setPropertyValue( WW8_ASCII2STR("Name"), aTmp );
1878 
1879     aTmp = bool2any( fEnabled != 0 );
1880 	rPropSet->setPropertyValue( WW8_ASCII2STR("Enabled"), aTmp);
1881 
1882     aTmp = bool2any( fLocked != 0 );
1883 	rPropSet->setPropertyValue( WW8_ASCII2STR("ReadOnly"), aTmp);
1884 
1885     aTmp = bool2any( fHideSelection != 0 );
1886     rPropSet->setPropertyValue( WW8_ASCII2STR( "HideInactiveSelection" ), aTmp);
1887 
1888 	aTmp <<= ImportColor(mnForeColor);
1889 	rPropSet->setPropertyValue( WW8_ASCII2STR("TextColor"), aTmp);
1890 
1891 	aTmp <<= ImportColor(mnBackColor);
1892 	rPropSet->setPropertyValue( WW8_ASCII2STR("BackgroundColor"), aTmp);
1893 
1894     aTmp <<= ImportBorder(nSpecialEffect,nBorderStyle);
1895     rPropSet->setPropertyValue( WW8_ASCII2STR("Border"), aTmp);
1896 
1897     aTmp <<= ImportColor( nBorderColor );
1898     rPropSet->setPropertyValue( WW8_ASCII2STR("BorderColor"), aTmp);
1899 
1900     aTmp = bool2any( fMultiLine != 0 );
1901 	rPropSet->setPropertyValue( WW8_ASCII2STR("MultiLine"), aTmp);
1902 
1903 	sal_uInt16 nTmp = static_cast<sal_uInt16>(nMaxLength);
1904 	aTmp <<= nTmp;
1905 	rPropSet->setPropertyValue( WW8_ASCII2STR("MaxTextLen"), aTmp);
1906 
1907 
1908 	sal_Bool bTemp1,bTemp2;
1909 	uno::Any aBarsH,aBarsV;
1910 	switch(nScrollBars)
1911 	{
1912 		case 1:
1913 			bTemp1 = sal_True;
1914 			bTemp2 = sal_False;
1915 			break;
1916 		case 2:
1917 			bTemp1 = sal_False;
1918 			bTemp2 = sal_True;
1919 			break;
1920 		case 3:
1921 			bTemp1 = sal_True;
1922 			bTemp2 = sal_True;
1923 			break;
1924 		case 0:
1925 		default:
1926 			bTemp1 = sal_False;
1927 			bTemp2 = sal_False;
1928 			break;
1929 	}
1930 
1931 	aBarsH = bool2any(bTemp1);
1932 	aBarsV = bool2any(bTemp2);
1933 	rPropSet->setPropertyValue( WW8_ASCII2STR("HScroll"), aBarsH);
1934 	rPropSet->setPropertyValue( WW8_ASCII2STR("VScroll"), aBarsV);
1935 
1936 	nTmp = nPasswordChar;
1937 	aTmp <<= nTmp;
1938 	rPropSet->setPropertyValue( WW8_ASCII2STR("EchoChar"), aTmp);
1939 
1940 	if (pValue)
1941 	{
1942         aTmp <<= lclCreateOUString( pValue, nValueLen );
1943         // DefaultText seems to no longer be in UnoEditControlModel
1944         if ( bSetInDialog )
1945         {
1946 		    rPropSet->setPropertyValue( WW8_ASCII2STR("Text"), aTmp);
1947         }
1948         else
1949         {
1950 		    rPropSet->setPropertyValue( WW8_ASCII2STR("DefaultText"), aTmp);
1951         }
1952 	}
1953 
1954 	aFontData.Import(rPropSet);
1955 	return sal_True;
1956 }
1957 
WriteContents(SvStorageStreamRef & rContents,const uno::Reference<beans::XPropertySet> & rPropSet,const awt::Size & rSize)1958 sal_Bool OCX_TextBox::WriteContents(SvStorageStreamRef &rContents,
1959 	const uno::Reference< beans::XPropertySet > &rPropSet,
1960 	const awt::Size &rSize)
1961 {
1962 	sal_Bool bRet=sal_True;
1963     sal_uInt32 nOldPos = rContents->Tell();
1964 	rContents->SeekRel(12);
1965 
1966 	pBlockFlags[0] = 0;
1967 	pBlockFlags[1] = 0x01;
1968 	pBlockFlags[2] = 0x00;
1969 	pBlockFlags[3] = 0x80;
1970 	pBlockFlags[4] = 0;
1971 	pBlockFlags[5] = 0;
1972 	pBlockFlags[6] = 0;
1973 	pBlockFlags[7] = 0;
1974 
1975 
1976 	sal_uInt8 nTemp=0x19;
1977 	uno::Any aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("Enabled"));
1978 	fEnabled = any2bool(aTmp);
1979 	if (fEnabled)
1980 		nTemp |= 0x02;
1981 
1982 	aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("ReadOnly"));
1983 	fLocked = any2bool(aTmp);
1984 	if (fLocked)
1985 		nTemp |= 0x04;
1986 
1987 	*rContents << nTemp;
1988 	pBlockFlags[0] |= 0x01;
1989 	*rContents << sal_uInt8(0x48);
1990     *rContents << sal_uInt8(0x80);
1991 
1992     fMultiLine = any2bool(rPropSet->getPropertyValue(WW8_ASCII2STR("MultiLine")));
1993     fHideSelection = any2bool(rPropSet->getPropertyValue(WW8_ASCII2STR("HideInactiveSelection")));
1994     nTemp = 0x0C;
1995 	if (fMultiLine)
1996 		nTemp |= 0x80;
1997     if( fHideSelection )
1998         nTemp |= 0x20;
1999 	*rContents << nTemp;
2000 
2001 	aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("BackgroundColor"));
2002     if (aTmp.hasValue())
2003 	    aTmp >>= mnBackColor;
2004 	*rContents << ExportColor(mnBackColor);
2005 	pBlockFlags[0] |= 0x02;
2006 
2007 	aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("TextColor"));
2008     if (aTmp.hasValue())
2009 	    aTmp >>= mnForeColor;
2010 	*rContents << ExportColor(mnForeColor);
2011 	pBlockFlags[0] |= 0x04;
2012 
2013 	aTmp = rPropSet->getPropertyValue( WW8_ASCII2STR("MaxTextLen"));
2014 	aTmp >>= nMaxLength;
2015 	*rContents << nMaxLength;
2016 	pBlockFlags[0] |= 0x08;
2017 
2018 	aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("Border"));
2019 	sal_Int16 nBorder = sal_Int16();
2020 	aTmp >>= nBorder;
2021 	nSpecialEffect = ExportBorder(nBorder,nBorderStyle);
2022 	*rContents << nBorderStyle;
2023 	pBlockFlags[0] |= 0x10;
2024 
2025 	aTmp = rPropSet->getPropertyValue( WW8_ASCII2STR("HScroll"));
2026 	sal_Bool bTemp1 = any2bool(aTmp);
2027 	aTmp = rPropSet->getPropertyValue( WW8_ASCII2STR("VScroll"));
2028 	sal_Bool bTemp2 = any2bool(aTmp);
2029 	if (!bTemp1 && !bTemp2)
2030 		nScrollBars =0;
2031 	else if (bTemp1 && bTemp2)
2032 		nScrollBars = 3;
2033 	else if (!bTemp1 && bTemp2)
2034 		nScrollBars = 2;
2035 	else
2036 		nScrollBars = 1;
2037 	*rContents << nScrollBars;
2038 	pBlockFlags[0] |= 0x20;
2039 
2040 	aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("EchoChar"));
2041 	sal_uInt16 nTmp = sal_uInt16();
2042 	aTmp >>= nTmp;
2043 	nPasswordChar = static_cast<sal_uInt8>(nTmp);
2044 	*rContents << nPasswordChar;
2045 	pBlockFlags[1] |= 0x02;
2046 
2047     SvxOcxString aValue( rPropSet->getPropertyValue(WW8_ASCII2STR("DefaultText")) );
2048     aValue.WriteLenField( *rContents );
2049     if (aValue.HasData())
2050 		pBlockFlags[2] |= 0x40;
2051 
2052 	WriteAlign(rContents,4);
2053     aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("BorderColor"));
2054     if (aTmp.hasValue())
2055         aTmp >>= nBorderColor;
2056     *rContents << ExportColor(nBorderColor);
2057     pBlockFlags[3] |= 0x02;
2058 
2059 	*rContents << nSpecialEffect;
2060 	pBlockFlags[3] |= 0x04;
2061 
2062 	WriteAlign(rContents,4);
2063 	*rContents << rSize.Width;
2064 	*rContents << rSize.Height;
2065 
2066     aValue.WriteCharArray( *rContents );
2067 
2068 	WriteAlign(rContents,4);
2069 
2070     nFixedAreaLen = static_cast<sal_uInt16>(rContents->Tell()-nOldPos-4);
2071 
2072 	bRet = aFontData.Export(rContents,rPropSet);
2073 
2074     rContents->Seek(nOldPos);
2075 	*rContents << nStandardId;
2076 	*rContents << nFixedAreaLen;
2077 
2078 	*rContents << pBlockFlags[0];
2079 	*rContents << pBlockFlags[1];
2080 	*rContents << pBlockFlags[2];
2081 	*rContents << pBlockFlags[3];
2082 	*rContents << pBlockFlags[4];
2083 	*rContents << pBlockFlags[5];
2084 	*rContents << pBlockFlags[6];
2085 	*rContents << pBlockFlags[7];
2086 
2087 	DBG_ASSERT((rContents.Is() &&
2088 		(SVSTREAM_OK == rContents->GetError())),"damn");
2089 	return bRet;
2090 }
2091 
2092 
Export(SvStorageRef & rObj,const uno::Reference<beans::XPropertySet> & rPropSet,const awt::Size & rSize)2093 sal_Bool OCX_TextBox::Export(SvStorageRef &rObj,
2094 	const uno::Reference< beans::XPropertySet > &rPropSet,
2095 	const awt::Size &rSize)
2096 {
2097 	static sal_uInt8 __READONLY_DATA aCompObj[] = {
2098 		0x01, 0x00, 0xFE, 0xFF, 0x03, 0x0A, 0x00, 0x00,
2099 		0xFF, 0xFF, 0xFF, 0xFF, 0x10, 0x1D, 0xD2, 0x8B,
2100 		0x42, 0xEC, 0xCE, 0x11, 0x9E, 0x0D, 0x00, 0xAA,
2101 		0x00, 0x60, 0x02, 0xF3, 0x1C, 0x00, 0x00, 0x00,
2102 		0x4D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66,
2103 		0x74, 0x20, 0x46, 0x6F, 0x72, 0x6D, 0x73, 0x20,
2104 		0x32, 0x2E, 0x30, 0x20, 0x54, 0x65, 0x78, 0x74,
2105 		0x42, 0x6F, 0x78, 0x00, 0x10, 0x00, 0x00, 0x00,
2106 		0x45, 0x6D, 0x62, 0x65, 0x64, 0x64, 0x65, 0x64,
2107 		0x20, 0x4F, 0x62, 0x6A, 0x65, 0x63, 0x74, 0x00,
2108 		0x10, 0x00, 0x00, 0x00, 0x46, 0x6F, 0x72, 0x6D,
2109 		0x73, 0x2E, 0x54, 0x65, 0x78, 0x74, 0x42, 0x6F,
2110 		0x78, 0x2E, 0x31, 0x00, 0xF4, 0x39, 0xB2, 0x71,
2111 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2112 		0x00, 0x00, 0x00, 0x00
2113 		};
2114 
2115 	{
2116 	SvStorageStreamRef xStor( rObj->OpenSotStream( C2S("\1CompObj")));
2117 	xStor->Write(aCompObj,sizeof(aCompObj));
2118 	DBG_ASSERT((xStor.Is() && (SVSTREAM_OK == xStor->GetError())),"damn");
2119 	}
2120 
2121 	{
2122 	SvStorageStreamRef xStor3( rObj->OpenSotStream( C2S("\3ObjInfo")));
2123 	xStor3->Write(aObjInfo,sizeof(aObjInfo));
2124 	DBG_ASSERT((xStor3.Is() && (SVSTREAM_OK == xStor3->GetError())),"damn");
2125 	}
2126 
2127 	static sal_uInt8 __READONLY_DATA aOCXNAME[] = {
2128 		0x54, 0x00, 0x65, 0x00, 0x78, 0x00, 0x74, 0x00,
2129 		0x42, 0x00, 0x6F, 0x00, 0x78, 0x00, 0x31, 0x00,
2130 		0x00, 0x00, 0x00, 0x00
2131 		};
2132 
2133 	{
2134 	SvStorageStreamRef xStor2( rObj->OpenSotStream( C2S("\3OCXNAME")));
2135 	xStor2->Write(aOCXNAME,sizeof(aOCXNAME));
2136 	DBG_ASSERT((xStor2.Is() && (SVSTREAM_OK == xStor2->GetError())),"damn");
2137 	}
2138 
2139 	SvStorageStreamRef xContents( rObj->OpenSotStream( C2S("contents")));
2140 	return WriteContents(xContents, rPropSet, rSize);
2141 }
2142 
WriteContents(SvStorageStreamRef & rContents,const uno::Reference<beans::XPropertySet> & rPropSet,const awt::Size & rSize)2143 sal_Bool OCX_FieldControl::WriteContents(SvStorageStreamRef &rContents,
2144 	const uno::Reference< beans::XPropertySet > &rPropSet,
2145 	const awt::Size &rSize)
2146 {
2147 	sal_Bool bRet=sal_True;
2148     sal_uInt32 nOldPos = rContents->Tell();
2149 	rContents->SeekRel(12);
2150 
2151 	pBlockFlags[0] = 0;
2152 	pBlockFlags[1] = 0x01;
2153 	pBlockFlags[2] = 0x00;
2154 	pBlockFlags[3] = 0x80;
2155 	pBlockFlags[4] = 0;
2156 	pBlockFlags[5] = 0;
2157 	pBlockFlags[6] = 0;
2158 	pBlockFlags[7] = 0;
2159 
2160 
2161 	sal_uInt8 nTemp=0x19;
2162 	uno::Any aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("Enabled"));
2163 	fEnabled = any2bool(aTmp);
2164 	if (fEnabled)
2165 		nTemp |= 0x02;
2166 
2167 	aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("ReadOnly"));
2168 	fLocked = any2bool(aTmp);
2169 	if (fLocked)
2170 		nTemp |= 0x04;
2171 
2172 	*rContents << nTemp;
2173 	pBlockFlags[0] |= 0x01;
2174 	*rContents << sal_uInt8(0x48);
2175 	*rContents << sal_uInt8(0x80);
2176 
2177 	nTemp = 0x2C;
2178 	*rContents << nTemp;
2179 
2180 	aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("BackgroundColor"));
2181     if (aTmp.hasValue())
2182 	    aTmp >>= mnBackColor;
2183 	*rContents << ExportColor(mnBackColor);
2184 	pBlockFlags[0] |= 0x02;
2185 
2186 	aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("TextColor"));
2187     if (aTmp.hasValue())
2188 	    aTmp >>= mnForeColor;
2189 	*rContents << ExportColor(mnForeColor);
2190 	pBlockFlags[0] |= 0x04;
2191 
2192 	aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("Border"));
2193 	sal_Int16 nBorder = sal_Int16();
2194 	aTmp >>= nBorder;
2195 	nSpecialEffect = ExportBorder(nBorder,nBorderStyle);
2196 	*rContents << nBorderStyle;
2197 	pBlockFlags[0] |= 0x10;
2198 
2199 #if 0 //Each control has a different Value format, and how to convert each to text has to be found out
2200     SvxOcxString aValue( rPropSet->getPropertyValue(WW8_ASCII2STR("DefaultText")) );
2201     aValue.WriteLenField( *rContents );
2202     if (aValue.HasData())
2203 		pBlockFlags[2] |= 0x40;
2204 #endif
2205 
2206 	*rContents << nSpecialEffect;
2207 	pBlockFlags[3] |= 0x04;
2208 
2209 	WriteAlign(rContents,4);
2210 	*rContents << rSize.Width;
2211 	*rContents << rSize.Height;
2212 
2213 #if 0
2214     aValue.WriteCharArray( *rContents );
2215 #endif
2216 
2217 	WriteAlign(rContents,4);
2218 
2219     nFixedAreaLen = static_cast<sal_uInt16>(rContents->Tell()-nOldPos-4);
2220 
2221 	bRet = aFontData.Export(rContents,rPropSet);
2222 
2223     rContents->Seek(nOldPos);
2224 	*rContents << nStandardId;
2225 	*rContents << nFixedAreaLen;
2226 
2227 	*rContents << pBlockFlags[0];
2228 	*rContents << pBlockFlags[1];
2229 	*rContents << pBlockFlags[2];
2230 	*rContents << pBlockFlags[3];
2231 	*rContents << pBlockFlags[4];
2232 	*rContents << pBlockFlags[5];
2233 	*rContents << pBlockFlags[6];
2234 	*rContents << pBlockFlags[7];
2235 
2236 	DBG_ASSERT((rContents.Is() &&
2237 		(SVSTREAM_OK==rContents->GetError())),"damn");
2238 	return bRet;
2239 }
2240 
Export(SvStorageRef & rObj,const uno::Reference<beans::XPropertySet> & rPropSet,const awt::Size & rSize)2241 sal_Bool OCX_FieldControl::Export(SvStorageRef &rObj,
2242 	const uno::Reference< beans::XPropertySet > &rPropSet,
2243 	const awt::Size &rSize)
2244 {
2245 	static sal_uInt8 __READONLY_DATA aCompObj[] = {
2246 		0x01, 0x00, 0xFE, 0xFF, 0x03, 0x0A, 0x00, 0x00,
2247 		0xFF, 0xFF, 0xFF, 0xFF, 0x10, 0x1D, 0xD2, 0x8B,
2248 		0x42, 0xEC, 0xCE, 0x11, 0x9E, 0x0D, 0x00, 0xAA,
2249 		0x00, 0x60, 0x02, 0xF3, 0x1C, 0x00, 0x00, 0x00,
2250 		0x4D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66,
2251 		0x74, 0x20, 0x46, 0x6F, 0x72, 0x6D, 0x73, 0x20,
2252 		0x32, 0x2E, 0x30, 0x20, 0x54, 0x65, 0x78, 0x74,
2253 		0x42, 0x6F, 0x78, 0x00, 0x10, 0x00, 0x00, 0x00,
2254 		0x45, 0x6D, 0x62, 0x65, 0x64, 0x64, 0x65, 0x64,
2255 		0x20, 0x4F, 0x62, 0x6A, 0x65, 0x63, 0x74, 0x00,
2256 		0x10, 0x00, 0x00, 0x00, 0x46, 0x6F, 0x72, 0x6D,
2257 		0x73, 0x2E, 0x54, 0x65, 0x78, 0x74, 0x42, 0x6F,
2258 		0x78, 0x2E, 0x31, 0x00, 0xF4, 0x39, 0xB2, 0x71,
2259 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2260 		0x00, 0x00, 0x00, 0x00
2261 		};
2262 
2263 	{
2264 	SvStorageStreamRef xStor( rObj->OpenSotStream( C2S("\1CompObj")));
2265 	xStor->Write(aCompObj,sizeof(aCompObj));
2266 	DBG_ASSERT((xStor.Is() && (SVSTREAM_OK == xStor->GetError())),"damn");
2267 	}
2268 
2269 	{
2270 	SvStorageStreamRef xStor3( rObj->OpenSotStream( C2S("\3ObjInfo")));
2271 	xStor3->Write(aObjInfo,sizeof(aObjInfo));
2272 	DBG_ASSERT((xStor3.Is() && (SVSTREAM_OK == xStor3->GetError())),"damn");
2273 	}
2274 
2275 	static sal_uInt8 __READONLY_DATA aOCXNAME[] = {
2276 		0x54, 0x00, 0x65, 0x00, 0x78, 0x00, 0x74, 0x00,
2277 		0x42, 0x00, 0x6F, 0x00, 0x78, 0x00, 0x31, 0x00,
2278 		0x00, 0x00, 0x00, 0x00
2279 		};
2280 
2281 	{
2282 	SvStorageStreamRef xStor2( rObj->OpenSotStream( C2S("\3OCXNAME")));
2283 	xStor2->Write(aOCXNAME,sizeof(aOCXNAME));
2284 	DBG_ASSERT((xStor2.Is() && (SVSTREAM_OK == xStor2->GetError())),"damn");
2285 	}
2286 
2287 	SvStorageStreamRef xContents( rObj->OpenSotStream( C2S("contents")));
2288 	return WriteContents(xContents, rPropSet, rSize);
2289 }
2290 
2291 
2292 
Import(com::sun::star::uno::Reference<com::sun::star::beans::XPropertySet> & rPropSet)2293 sal_Bool OCX_ToggleButton::Import(com::sun::star::uno::Reference<
2294     com::sun::star::beans::XPropertySet> &rPropSet)
2295 {
2296 	uno::Any aTmp(&sName,getCppuType((OUString *)0));
2297 	rPropSet->setPropertyValue( WW8_ASCII2STR("Name"), aTmp );
2298 
2299     aTmp = bool2any(true);
2300     rPropSet->setPropertyValue( WW8_ASCII2STR("Toggle"), aTmp );
2301 
2302 	sal_Bool bTemp;
2303 	if ((!(fEnabled)) || (fLocked))
2304 		bTemp = sal_False;
2305 	else
2306 		bTemp = sal_True;
2307 	aTmp = bool2any(bTemp);
2308 	rPropSet->setPropertyValue( WW8_ASCII2STR("Enabled"), aTmp);
2309 
2310     bTemp = fWordWrap != 0;
2311     aTmp = bool2any(bTemp);
2312     rPropSet->setPropertyValue( WW8_ASCII2STR("MultiLine"), aTmp);
2313 
2314 	aTmp <<= ImportColor(mnForeColor);
2315 	rPropSet->setPropertyValue( WW8_ASCII2STR("TextColor"), aTmp);
2316 
2317     // fake transparent toggle button by setting window background color
2318     if( !fBackStyle )
2319         mnBackColor = 0x80000005;
2320     aTmp <<= ImportColor(mnBackColor);
2321     rPropSet->setPropertyValue( WW8_ASCII2STR("BackgroundColor"), aTmp);
2322 
2323 	if (pValue)
2324 	{
2325 		sal_Int16 nTmp=pValue[0]-0x30;
2326         aTmp <<= nTmp == 1;
2327         rPropSet->setPropertyValue( WW8_ASCII2STR("DefaultState"), aTmp);
2328 	}
2329 
2330 	if (pCaption)
2331 	{
2332         aTmp <<= lclCreateOUString( pCaption, nCaptionLen );
2333 		rPropSet->setPropertyValue( WW8_ASCII2STR("Label"), aTmp);
2334 	}
2335 
2336 	aFontData.Import(rPropSet);
2337 	return sal_True;
2338 }
2339 
Export(SvStorageRef & rObj,const uno::Reference<beans::XPropertySet> & rPropSet,const awt::Size & rSize)2340 sal_Bool OCX_ToggleButton::Export(
2341     SvStorageRef &rObj, const uno::Reference< beans::XPropertySet> &rPropSet,
2342     const awt::Size& rSize )
2343 {
2344     static sal_uInt8 __READONLY_DATA aCompObj[] = {
2345             0x01, 0x00, 0xFE, 0xFF, 0x03, 0x0A, 0x00, 0x00,
2346             0xFF, 0xFF, 0xFF, 0xFF, 0x60, 0x1D, 0xD2, 0x8B,
2347             0x42, 0xEC, 0xCE, 0x11, 0x9E, 0x0D, 0x00, 0xAA,
2348             0x00, 0x60, 0x02, 0xF3, 0x21, 0x00, 0x00, 0x00,
2349             0x4D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66,
2350             0x74, 0x20, 0x46, 0x6F, 0x72, 0x6D, 0x73, 0x20,
2351             0x32, 0x2E, 0x30, 0x20, 0x54, 0x6F, 0x67, 0x67,
2352             0x6C, 0x65, 0x42, 0x75, 0x74, 0x74, 0x6F, 0x6E,
2353             0x00, 0x10, 0x00, 0x00, 0x00, 0x45, 0x6D, 0x62,
2354             0x65, 0x64, 0x64, 0x65, 0x64, 0x20, 0x4F, 0x62,
2355             0x6A, 0x65, 0x63, 0x74, 0x00, 0x15, 0x00, 0x00,
2356             0x00, 0x46, 0x6F, 0x72, 0x6D, 0x73, 0x2E, 0x54,
2357             0x6F, 0x67, 0x67, 0x6C, 0x65, 0x42, 0x75, 0x74,
2358             0x74, 0x6F, 0x6E, 0x2E, 0x31, 0x00, 0xF4, 0x39,
2359             0xB2, 0x71, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2360             0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2361         };
2362 
2363     {
2364     SvStorageStreamRef xStor( rObj->OpenSotStream( C2S("\1CompObj")));
2365     xStor->Write(aCompObj,sizeof(aCompObj));
2366     DBG_ASSERT((xStor.Is() && (SVSTREAM_OK == xStor->GetError())),"damn");
2367     }
2368 
2369     {
2370     SvStorageStreamRef xStor3( rObj->OpenSotStream( C2S("\3ObjInfo")));
2371     xStor3->Write(aObjInfo,sizeof(aObjInfo));
2372     DBG_ASSERT((xStor3.Is() && (SVSTREAM_OK == xStor3->GetError())),"damn");
2373     }
2374 
2375     static sal_uInt8 __READONLY_DATA aOCXNAME[] = {
2376         0x54, 0x00, 0x6F, 0x00, 0x67, 0x00, 0x67, 0x00,
2377         0x6C, 0x00, 0x65, 0x00, 0x42, 0x00, 0x75, 0x00,
2378         0x74, 0x00, 0x74, 0x00, 0x6F, 0x00, 0x6E, 0x00,
2379         0x31, 0x00, 0x00, 0x00, 0x00, 0x00
2380     };
2381 
2382     {
2383     SvStorageStreamRef xStor2( rObj->OpenSotStream( C2S("\3OCXNAME")));
2384     xStor2->Write(aOCXNAME,sizeof(aOCXNAME));
2385     DBG_ASSERT((xStor2.Is() && (SVSTREAM_OK == xStor2->GetError())),"damn");
2386     }
2387 
2388     SvStorageStreamRef xContents( rObj->OpenSotStream( C2S("contents")));
2389 
2390     return WriteContents(xContents,rPropSet,rSize);
2391 }
2392 
WriteContents(SvStorageStreamRef & rContents,const uno::Reference<beans::XPropertySet> & rPropSet,const awt::Size & rSize)2393 sal_Bool OCX_ToggleButton::WriteContents(SvStorageStreamRef &rContents,
2394     const uno::Reference< beans::XPropertySet > &rPropSet,
2395     const awt::Size &rSize)
2396 {
2397     sal_Bool bRet=sal_True;
2398     sal_uInt32 nOldPos = rContents->Tell();
2399     rContents->SeekRel(12);
2400 
2401     pBlockFlags[0] = 0;
2402     pBlockFlags[1] = 0x01;
2403     pBlockFlags[2] = 0;
2404     pBlockFlags[3] = 0x80;
2405     pBlockFlags[4] = 0;
2406     pBlockFlags[5] = 0;
2407     pBlockFlags[6] = 0;
2408     pBlockFlags[7] = 0;
2409 
2410     uno::Any aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("Enabled"));
2411     fEnabled = any2bool(aTmp);
2412 
2413     sal_uInt8 nTemp=fEnabled;
2414     if (fEnabled)
2415         nTemp = nTemp << 1;
2416     if (fBackStyle)
2417         nTemp |= 0x08;
2418     *rContents << nTemp;
2419     pBlockFlags[0] |= 0x01;
2420     *rContents << sal_uInt8(0x00);
2421     nTemp = 0;
2422     aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("MultiLine"));
2423     fWordWrap = any2bool(aTmp);
2424     if (fWordWrap)
2425         nTemp |= 0x80;
2426     *rContents << nTemp;
2427     *rContents << sal_uInt8(0x00);
2428 
2429     aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("BackgroundColor"));
2430     if (aTmp.hasValue())
2431         aTmp >>= mnBackColor;
2432     *rContents << ExportColor(mnBackColor);
2433     pBlockFlags[0] |= 0x02;
2434 
2435     aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("TextColor"));
2436     if (aTmp.hasValue())
2437         aTmp >>= mnForeColor;
2438     *rContents << ExportColor(mnForeColor);
2439     pBlockFlags[0] |= 0x04;
2440 
2441     nStyle = 6;
2442     *rContents << nStyle;
2443     pBlockFlags[0] |= 0x40;
2444 
2445     WriteAlign(rContents,4);
2446     nValueLen = 1|SVX_MSOCX_COMPRESSED;
2447     bool bDefault = false;
2448     rPropSet->getPropertyValue(WW8_ASCII2STR("DefaultState")) >>= bDefault;
2449     sal_uInt8 nDefault = static_cast< sal_uInt8 >( bDefault ? '1' : '0' );
2450     *rContents << nValueLen;
2451     pBlockFlags[2] |= 0x40;
2452 
2453     SvxOcxString aCaption( rPropSet->getPropertyValue(WW8_ASCII2STR("Label")) );
2454     aCaption.WriteLenField( *rContents );
2455     if (aCaption.HasData())
2456         pBlockFlags[2] |= 0x80;
2457 
2458     WriteAlign(rContents,4);
2459     *rContents << rSize.Width;
2460     *rContents << rSize.Height;
2461 
2462     *rContents << nDefault;
2463     *rContents << sal_uInt8(0x00);
2464 
2465     aCaption.WriteCharArray( *rContents );
2466 
2467     WriteAlign(rContents,4);
2468     nFixedAreaLen = static_cast<sal_uInt16>(rContents->Tell()-nOldPos-4);
2469     bRet = aFontData.Export(rContents,rPropSet);
2470     rContents->Seek(nOldPos);
2471     *rContents << nStandardId;
2472     *rContents << nFixedAreaLen;
2473 
2474     *rContents << pBlockFlags[0];
2475     *rContents << pBlockFlags[1];
2476     *rContents << pBlockFlags[2];
2477     *rContents << pBlockFlags[3];
2478     *rContents << pBlockFlags[4];
2479     *rContents << pBlockFlags[5];
2480     *rContents << pBlockFlags[6];
2481     *rContents << pBlockFlags[7];
2482 
2483     DBG_ASSERT((rContents.Is() &&
2484         (SVSTREAM_OK==rContents->GetError())),"damn");
2485     return bRet;
2486 }
2487 
Import(uno::Reference<beans::XPropertySet> & rPropSet)2488 sal_Bool OCX_Label::Import(uno::Reference< beans::XPropertySet > &rPropSet)
2489 {
2490 	uno::Any aTmp(&sName,getCppuType((OUString *)0));
2491 	rPropSet->setPropertyValue( WW8_ASCII2STR("Name"), aTmp );
2492 
2493 	sal_Bool bTemp;
2494 	if ((!(fEnabled)) || (fLocked))
2495 		bTemp = sal_False;
2496 	else
2497 		bTemp = sal_True;
2498 	aTmp = bool2any(bTemp);
2499 	rPropSet->setPropertyValue( WW8_ASCII2STR("Enabled"), aTmp);
2500 
2501 	aTmp <<= ImportColor(mnForeColor);
2502 	rPropSet->setPropertyValue( WW8_ASCII2STR("TextColor"), aTmp);
2503 
2504     // background color: fBackStyle==0 -> transparent
2505     if( fBackStyle )
2506     {
2507         aTmp <<= ImportColor(mnBackColor);
2508     }
2509     else
2510     {
2511         // try fake transparent by using parents backColor
2512         if ( bSetInDialog && mpParent != NULL )
2513         {
2514             aTmp <<= ImportColor( mpParent->mnBackColor );
2515         }
2516         else
2517         {
2518             aTmp = uno::Any(); // use SO default
2519         }
2520     }
2521     rPropSet->setPropertyValue( WW8_ASCII2STR("BackgroundColor"), aTmp);
2522 
2523 	aTmp <<= ImportBorder(nSpecialEffect,nBorderStyle);
2524 	rPropSet->setPropertyValue( WW8_ASCII2STR("Border"), aTmp);
2525 
2526     aTmp <<= ImportColor( nBorderColor );
2527     rPropSet->setPropertyValue( WW8_ASCII2STR("BorderColor"), aTmp);
2528 
2529 	bTemp=fWordWrap;
2530 	aTmp = bool2any(bTemp);
2531 	rPropSet->setPropertyValue( WW8_ASCII2STR("MultiLine"), aTmp);
2532 
2533 	if (pCaption)
2534 	{
2535         aTmp <<= lclCreateOUString( pCaption, nCaptionLen );
2536 		rPropSet->setPropertyValue( WW8_ASCII2STR("Label"), aTmp);
2537 	}
2538 
2539 	aFontData.Import(rPropSet);
2540 	return sal_True;
2541 }
2542 
Import(com::sun::star::uno::Reference<com::sun::star::beans::XPropertySet> & rPropSet)2543 sal_Bool OCX_ComboBox::Import(com::sun::star::uno::Reference<
2544     com::sun::star::beans::XPropertySet> &rPropSet)
2545 {
2546 
2547 	uno::Any aTmp(&sName,getCppuType((OUString *)0));
2548 	rPropSet->setPropertyValue( WW8_ASCII2STR("Name"), aTmp );
2549 
2550     aTmp = bool2any(fEnabled != 0);
2551 	rPropSet->setPropertyValue( WW8_ASCII2STR("Enabled"), aTmp);
2552 
2553     aTmp = bool2any(fLocked != 0);
2554 	rPropSet->setPropertyValue( WW8_ASCII2STR("ReadOnly"), aTmp);
2555 
2556     aTmp = bool2any( nDropButtonStyle != 0 );
2557 	rPropSet->setPropertyValue( WW8_ASCII2STR("Dropdown"), aTmp);
2558 
2559     aTmp = bool2any( fHideSelection != 0 );
2560     rPropSet->setPropertyValue( WW8_ASCII2STR( "HideInactiveSelection" ), aTmp);
2561 
2562 	aTmp <<= ImportColor(mnForeColor);
2563 	rPropSet->setPropertyValue( WW8_ASCII2STR("TextColor"), aTmp);
2564 
2565 	if (pValue)
2566     {
2567         aTmp <<= lclCreateOUString( pValue, nValueLen );
2568         if ( bSetInDialog )
2569         {
2570             rPropSet->setPropertyValue( WW8_ASCII2STR("Text"), aTmp);
2571         }
2572         else
2573         {
2574             rPropSet->setPropertyValue( WW8_ASCII2STR("DefaultText"), aTmp);
2575         }
2576     }
2577 
2578 	aTmp <<= ImportColor(mnBackColor);
2579 	rPropSet->setPropertyValue( WW8_ASCII2STR("BackgroundColor"), aTmp);
2580 
2581 	aTmp <<= ImportBorder(nSpecialEffect,nBorderStyle);
2582 	rPropSet->setPropertyValue( WW8_ASCII2STR("Border"), aTmp);
2583 
2584     aTmp <<= ImportColor( nBorderColor );
2585     rPropSet->setPropertyValue( WW8_ASCII2STR("BorderColor"), aTmp);
2586 
2587 	sal_Int16 nTmp=static_cast<sal_Int16>(nMaxLength);
2588 	aTmp <<= nTmp;
2589 	rPropSet->setPropertyValue( WW8_ASCII2STR("MaxTextLen"), aTmp);
2590 
2591 	aFontData.Import(rPropSet);
2592 	return sal_True;
2593 }
2594 
WriteContents(SvStorageStreamRef & rContents,const uno::Reference<beans::XPropertySet> & rPropSet,const awt::Size & rSize)2595 sal_Bool OCX_ComboBox::WriteContents(SvStorageStreamRef &rContents,
2596 	const uno::Reference< beans::XPropertySet > &rPropSet,
2597 	const awt::Size &rSize)
2598 {
2599 	sal_Bool bRet=sal_True;
2600     sal_uInt32 nOldPos = rContents->Tell();
2601 	rContents->SeekRel(12);
2602 
2603 	pBlockFlags[0] = 0;
2604 	pBlockFlags[1] = 0x01;
2605 	pBlockFlags[2] = 0x00;
2606 	pBlockFlags[3] = 0x80;
2607 	pBlockFlags[4] = 0;
2608 	pBlockFlags[5] = 0;
2609 	pBlockFlags[6] = 0;
2610 	pBlockFlags[7] = 0;
2611 
2612 
2613 	sal_uInt8 nTemp=0x19;//fEnabled;
2614 	uno::Any aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("Enabled"));
2615 	fEnabled = any2bool(aTmp);
2616 	if (fEnabled)
2617 		nTemp |= 0x02;
2618 
2619 	aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("ReadOnly"));
2620 	fLocked = any2bool(aTmp);
2621 	if (fLocked)
2622 		nTemp |= 0x04;
2623 
2624 	*rContents << nTemp;
2625 	pBlockFlags[0] |= 0x01;
2626 	*rContents << sal_uInt8(0x48);
2627 	*rContents << sal_uInt8(0x80);
2628 
2629     nTemp = 0x0C;
2630     fHideSelection = any2bool(rPropSet->getPropertyValue(WW8_ASCII2STR("HideInactiveSelection")));
2631     if( fHideSelection )
2632         nTemp |= 0x20;
2633     *rContents << nTemp;
2634 
2635 	aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("BackgroundColor"));
2636     if (aTmp.hasValue())
2637 	    aTmp >>= mnBackColor;
2638 	*rContents << ExportColor(mnBackColor);
2639 	pBlockFlags[0] |= 0x02;
2640 
2641 	aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("TextColor"));
2642     if (aTmp.hasValue())
2643 	    aTmp >>= mnForeColor;
2644 	*rContents << ExportColor(mnForeColor);
2645 	pBlockFlags[0] |= 0x04;
2646 
2647 	aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("Border"));
2648 	sal_Int16 nBorder = sal_Int16();
2649 	aTmp >>= nBorder;
2650 	nSpecialEffect = ExportBorder(nBorder,nBorderStyle);
2651 	*rContents << nBorderStyle;
2652 	pBlockFlags[0] |= 0x10;
2653 
2654 	nStyle = 3;
2655 	*rContents << nStyle;
2656 	pBlockFlags[0] |= 0x40;
2657 
2658 	WriteAlign(rContents,2);
2659 
2660 	aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("LineCount"));
2661 	aTmp >>= nListRows;
2662 	*rContents << nListRows;
2663 	pBlockFlags[1] |= 0x40;
2664 
2665 	*rContents << sal_uInt8(1); //DefaultSelected One
2666 	pBlockFlags[2] |= 0x01;
2667 
2668 	aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("Dropdown"));
2669 	nDropButtonStyle = any2bool(aTmp);
2670 	if (nDropButtonStyle)
2671 		nDropButtonStyle=0x02;
2672 	*rContents << nDropButtonStyle;
2673 	pBlockFlags[2] |= 0x04;
2674 
2675     SvxOcxString aValue( rPropSet->getPropertyValue(WW8_ASCII2STR("Text")) );
2676     aValue.WriteLenField( *rContents );
2677     if (aValue.HasData())
2678 		pBlockFlags[2] |= 0x40;
2679 
2680 	WriteAlign(rContents,4);
2681     aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("BorderColor"));
2682     if (aTmp.hasValue())
2683         aTmp >>= nBorderColor;
2684     *rContents << ExportColor(nBorderColor);
2685     pBlockFlags[3] |= 0x02;
2686 
2687 	*rContents << nSpecialEffect;
2688 	pBlockFlags[3] |= 0x04;
2689 
2690 	WriteAlign(rContents,4);
2691 	*rContents << rSize.Width;
2692 	*rContents << rSize.Height;
2693 
2694     aValue.WriteCharArray( *rContents );
2695 
2696 	WriteAlign(rContents,4);
2697 
2698     nFixedAreaLen = static_cast<sal_uInt16>(rContents->Tell()-nOldPos-4);
2699 
2700 	bRet = aFontData.Export(rContents,rPropSet);
2701 
2702     rContents->Seek(nOldPos);
2703 	*rContents << nStandardId;
2704 	*rContents << nFixedAreaLen;
2705 
2706 	*rContents << pBlockFlags[0];
2707 	*rContents << pBlockFlags[1];
2708 	*rContents << pBlockFlags[2];
2709 	*rContents << pBlockFlags[3];
2710 	*rContents << pBlockFlags[4];
2711 	*rContents << pBlockFlags[5];
2712 	*rContents << pBlockFlags[6];
2713 	*rContents << pBlockFlags[7];
2714 
2715 	DBG_ASSERT((rContents.Is() &&
2716 		(SVSTREAM_OK==rContents->GetError())),"damn");
2717 	return bRet;
2718 }
2719 
2720 
Export(SvStorageRef & rObj,const uno::Reference<beans::XPropertySet> & rPropSet,const awt::Size & rSize)2721 sal_Bool OCX_ComboBox::Export(SvStorageRef &rObj,
2722 	const uno::Reference< beans::XPropertySet > &rPropSet,
2723 	const awt::Size &rSize)
2724 {
2725 	static sal_uInt8 __READONLY_DATA aCompObj[] = {
2726 		0x01, 0x00, 0xFE, 0xFF, 0x03, 0x0A, 0x00, 0x00,
2727 		0xFF, 0xFF, 0xFF, 0xFF, 0x30, 0x1D, 0xD2, 0x8B,
2728 		0x42, 0xEC, 0xCE, 0x11, 0x9E, 0x0D, 0x00, 0xAA,
2729 		0x00, 0x60, 0x02, 0xF3, 0x1D, 0x00, 0x00, 0x00,
2730 		0x4D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66,
2731 		0x74, 0x20, 0x46, 0x6F, 0x72, 0x6D, 0x73, 0x20,
2732 		0x32, 0x2E, 0x30, 0x20, 0x43, 0x6F, 0x6D, 0x62,
2733 		0x6F, 0x42, 0x6F, 0x78, 0x00, 0x10, 0x00, 0x00,
2734 		0x00, 0x45, 0x6D, 0x62, 0x65, 0x64, 0x64, 0x65,
2735 		0x64, 0x20, 0x4F, 0x62, 0x6A, 0x65, 0x63, 0x74,
2736 		0x00, 0x11, 0x00, 0x00, 0x00, 0x46, 0x6F, 0x72,
2737 		0x6D, 0x73, 0x2E, 0x43, 0x6F, 0x6D, 0x62, 0x6F,
2738 		0x42, 0x6F, 0x78, 0x2E, 0x31, 0x00, 0xF4, 0x39,
2739 		0xB2, 0x71, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2740 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2741 		};
2742 
2743 	{
2744 	SvStorageStreamRef xStor( rObj->OpenSotStream( C2S("\1CompObj")));
2745 	xStor->Write(aCompObj,sizeof(aCompObj));
2746 	DBG_ASSERT((xStor.Is() && (SVSTREAM_OK == xStor->GetError())),"damn");
2747 	}
2748 
2749 	{
2750 	SvStorageStreamRef xStor3( rObj->OpenSotStream( C2S("\3ObjInfo")));
2751 	xStor3->Write(aObjInfo,sizeof(aObjInfo));
2752 	DBG_ASSERT((xStor3.Is() && (SVSTREAM_OK == xStor3->GetError())),"damn");
2753 	}
2754 
2755 	static sal_uInt8 __READONLY_DATA aOCXNAME[] = {
2756 		0x43, 0x00, 0x6F, 0x00, 0x6D, 0x00, 0x62, 0x00,
2757 		0x6F, 0x00, 0x42, 0x00, 0x6F, 0x00, 0x78, 0x00,
2758 		0x31, 0x00, 0x00, 0x00, 0x00, 0x00
2759 	};
2760 
2761 	{
2762 	SvStorageStreamRef xStor2( rObj->OpenSotStream( C2S("\3OCXNAME")));
2763 	xStor2->Write(aOCXNAME,sizeof(aOCXNAME));
2764 	DBG_ASSERT((xStor2.Is() && (SVSTREAM_OK == xStor2->GetError())),"damn");
2765 	}
2766 
2767 	SvStorageStreamRef xContents( rObj->OpenSotStream( C2S("contents")));
2768 	return WriteContents(xContents, rPropSet, rSize);
2769 }
2770 
2771 
2772 
Import(com::sun::star::uno::Reference<com::sun::star::beans::XPropertySet> & rPropSet)2773 sal_Bool OCX_ListBox::Import(com::sun::star::uno::Reference<
2774     com::sun::star::beans::XPropertySet> &rPropSet)
2775 {
2776 
2777 	uno::Any aTmp(&sName,getCppuType((OUString *)0));
2778 	rPropSet->setPropertyValue( WW8_ASCII2STR("Name"), aTmp );
2779 
2780 	sal_Bool bTmp=fEnabled;
2781 	aTmp = bool2any(bTmp);
2782 	rPropSet->setPropertyValue( WW8_ASCII2STR("Enabled"), aTmp);
2783 
2784 	bTmp=fLocked;
2785 	aTmp = bool2any(bTmp);
2786 	rPropSet->setPropertyValue( WW8_ASCII2STR("ReadOnly"), aTmp);
2787 
2788 	aTmp <<= ImportColor(mnForeColor);
2789 	rPropSet->setPropertyValue( WW8_ASCII2STR("TextColor"), aTmp);
2790 
2791 	sal_Bool bTemp = nMultiState;
2792 	aTmp = bool2any(bTemp);
2793 	rPropSet->setPropertyValue( WW8_ASCII2STR("MultiSelection"), aTmp);
2794 
2795 #if 0		//Don't delete this for now until I figure out if I can make this
2796 	if (pValue)
2797     {
2798         aTmp <<= lclCreateOUString( pValue, nValueLen );
2799         xPropSet->setPropertyValue( WW8_ASCII2STR("DefaultText"), aTmp);
2800     }
2801 #endif
2802 
2803 	aTmp <<= ImportColor(mnBackColor);
2804 	rPropSet->setPropertyValue( WW8_ASCII2STR("BackgroundColor"), aTmp);
2805 
2806 	aTmp <<= ImportBorder(nSpecialEffect,nBorderStyle);
2807 	rPropSet->setPropertyValue( WW8_ASCII2STR("Border"), aTmp);
2808 
2809     aTmp <<= ImportColor( nBorderColor );
2810     rPropSet->setPropertyValue( WW8_ASCII2STR("BorderColor"), aTmp);
2811 
2812 	aFontData.Import(rPropSet);
2813 	return sal_True;
2814 }
2815 
WriteContents(SvStorageStreamRef & rContents,const uno::Reference<beans::XPropertySet> & rPropSet,const awt::Size & rSize)2816 sal_Bool OCX_ListBox::WriteContents(SvStorageStreamRef &rContents,
2817 	const uno::Reference< beans::XPropertySet > &rPropSet,
2818 	const awt::Size &rSize)
2819 {
2820 	sal_Bool bRet=sal_True;
2821     sal_uInt32 nOldPos = rContents->Tell();
2822 	rContents->SeekRel(12);
2823 
2824 	pBlockFlags[0] = 0;
2825 	pBlockFlags[1] = 0x01;
2826 	pBlockFlags[2] = 0x01;
2827 	pBlockFlags[3] = 0x80;
2828 	pBlockFlags[4] = 0;
2829 	pBlockFlags[5] = 0;
2830 	pBlockFlags[6] = 0;
2831 	pBlockFlags[7] = 0;
2832 
2833 	uno::Any aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("Enabled"));
2834 	fEnabled = any2bool(aTmp);
2835 	sal_uInt8 nTemp=fEnabled;
2836 	if (fEnabled)
2837 		nTemp = nTemp << 1;
2838 
2839 	aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("ReadOnly"));
2840 	fLocked = any2bool(aTmp);
2841 	if (fLocked)
2842 		nTemp |= 0x04;
2843 
2844 	*rContents << nTemp;
2845 	pBlockFlags[0] |= 0x01;
2846 	*rContents << sal_uInt8(0x00);
2847 	*rContents << sal_uInt8(0x00);
2848 	*rContents << sal_uInt8(0x00);
2849 
2850 	aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("BackgroundColor"));
2851     if (aTmp.hasValue())
2852 	    aTmp >>= mnBackColor;
2853 	*rContents << ExportColor(mnBackColor);
2854 	pBlockFlags[0] |= 0x02;
2855 
2856 	aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("TextColor"));
2857     if (aTmp.hasValue())
2858 	    aTmp >>= mnForeColor;
2859 	*rContents << ExportColor(mnForeColor);
2860 	pBlockFlags[0] |= 0x04;
2861 
2862     aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("Border"));
2863     sal_Int16 nBorder = sal_Int16();
2864     aTmp >>= nBorder;
2865     nSpecialEffect = ExportBorder(nBorder,nBorderStyle);
2866     WriteAlign(rContents,2);
2867     *rContents << nBorderStyle;
2868     pBlockFlags[0] |= 0x10;
2869 
2870 	aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("MultiSelection"));
2871 	nMultiState = any2bool(aTmp);
2872 
2873 	if (nMultiState)
2874 	{
2875 		*rContents << nMultiState;
2876 		pBlockFlags[0] |= 0x20;
2877 	}
2878 
2879 	nStyle = 2;
2880 	*rContents << nStyle;
2881 	pBlockFlags[0] |= 0x40;
2882 
2883 
2884 	WriteAlign(rContents,4);
2885 
2886 #if 0
2887     SvxOcxString aValue( rPropSet->getPropertyValue(WW8_ASCII2STR("DefaultText")) );
2888     aValue.WriteLenField( *rContents );
2889     if (aValue.HasData())
2890 		pBlockFlags[2] |= 0x40;
2891 
2892 	WriteAlign(rContents,4);
2893 #endif
2894 
2895     WriteAlign(rContents,4);
2896     aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("BorderColor"));
2897     if (aTmp.hasValue())
2898         aTmp >>= nBorderColor;
2899     *rContents << ExportColor(nBorderColor);
2900     pBlockFlags[3] |= 0x02;
2901 
2902     *rContents << nSpecialEffect;
2903     pBlockFlags[3] |= 0x04;
2904 
2905     WriteAlign(rContents,4);
2906 	*rContents << rSize.Width;
2907 	*rContents << rSize.Height;
2908 
2909 #if 0
2910     aValue.WriteCharArray( *rContents );
2911 #endif
2912 
2913 	WriteAlign(rContents,4);
2914 
2915     nFixedAreaLen = static_cast<sal_uInt16>(rContents->Tell()-nOldPos-4);
2916 
2917 	bRet = aFontData.Export(rContents,rPropSet);
2918 
2919     rContents->Seek(nOldPos);
2920 	*rContents << nStandardId;
2921 	*rContents << nFixedAreaLen;
2922 
2923 	*rContents << pBlockFlags[0];
2924 	*rContents << pBlockFlags[1];
2925 	*rContents << pBlockFlags[2];
2926 	*rContents << pBlockFlags[3];
2927 	*rContents << pBlockFlags[4];
2928 	*rContents << pBlockFlags[5];
2929 	*rContents << pBlockFlags[6];
2930 	*rContents << pBlockFlags[7];
2931 
2932 	DBG_ASSERT((rContents.Is() &&
2933 		(SVSTREAM_OK==rContents->GetError())),"damn");
2934 	return bRet;
2935 }
2936 
Export(SvStorageRef & rObj,const uno::Reference<beans::XPropertySet> & rPropSet,const awt::Size & rSize)2937 sal_Bool OCX_ListBox::Export(SvStorageRef &rObj,
2938 	const uno::Reference< beans::XPropertySet > &rPropSet,
2939 	const awt::Size &rSize)
2940 {
2941 	static sal_uInt8 __READONLY_DATA aCompObj[] = {
2942 		0x01, 0x00, 0xFE, 0xFF, 0x03, 0x0A, 0x00, 0x00,
2943 		0xFF, 0xFF, 0xFF, 0xFF, 0x20, 0x1D, 0xD2, 0x8B,
2944 		0x42, 0xEC, 0xCE, 0x11, 0x9E, 0x0D, 0x00, 0xAA,
2945 		0x00, 0x60, 0x02, 0xF3, 0x1C, 0x00, 0x00, 0x00,
2946 		0x4D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66,
2947 		0x74, 0x20, 0x46, 0x6F, 0x72, 0x6D, 0x73, 0x20,
2948 		0x32, 0x2E, 0x30, 0x20, 0x4C, 0x69, 0x73, 0x74,
2949 		0x42, 0x6F, 0x78, 0x00, 0x10, 0x00, 0x00, 0x00,
2950 		0x45, 0x6D, 0x62, 0x65, 0x64, 0x64, 0x65, 0x64,
2951 		0x20, 0x4F, 0x62, 0x6A, 0x65, 0x63, 0x74, 0x00,
2952 		0x10, 0x00, 0x00, 0x00, 0x46, 0x6F, 0x72, 0x6D,
2953 		0x73, 0x2E, 0x4C, 0x69, 0x73, 0x74, 0x42, 0x6F,
2954 		0x78, 0x2E, 0x31, 0x00, 0xF4, 0x39, 0xB2, 0x71,
2955 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2956 		0x00, 0x00, 0x00, 0x00
2957 		};
2958 
2959 	{
2960 	SvStorageStreamRef xStor( rObj->OpenSotStream( C2S("\1CompObj")));
2961 	xStor->Write(aCompObj,sizeof(aCompObj));
2962 	DBG_ASSERT((xStor.Is() && (SVSTREAM_OK == xStor->GetError())),"damn");
2963 	}
2964 
2965 	{
2966 	SvStorageStreamRef xStor3( rObj->OpenSotStream( C2S("\3ObjInfo")));
2967 	xStor3->Write(aObjInfo,sizeof(aObjInfo));
2968 	DBG_ASSERT((xStor3.Is() && (SVSTREAM_OK == xStor3->GetError())),"damn");
2969 	}
2970 
2971 	static sal_uInt8 __READONLY_DATA aOCXNAME[] = {
2972 		0x4C, 0x00, 0x69, 0x00, 0x73, 0x00, 0x74, 0x00,
2973 		0x42, 0x00, 0x6F, 0x00, 0x78, 0x00, 0x31, 0x00,
2974 		0x00, 0x00, 0x00, 0x00
2975 		};
2976 
2977 	{
2978 	SvStorageStreamRef xStor2( rObj->OpenSotStream( C2S("\3OCXNAME")));
2979 	xStor2->Write(aOCXNAME,sizeof(aOCXNAME));
2980 	DBG_ASSERT((xStor2.Is() && (SVSTREAM_OK == xStor2->GetError())),"damn");
2981 	}
2982 
2983 	SvStorageStreamRef xContents( rObj->OpenSotStream( C2S("contents")));
2984 	return WriteContents(xContents, rPropSet, rSize);
2985 }
2986 
Read(SvStorageStream * pS)2987 sal_Bool OCX_Control::Read(SvStorageStream *pS)
2988 {
2989     sal_uInt16 nIdentifier, nFixedAreaLen;
2990 	*pS >> nIdentifier;
2991 	DBG_ASSERT(nStandardId==nIdentifier,
2992 		"A control that has a different identifier");
2993 	*pS >> nFixedAreaLen;
2994     pS->SeekRel(nFixedAreaLen);
2995     return true;
2996 }
2997 
Read(SvStorageStream * pS)2998 sal_Bool OCX_ModernControl::Read(SvStorageStream *pS)
2999 {
3000     long nStart = pS->Tell();
3001 	*pS >> nIdentifier;
3002 	DBG_ASSERT(nIdentifier==nStandardId,
3003 			"A control that has a different identifier");
3004 	*pS >> nFixedAreaLen;
3005 	pS->Read(pBlockFlags,8);
3006 
3007 	if (pBlockFlags[0] & 0x01)
3008 	{
3009 		sal_uInt8 nTemp;
3010 		*pS >> nTemp;
3011 
3012 		fEnabled = (nTemp & 0x02) >> 1;
3013 		fLocked = (nTemp & 0x04) >> 2;
3014         fBackStyle = (nTemp & 0x08) >> 3;
3015 
3016 		*pS >> nTemp;
3017 
3018 		fColumnHeads = (nTemp & 0x04) >> 2;
3019 		fIntegralHeight = (nTemp & 0x08) >> 3;
3020 		fMatchRequired = (nTemp & 0x10) >> 4;
3021 		fAlignment = (nTemp & 0x20) >> 5;
3022 
3023 		*pS >> nTemp;
3024 
3025 		fDragBehaviour = (nTemp & 0x08) >> 3;
3026 		fEnterKeyBehaviour = (nTemp & 0x10) >> 4;
3027 		fEnterFieldBehaviour = (nTemp & 0x20) >> 5;
3028 		fTabKeyBehaviour = (nTemp & 0x40) >> 6;
3029 		fWordWrap = (nTemp & 0x80) >> 7;
3030 
3031 		*pS >> nTemp;
3032 		fSelectionMargin = (nTemp & 0x04) >> 2;
3033 		fAutoWordSelect = (nTemp & 0x08) >> 3;
3034 		fAutoSize = (nTemp & 0x10) >> 4;
3035 		fHideSelection = (nTemp & 0x20) >> 5;
3036 		fAutoTab = (nTemp & 0x40) >> 6;
3037 		fMultiLine = (nTemp & 0x80) >> 7;
3038 
3039 	}
3040 
3041 	/*If any of these are set they follow eachother in this order one after
3042 	another padded out to the next U32 boundary with 0's
3043 	U8 can abut each other U16 must start on a U16 boundary and are padded to
3044 	that with 0's. A standardish word alignment structure*/
3045 
3046 	if (pBlockFlags[0] & 0x02)
3047 		*pS >> mnBackColor;
3048 	if (pBlockFlags[0] & 0x04)
3049 		*pS >> mnForeColor;
3050 	if (pBlockFlags[0] & 0x08)
3051 		*pS >> nMaxLength;
3052 
3053 	if (pBlockFlags[0] & 0x10)
3054 		*pS >> nBorderStyle;
3055 	if (pBlockFlags[0] & 0x20)
3056 		*pS >> nScrollBars;
3057 	if (pBlockFlags[0] & 0x40)
3058 		*pS >> nStyle;// (UI 0 == Data 3, UI 2 = Data 7)
3059 	if (pBlockFlags[0] & 0x80)
3060 		*pS >> nMousePointer;
3061 
3062 	if (pBlockFlags[1] & 0x02)
3063 		*pS >> nPasswordChar; //HUH ??? always 0 ??? not sure maybe just padding
3064 
3065 	if (pBlockFlags[1] & 0x04)
3066 	{
3067 		ReadAlign(pS, pS->Tell() - nStart, 4);
3068 		*pS >> nListWidth;
3069 	}
3070 
3071 	if (pBlockFlags[1] & 0x08)
3072 	{
3073 		ReadAlign(pS, pS->Tell() - nStart, 2);
3074 		*pS >> nBoundColumn;
3075 	}
3076 	if (pBlockFlags[1] & 0x10)
3077 	{
3078 		ReadAlign(pS, pS->Tell() - nStart, 2);
3079 		*pS >> nTextColumn;
3080 	}
3081 	if (pBlockFlags[1] & 0x20)
3082 	{
3083 		ReadAlign(pS, pS->Tell() - nStart, 2);
3084 		*pS >> nColumnCount;
3085 	}
3086 	if (pBlockFlags[1] & 0x40)
3087 	{
3088 		ReadAlign(pS, pS->Tell() - nStart, 2);
3089 		*pS >> nListRows;
3090 	}
3091 	if (pBlockFlags[1] & 0x80)
3092 	{
3093 		ReadAlign(pS, pS->Tell() - nStart, 2);
3094 		*pS >> nUnknown8; //something to do with ColumnWidths
3095 	}
3096 	if (pBlockFlags[2] & 0x01)
3097 		*pS >> nMatchEntry;
3098 	if (pBlockFlags[2] & 0x02)
3099 		*pS >> nListStyle;
3100 	if (pBlockFlags[2] & 0x04)
3101 		*pS >> nShowDropButtonWhen;
3102 	if (pBlockFlags[2] & 0x10)
3103 		*pS >> nDropButtonStyle;
3104 	if (pBlockFlags[2] & 0x20)
3105 		*pS >> nMultiState;
3106 
3107     bool bValue = (pBlockFlags[2] & 0x40) != 0;
3108     if (bValue)
3109 	{
3110 		ReadAlign(pS, pS->Tell() - nStart, 4);
3111         *pS >> nValueLen;
3112 	}
3113     bool bCaption = (pBlockFlags[2] & 0x80) != 0;
3114     if (bCaption)
3115 	{
3116 		ReadAlign(pS, pS->Tell() - nStart, 4);
3117         *pS >> nCaptionLen;
3118 	}
3119 	if (pBlockFlags[3] & 0x01)
3120 	{
3121 		ReadAlign(pS, pS->Tell() - nStart, 4);
3122 		*pS >> nHorzPos;
3123 		*pS >> nVertPos;
3124 	}
3125 	if (pBlockFlags[3] & 0x02)
3126 	{
3127 		ReadAlign(pS, pS->Tell() - nStart, 4);
3128 		*pS >> nBorderColor;
3129 	}
3130 	if (pBlockFlags[3] & 0x04)
3131 	{
3132 		ReadAlign(pS, pS->Tell() - nStart, 4); // NEW
3133 		*pS >> nSpecialEffect;
3134         pS->SeekRel( 3 );       // special effect is 32bit, not 8bit
3135 	}
3136 	if (pBlockFlags[3] & 0x08)
3137 	{
3138 		ReadAlign(pS, pS->Tell() - nStart, 2);
3139 		*pS >> nIcon;
3140 		DBG_ASSERT(nIcon == 0xFFFF, "Unexpected nIcon");
3141 	}
3142 	if (pBlockFlags[3] & 0x10)
3143 	{
3144 		ReadAlign(pS, pS->Tell() - nStart, 2);
3145 		*pS >> nPicture;
3146 		DBG_ASSERT(nPicture == 0xFFFF, "Unexpected nIcon");
3147 	}
3148 	if (pBlockFlags[3] & 0x20)
3149 		*pS >> nAccelerator;
3150 	/*
3151 	if (pBlockFlags[3] & 0x80)
3152 		*pS >> nUnknown9;
3153 	*/
3154     bool bGroupName = (pBlockFlags[4] & 0x01) != 0;
3155     if (bGroupName)
3156 	{
3157 		ReadAlign(pS, pS->Tell() - nStart, 4);
3158         *pS >> nGroupNameLen;
3159 	}
3160 
3161 	//End
3162 
3163 	ReadAlign(pS, pS->Tell() - nStart, 4);
3164 	*pS >> nWidth;
3165 	*pS >> nHeight;
3166 
3167     if (bValue)
3168         lclReadCharArray( *pS, pValue, nValueLen, pS->Tell() - nStart);
3169 
3170     if (bCaption)
3171         lclReadCharArray( *pS, pCaption, nCaptionLen, pS->Tell() - nStart);
3172 
3173     if (bGroupName)
3174         lclReadCharArray( *pS, pGroupName, nGroupNameLen, pS->Tell() - nStart);
3175 
3176     ReadAlign(pS, pS->Tell() - nStart, 4);
3177 	if (nIcon)
3178 	{
3179 		pS->Read(pIconHeader,20);
3180 		*pS >> nIconLen;
3181 		pIcon = new sal_uInt8[nIconLen];
3182 		pS->Read(pIcon,nIconLen);
3183 	}
3184 
3185 	if (nPicture)
3186 	{
3187 		pS->Read(pPictureHeader,20);
3188 		*pS >> nPictureLen;
3189 		pPicture = new sal_uInt8[nPictureLen];
3190 		pS->Read(pPicture,nPictureLen);
3191 	}
3192 
3193 	return sal_True;
3194 }
3195 
3196 
Read(SvStorageStream * pS)3197 sal_Bool OCX_CommandButton::Read(SvStorageStream *pS)
3198 {
3199     long nStart = pS->Tell();
3200 	*pS >> nIdentifier;
3201 	DBG_ASSERT(nStandardId==nIdentifier,
3202 		"A control that has a different identifier");
3203 	*pS >> nFixedAreaLen;
3204 	pS->Read(pBlockFlags,4);
3205 
3206 
3207 	if (pBlockFlags[0] & 0x01)
3208 		*pS >> mnForeColor;
3209 	if (pBlockFlags[0] & 0x02)
3210 		*pS >> mnBackColor;
3211 
3212 	if (pBlockFlags[0] & 0x04)
3213 	{
3214 		sal_uInt8 nTemp;
3215 		*pS >> nTemp;
3216 		fEnabled = (nTemp&0x02)>>1;
3217 		fLocked = (nTemp&0x04)>>2;
3218 		fBackStyle = (nTemp&0x08)>>3;
3219 		*pS >> nTemp;
3220 		*pS >> nTemp;
3221 		fWordWrap = (nTemp&0x80)>>7;
3222 		*pS >> nTemp;
3223 		fAutoSize = (nTemp&0x10)>>4;
3224 	}
3225 
3226     bool bCaption = (pBlockFlags[0] & 0x08) != 0;
3227     if (bCaption)
3228     {
3229 		*pS >> nCaptionLen;
3230     }
3231 	if (pBlockFlags[0] & 0x10) /*Picture Position, a strange mechanism here*/
3232 	{
3233 		*pS >> nVertPos;
3234 		*pS >> nHorzPos;
3235 	}
3236 
3237 	if (pBlockFlags[0] & 0x40) /*MousePointer*/
3238 		*pS >> nMousePointer;
3239 
3240 	if (pBlockFlags[0] & 0x80)
3241 	{
3242 		ReadAlign(pS, pS->Tell() - nStart, 2);
3243 		*pS >> nPicture;
3244 	}
3245 
3246 	if (pBlockFlags[1] & 0x01)
3247 	{
3248 		ReadAlign(pS, pS->Tell() - nStart, 2);
3249 		*pS >> nAccelerator;
3250 	}
3251 
3252     // "take focus on click" is directly in content flags, not in option field...
3253     mbTakeFocus = (pBlockFlags[1] & 0x02) == 0;     // option is on, if flag is not set
3254 
3255 	if (pBlockFlags[1] & 0x04)
3256 	{
3257 		ReadAlign(pS, pS->Tell() - nStart, 2);
3258 		*pS >> nIcon;
3259 	}
3260 
3261     if (bCaption)
3262         lclReadCharArray( *pS, pCaption, nCaptionLen, pS->Tell() - nStart);
3263 
3264 	ReadAlign(pS, pS->Tell() - nStart, 4);
3265 	*pS >> nWidth;
3266 	*pS >> nHeight;
3267 
3268 	if (nIcon)
3269 	{
3270 		pS->Read(pIconHeader,20);
3271 		*pS >> nIconLen;
3272 		pIcon = new sal_uInt8[nIconLen];
3273 		pS->Read(pIcon,nIconLen);
3274 	}
3275 
3276 	if (nPicture)
3277 	{
3278 		pS->Read(pPictureHeader,20);
3279 		*pS >> nPictureLen;
3280 		pPicture = new sal_uInt8[nPictureLen];
3281 		pS->Read(pPicture,nPictureLen);
3282 	}
3283 
3284 	return sal_True;
3285 }
3286 
Read(SvStorageStream * pS)3287 sal_Bool OCX_Label::Read(SvStorageStream *pS)
3288 {
3289     long nStart = pS->Tell();
3290 	*pS >> nIdentifier;
3291 	DBG_ASSERT(nStandardId==nIdentifier,
3292 			"A control that has a different identifier");
3293 	*pS >> nFixedAreaLen;
3294 	pS->Read(pBlockFlags,4);
3295 
3296 
3297 	if (pBlockFlags[0] & 0x01)
3298 		*pS >> mnForeColor;
3299 	if (pBlockFlags[0] & 0x02)
3300 		*pS >> mnBackColor;
3301 
3302 
3303 	if (pBlockFlags[0] & 0x04)
3304 	{
3305 		sal_uInt8 nTemp;
3306 		*pS >> nTemp;
3307 		fEnabled = (nTemp&0x02)>>1;
3308 		fLocked = (nTemp&0x04)>>2;
3309 		fBackStyle = (nTemp&0x08)>>3;
3310 		*pS >> nTemp;
3311 		*pS >> nTemp;
3312 		fWordWrap = (nTemp&0x80)>>7;
3313 		*pS >> nTemp;
3314 		fAutoSize = (nTemp&0x10)>>4;
3315 	}
3316     bool bCaption = (pBlockFlags[0] & 0x08) != 0;
3317     if (bCaption)
3318 		*pS >> nCaptionLen;
3319 
3320 	if (pBlockFlags[0] & 0x10)
3321 	{
3322 		*pS >> nVertPos;
3323 		*pS >> nHorzPos;
3324 	}
3325 
3326 	if (pBlockFlags[0] & 0x40)
3327 		*pS >> nMousePointer;
3328 
3329 	if (pBlockFlags[0] & 0x80)
3330 	{
3331 		ReadAlign(pS,pS->Tell() - nStart, 4);
3332 		*pS >> nBorderColor;
3333 	}
3334 
3335 	if (pBlockFlags[1] & 0x01)
3336 	{
3337 		ReadAlign(pS, pS->Tell() - nStart, 2);
3338 		*pS >> nBorderStyle;
3339 	}
3340 
3341 	if (pBlockFlags[1] & 0x02)
3342 	{
3343 		ReadAlign(pS, pS->Tell() - nStart, 2);
3344 		*pS >> nSpecialEffect;
3345 	}
3346 
3347 	if (pBlockFlags[1] & 0x04)
3348 	{
3349 		ReadAlign(pS, pS->Tell() - nStart, 2);
3350 		*pS >> nPicture;
3351 	}
3352 
3353 	if (pBlockFlags[1] & 0x08)
3354 	{
3355 		ReadAlign(pS, pS->Tell() - nStart, 2);
3356 		*pS >> nAccelerator;
3357 	}
3358 
3359 	if (pBlockFlags[1] & 0x10)
3360 	{
3361 		ReadAlign(pS, pS->Tell() - nStart, 2);
3362 		*pS >> nIcon;
3363 	}
3364 
3365     if (bCaption)
3366         lclReadCharArray( *pS, pCaption, nCaptionLen, pS->Tell() - nStart);
3367 
3368     ReadAlign(pS, pS->Tell() - nStart, 4);
3369 	*pS >> nWidth;
3370 	*pS >> nHeight;
3371 
3372 	if (nPicture)
3373 	{
3374 		pS->Read(pPictureHeader,20);
3375 		*pS >> nPictureLen;
3376 		pPicture = new sal_uInt8[nPictureLen];
3377 		pS->Read(pPicture,nPictureLen);
3378 	}
3379     if (nIcon)
3380     {
3381         pS->Read(pIconHeader,20);
3382         *pS >> nIconLen;
3383         pIcon = new sal_uInt8[nIconLen];
3384         pS->Read(pIcon,nIconLen);
3385     }
3386 
3387 	return sal_True;
3388 }
3389 
TypeName(sal_Char * pName,sal_uInt32 nStoreId,sal_uInt32 nLen,sal_uInt16 nType,sal_Int32 nLeft,sal_Int32 nTop)3390 TypeName::TypeName(sal_Char *pName, sal_uInt32 nStoreId, sal_uInt32 nLen, sal_uInt16 nType, sal_Int32 nLeft,
3391     sal_Int32 nTop)
3392     : msName(lclCreateOUString(pName, nLen)), mnType(nType), mnLeft(nLeft),
3393     mnTop(nTop),mnStoreId(nStoreId)
3394 {
3395 }
3396 
OCX_ContainerControl(SotStorageRef & parent,const::rtl::OUString & storageName,const::rtl::OUString & sN,const uno::Reference<container::XNameContainer> & rParent,OCX_Control * pParent)3397 OCX_ContainerControl::OCX_ContainerControl( SotStorageRef& parent,
3398             const ::rtl::OUString& storageName,
3399             const ::rtl::OUString& sN,
3400             const uno::Reference< container::XNameContainer >  &rParent,
3401             OCX_Control* pParent ) :
3402                 OCX_Control(sN, pParent), rbGroupMgr( sName ), mxParent(rParent), nNoRecords(0), nTotalLen(0), containerType( STDCONTAINER )
3403 {
3404 
3405     mContainerStorage = parent->OpenSotStorage(storageName,
3406         STREAM_READWRITE |
3407         STREAM_NOCREATE |
3408         STREAM_SHARE_DENYALL);
3409     mContainerStream = mContainerStorage->OpenSotStream(
3410         String(RTL_CONSTASCII_STRINGPARAM("f"),
3411         RTL_TEXTENCODING_MS_1252),
3412         STREAM_STD_READ | STREAM_NOCREATE);
3413     mContainedControlsStream = mContainerStorage->OpenSotStream( String(RTL_CONSTASCII_STRINGPARAM("o"),
3414         RTL_TEXTENCODING_MS_1252),
3415         STREAM_STD_READ | STREAM_NOCREATE);
3416 }
~OCX_ContainerControl()3417 OCX_ContainerControl::~OCX_ContainerControl()
3418 {
3419     CtrlIterator aEnd = mpControls.end();
3420     for (CtrlIterator aIter = mpControls.begin(); aIter != aEnd; ++ aIter )
3421     {
3422         delete *aIter;
3423     }
3424 }
3425 
3426 // Really import should receive the parent e.g. a Userform, Frame or Multi Page
3427 // and call import on its containees with itself  ( up-called from
3428 // the base class ) but... the reality is we have no containment model
3429 // so we make sure rPropSet is always the parent Dialog
3430 
Import(uno::Reference<beans::XPropertySet> &)3431 sal_Bool OCX_ContainerControl::Import(uno::Reference<beans::XPropertySet>& /* rProps */ )
3432 {
3433     if ( !mxParent.is() )
3434     {
3435         return sal_False;
3436     }
3437     CtrlIterator aEnd = mpControls.end();
3438 //    int count = 0;
3439     for (CtrlIterator aIter = mpControls.begin(); aIter != aEnd; ++ aIter )
3440     {
3441         if ( !(*aIter)->Import( mxParent ) )
3442         {
3443             return sal_False;
3444         }
3445     }
3446     return sal_True;
3447 }
3448 
createSubStreamName(const sal_uInt32 & subStorageId)3449 OUString OCX_ContainerControl::createSubStreamName( const sal_uInt32& subStorageId )
3450 {
3451     static OUString sI = OUString::createFromAscii("i");
3452     static OUString sZero = OUString::createFromAscii( "0" );
3453     OUStringBuffer buf( 6 );
3454     buf.append( sI );
3455     // for subStorage id < 10 stream name has leading '0'
3456     // eg "i07"
3457     if ( subStorageId < 10 )
3458     {
3459         buf.append( sZero );
3460     }
3461     buf.append( OUString::valueOf( (sal_Int32)subStorageId ) );
3462     return buf.makeStringAndClear();
3463 }
3464 
createFromContainerRecord(const ContainerRecord & record,OCX_Control * & pControl)3465 bool OCX_ContainerControl::createFromContainerRecord( const ContainerRecord& record, OCX_Control*& pControl )
3466 {
3467     pControl = NULL;
3468     switch ( record.nTypeIdent)
3469         {
3470             case CMDBUTTON:
3471                 pControl = new OCX_CommandButton;
3472                 break;
3473             case LABEL:
3474                 pControl = new OCX_UserFormLabel(this);
3475                 break;
3476             case TEXTBOX:
3477                 pControl = new OCX_TextBox;
3478                 break;
3479             case LISTBOX:
3480                 pControl = new OCX_ListBox;
3481                 break;
3482             case COMBOBOX:
3483                 pControl = new OCX_ComboBox;
3484                 break;
3485             case CHECKBOX:
3486                 pControl =  new OCX_CheckBox;
3487                 break;
3488             case OPTIONBUTTON:
3489                 pControl = new OCX_OptionButton;
3490                 break;
3491             case TOGGLEBUTTON:
3492                 pControl = new OCX_ToggleButton;
3493                 break;
3494             case IMAGE: //Image
3495             {
3496                 pControl = new OCX_Image;
3497                 break;
3498             }
3499             case PAGE: // Page
3500             {
3501                 OUString sMSStore = createSubStreamName( record.nSubStorageId );
3502                 pControl = new OCX_Page(mContainerStorage, sMSStore,
3503                     record.cName, mxParent, this);
3504                 break;
3505             }
3506             case MULTIPAGE: // MultiPage
3507             {
3508                 OUString sMSStore = createSubStreamName( record.nSubStorageId );
3509                 pControl = new OCX_MultiPage( mContainerStorage, sMSStore,
3510                     record.cName, mxParent, this);
3511                 break;
3512             }
3513             case FRAME:  //Frame
3514             {
3515                 OUString sFrameStore = createSubStreamName( record.nSubStorageId );
3516                 pControl = new OCX_Frame(mContainerStorage, sFrameStore,
3517                     record.cName, mxParent, this);
3518 
3519                 break;
3520             }
3521             case SPINBUTTON: //SpinButton
3522             {
3523                 pControl = new OCX_SpinButton;
3524                 break;
3525             }
3526             case TABSTRIP: //TabStrip
3527             {
3528                 pControl = new OCX_TabStrip;
3529                 break;
3530             }
3531             case SCROLLBAR: //ScrollBar
3532                 pControl = new OCX_ScrollBar;
3533                 break;
3534             case PROGRESSBAR: //ProgressBar Active X control
3535                 pControl = new OCX_ProgressBar;
3536                 break;
3537             default:
3538                 OSL_TRACE( "**** Unknown control 0x%x", record.nTypeIdent );
3539                 DBG_ERROR( "Unknown control");
3540                 return false;
3541         }
3542         pControl->sName = record.cName;
3543         return true;
3544 }
3545 
3546 
addSeperator(std::vector<OCX_Control * > & dest)3547 void addSeperator( std::vector< OCX_Control* >& dest )
3548 {
3549     OCX_Control* seperator = new OCX_CommandButton;
3550     seperator->SetInDialog(true);
3551     seperator->sName = C2S("GroupSeperator");
3552     dest.push_back( seperator );
3553 }
3554 
addRButtons(std::vector<OCX_Control * > & src,std::vector<OCX_Control * > & dest,bool addGroupSeperator)3555 void addRButtons( std::vector< OCX_Control* >& src,
3556                   std::vector< OCX_Control* >& dest,
3557                   bool addGroupSeperator )
3558 {
3559     if ( addGroupSeperator )
3560     {
3561         addSeperator( dest );
3562     }
3563 
3564     for ( CtrlIterator rbIter = src.begin(); rbIter != src.end(); ++rbIter )
3565     {
3566         dest.push_back( *rbIter );
3567     }
3568 }
3569 
ProcessControl(OCX_Control * pControl,SvStorageStream *,ContainerRecord & rec)3570 void OCX_ContainerControl::ProcessControl(OCX_Control* pControl,SvStorageStream* /* pS */,  ContainerRecord& rec )
3571 {
3572     SotStorageStreamRef oStream = mContainedControlsStream;
3573 
3574     // can insert into OO Dialog (e.g is this a supported dialog control)??
3575     if ( rec.nTypeIdent == SPINBUTTON ||
3576         rec.nTypeIdent == TABSTRIP)
3577     {
3578         // skip the record in the stream, discard the control
3579         oStream->SeekRel( rec.nSubStreamLen );
3580         delete pControl;
3581     }
3582     else
3583     {
3584         // A container control needs to read the f stream in
3585         // the folder ( substorage ) associated with this control
3586         if (  rec.nTypeIdent ==  FRAME ||
3587             rec.nTypeIdent ==  MULTIPAGE||
3588             rec.nTypeIdent ==  PAGE )
3589         {
3590             OCX_ContainerControl* pContainer =
3591                static_cast< OCX_ContainerControl* >( pControl );
3592             oStream = pContainer->getContainerStream();
3593         }
3594 
3595         pControl->sName = rec.cName;
3596         pControl->msToolTip = rec.controlTip;
3597         // Position of controls is relative to the container
3598         pControl->mnTop = rec.nTop + mnTop;
3599         pControl->mnLeft = rec.nLeft + mnLeft;
3600         // MS tabIndex, pretty useless in OpenOffice land
3601         // as tab indexes in MS are relative to parent container.
3602         // However we need this value in order to set
3603         // OpenOffice tab indices in a sensible way to
3604         // reflect the ms tabbing from orig MS UserForm, see below
3605         pControl->mnTabPos = rec.nTabPos;
3606         pControl->SetInDialog(true);
3607         pControl->mbVisible = rec.bVisible;
3608         if ( mnStep )
3609         {
3610             // If the container has a step then it should be
3611             // applied to all containees
3612             pControl->mnStep = mnStep;
3613         }
3614 
3615         // #117490# DR: container records provide size of substream, use it here...
3616 
3617         // remember initial position to set correct stream position
3618         sal_uLong nStrmPos = oStream->Tell();
3619         // import control, may return with invalid stream position
3620         pControl->FullRead(oStream);
3621         // set stream to position behind substream of this control
3622         oStream->Seek( nStrmPos + rec.nSubStreamLen );
3623 
3624         //need to fake grouping behaviour for radio ( option ) buttons
3625         if ( rec.nTypeIdent == OPTIONBUTTON )
3626         {
3627             OCX_OptionButton* pRButton =
3628                 static_cast< OCX_OptionButton*>(pControl);
3629             rbGroupMgr.addRadioButton( pRButton );
3630         }
3631         else
3632         {
3633             mpControls.push_back( pControl );
3634         }
3635     }
3636 }
3637 
Read(SvStorageStream * pS)3638 sal_Bool OCX_ContainerControl::Read(SvStorageStream *pS)
3639 {
3640 
3641     if ( mpParent )
3642     {
3643         mnBackColor = mpParent->mnBackColor;
3644     }
3645 
3646     std::auto_ptr< ContainerRecReader > reader (
3647         ContainerRecordReaderFac::instance( containerType ) );
3648 
3649     reader->Read( this, pS );
3650     // Need to honour the MS Tab Indexes. However MS tab indexes are
3651     // relative to parent, this hack sorts the controls in each container
3652     // based on the ms tab indexes. When import is called we create the
3653     // controls in Open/Star office based on the order of the tab indexes,
3654     // this ensures that the default tab index created by Star/Open office
3655     // reflects the "flattened" ms tab order.
3656     ::std::sort( mpControls.begin(), mpControls.end(), SortOrderByTabPos() );
3657     mpControls = rbGroupMgr.insertGroupsIntoControlList( mpControls );
3658 	return true;
3659 }
3660 
OCX_MultiPage(SotStorageRef & parent,const::rtl::OUString & storageName,const::rtl::OUString & sN,const uno::Reference<container::XNameContainer> & rDialog,OCX_Control * pParent)3661 OCX_MultiPage::OCX_MultiPage( SotStorageRef& parent,
3662             const ::rtl::OUString& storageName,
3663             const ::rtl::OUString& sN,
3664             const uno::Reference< container::XNameContainer >  &rDialog,
3665             OCX_Control* pParent):
3666 		OCX_ContainerControl(parent, storageName, sN, rDialog, pParent ), fUnknown1(0), fEnabled(1),
3667         fLocked(0), fBackStyle(1), fWordWrap(1), fAutoSize(0), nCaptionLen(0),
3668         nVertPos(1), nHorzPos(7), nMousePointer(0), nBorderColor(0x80000012),
3669 		nKeepScrollBarsVisible(3), nCycle(0), nBorderStyle(0), nSpecialEffect(0),
3670 		nPicture(0), nPictureAlignment(2), nPictureSizeMode(0),
3671 		bPictureTiling(sal_False), nAccelerator(0), nIcon(0), pCaption(0),
3672 		nScrollWidth(0), nScrollHeight(0), nIconLen(0), pIcon(0), nPictureLen(0),
3673 		pPicture(0)
3674 {
3675     msDialogType = C2U("NotSupported");
3676     mnForeColor = 0x80000012L,
3677     mnBackColor = 0x8000000FL;
3678     bSetInDialog = true;// UserForm control only
3679     aFontData.SetHasAlign(sal_True);
3680     containerType = MULTIPAGE;
3681     mnCurrentPageStep = 0;
3682 }
3683 
ProcessControl(OCX_Control * pControl,SvStorageStream *,ContainerRecord & rec)3684 void OCX_MultiPage::ProcessControl(OCX_Control* pControl, SvStorageStream* /* pS */,  ContainerRecord& rec )
3685 {
3686     SotStorageStreamRef oStream = mContainedControlsStream;
3687 
3688     OCX_Page *pPage = NULL;
3689     if ( rec.nTypeIdent == PAGE )
3690         pPage = static_cast< OCX_Page* >( pControl );
3691     if ( pPage != NULL )
3692     {
3693         pPage->mnStep = ++mnCurrentPageStep;
3694 
3695         pPage->mnTop =  mnTop;// move these to Page::import ?
3696         pPage->mnLeft = mnLeft;
3697         pPage->mnBackColor = mnBackColor;
3698 
3699         oStream = pPage->getContainerStream();;
3700         // Position of controls is relative to pos of this MuliPage
3701         // Control
3702         pPage->FullRead( oStream );
3703 
3704         mpControls.push_back( pPage );
3705     }
3706     else
3707     {
3708         OSL_TRACE("!!!! Unsupported Control 0x%x ", rec.nTypeIdent);
3709         DBG_ERROR("MultiPage error expected Page control");
3710     }
3711 
3712 }
3713 
Read(SvStorageStream * pS)3714 sal_Bool OCX_MultiPage::Read(SvStorageStream *pS)
3715 {
3716     // Unlike the other containers e.g. UserForm & Frame
3717     // the o stream is does not contain info for the contained controls
3718     // ( e.g. the pages themselves ) but seems to be for the MultiPage
3719     // itself - need to check this in more detail
3720 
3721     // For the moment skip read of the MultiPage specific properties
3722     // not much point reading these as we can't display the multi page
3723     // control or in fact any sort of tabbed layout, best we can do is
3724     // import just the contained controls of the individual pages
3725     // Note: the record skipped below ( does not contain the expected
3726     // info on this control, that seems to be contained in the o stream,
3727     // see comment above)
3728     OCX_Control skip(C2S("Dummy"));
3729     skip.Read( pS );
3730     mnCurrentPageStep = mnStep; //( set step of of pages relative to step
3731                                 //of this MultiPage ( e.g. emulate containment )
3732     return OCX_ContainerControl::Read(pS);
3733 }
3734 
3735 
Import(com::sun::star::uno::Reference<com::sun::star::beans::XPropertySet> & rPropSet)3736 sal_Bool OCX_MultiPage::Import(com::sun::star::uno::Reference<
3737     com::sun::star::beans::XPropertySet> &rPropSet)
3738 {
3739     // Calls import on contained controls
3740     OCX_ContainerControl::Import( rPropSet );
3741     return sal_True;
3742 }
3743 
Import(com::sun::star::uno::Reference<com::sun::star::container::XNameContainer> & rDialog)3744 sal_Bool OCX_MultiPage::Import(com::sun::star::uno::Reference<
3745 		com::sun::star::container::XNameContainer>
3746 		&rDialog)
3747 {
3748     uno::Reference<beans::XPropertySet> xPropSet( rDialog, uno::UNO_QUERY );
3749 
3750     // Although MultiPage is not represeted by a "real" control we still
3751     // need to propagate the backcolor of this logical parent
3752     // ( the dialog or Frame or whatever ) to the children of this control.
3753     // For example the controls contained in the Page of a
3754     // MultiPage control use the parents backcolor ( e,g,
3755     // Pages backcolor ) when trying to fake transparency
3756     mnBackColor = mpParent->mnBackColor;
3757 
3758     if ( xPropSet.is() )
3759     {
3760         // Calls import on contained pages
3761         return OCX_ContainerControl::Import( xPropSet );
3762     }
3763     OSL_TRACE("*** Major problem, no dialog to add controls to ");
3764     DBG_ERROR(" Major problem, no dialog to add controls to ");
3765     return false;
3766 }
3767 
3768 
3769 
OCX_Page(SotStorageRef & parent,const::rtl::OUString & storageName,const::rtl::OUString & sN,const uno::Reference<container::XNameContainer> & rDialog,OCX_Control * pParent)3770 OCX_Page::OCX_Page( SotStorageRef& parent,
3771             const ::rtl::OUString& storageName,
3772             const ::rtl::OUString& sN,
3773             const uno::Reference< container::XNameContainer >  &rDialog,
3774             OCX_Control* pParent):
3775 		OCX_ContainerControl(parent, storageName, sN, rDialog, pParent ),
3776         fUnknown1(0), fEnabled(1), fLocked(0),
3777 		fBackStyle(1), fWordWrap(1), fAutoSize(0), nCaptionLen(0), nVertPos(1),
3778 		nHorzPos(7), nMousePointer(0), nBorderColor(0x80000012),
3779 		nKeepScrollBarsVisible(3), nCycle(0), nBorderStyle(0), nSpecialEffect(0),
3780 		nPicture(0), nPictureAlignment(2), nPictureSizeMode(0),
3781 		bPictureTiling(sal_False), nAccelerator(0), nIcon(0), pCaption(0),
3782 		nScrollWidth(0), nScrollHeight(0), nIconLen(0), pIcon(0), nPictureLen(0),
3783 		pPicture(0)
3784 {
3785     msDialogType = C2U("NotSupported");
3786     mnForeColor = 0x80000012,
3787 	mnBackColor = 0x8000000F,
3788     bSetInDialog = true;// UserForm control only
3789     aFontData.SetHasAlign(sal_True);
3790 }
3791 
3792 
Read(SvStorageStream * pS)3793 sal_Bool OCX_Page::Read(SvStorageStream *pS)
3794 {
3795     long nStart = pS->Tell();
3796 	*pS >> nIdentifier;
3797 	DBG_ASSERT(0x400==nIdentifier,
3798 			"A control that has a different identifier");
3799 	*pS >> nFixedAreaLen;
3800 	pS->Read(pBlockFlags,4);
3801 
3802     pS->SeekRel( nFixedAreaLen - sizeof( pBlockFlags ) );
3803 
3804     ReadAlign( pS, pS->Tell() - nStart, 4);
3805 
3806     if (pBlockFlags[2] & 0x10)
3807     {
3808         //Font Stuff..
3809         pS->SeekRel(0x1a);
3810         sal_uInt8 nFontLen;
3811         *pS >> nFontLen;
3812         pS->SeekRel(nFontLen);
3813     }
3814     return OCX_ContainerControl::Read(pS);
3815 
3816 }
3817 
Import(com::sun::star::uno::Reference<com::sun::star::container::XNameContainer> & rDialog)3818 sal_Bool OCX_Page::Import(com::sun::star::uno::Reference<
3819 		com::sun::star::container::XNameContainer>
3820 		&rDialog)
3821 {
3822 
3823     uno::Reference<beans::XPropertySet> xPropSet( rDialog, uno::UNO_QUERY );
3824     if ( xPropSet.is() )
3825     {
3826         // apply Step to contained controls
3827         CtrlIterator aEnd = mpControls.end();
3828         for (CtrlIterator aIter = mpControls.begin(); aIter != aEnd; ++ aIter )
3829         {
3830             (*aIter)->mnStep = mnStep;
3831         }
3832         // Calls import on contained pages
3833         return OCX_ContainerControl::Import( xPropSet );
3834     }
3835     OSL_TRACE("*** Major problem, no dialog to add controls to ");
3836     DBG_ERROR("*** Major problem, no dialog to add controls to ");
3837     return sal_False;
3838 }
3839 
OCX_Frame(SotStorageRef & parent,const::rtl::OUString & storageName,const::rtl::OUString & sN,const uno::Reference<container::XNameContainer> & rDialog,OCX_Control * pParent)3840 OCX_Frame::OCX_Frame( SotStorageRef& parent,
3841             const ::rtl::OUString& storageName,
3842             const ::rtl::OUString& sN,
3843             const uno::Reference< container::XNameContainer >  &rDialog, OCX_Control* pParent):
3844 		OCX_ContainerControl(parent, storageName, sN, rDialog, pParent ),fUnknown1(0),fEnabled(1), fLocked(0),
3845 		fBackStyle(1), fWordWrap(1), fAutoSize(0), nCaptionLen(0), nVertPos(1),
3846 		nHorzPos(7), nMousePointer(0), nBorderColor(0x80000012),
3847 		nKeepScrollBarsVisible(3), nCycle(0), nBorderStyle(0), nSpecialEffect(0),
3848 		nPicture(0), nPictureAlignment(2), nPictureSizeMode(0),
3849 		bPictureTiling(sal_False), nAccelerator(0), nIcon(0), pCaption(0),
3850 		nScrollWidth(0), nScrollHeight(0), nScrollLeft(0), nScrollTop(0), nIconLen(0), pIcon(0), nPictureLen(0),
3851 		pPicture(0)
3852 {
3853     msDialogType = C2U("com.sun.star.awt.UnoControlGroupBoxModel");
3854     mnForeColor = 0x80000012;
3855 	mnBackColor = 0x8000000F;
3856     bSetInDialog = true;// UserForm control only
3857     aFontData.SetHasAlign(sal_True);
3858 }
3859 
3860 
Read(SvStorageStream * pS)3861 sal_Bool OCX_Frame::Read(SvStorageStream *pS)
3862 {
3863     long nStart = pS->Tell();
3864 	*pS >> nIdentifier;
3865 	DBG_ASSERT(0x400==nIdentifier,
3866 			"A control that has a different identifier");
3867 	*pS >> nFixedAreaLen;
3868 	pS->Read(pBlockFlags,4);
3869 
3870 	if (pBlockFlags[0] & 0x01)
3871     {
3872             DBG_ASSERT(sal_False, "ARSE");
3873     }
3874 	if (pBlockFlags[0] & 0x02)
3875             *pS >> mnBackColor;
3876 	if (pBlockFlags[0] & 0x04)
3877             *pS >> mnForeColor;
3878     if (pBlockFlags[0] & 0x08)
3879         *pS >> fUnknown1;
3880     if (pBlockFlags[0] & 0x40)
3881 	{
3882 		sal_uInt8 nTemp;
3883 		*pS >> nTemp;
3884 		fEnabled = (nTemp&0x04)>>2;
3885 		fBackStyle = (nTemp&0x08)>>3;
3886 		*pS >> nTemp;
3887 		*pS >> nTemp;
3888 		fWordWrap = (nTemp&0x80)>>7;
3889 		*pS >> nTemp;
3890 		fAutoSize = (nTemp&0x10)>>4;
3891     }
3892     if (pBlockFlags[0] & 0x80)
3893     {
3894         *pS >> nBorderStyle;
3895     }
3896 
3897     ReadAlign(pS, pS->Tell() - nStart, 4);
3898 
3899     if (pBlockFlags[1] & 0x01)
3900 		*pS >> nMousePointer;
3901     if (pBlockFlags[1] & 0x02)
3902         *pS >> nKeepScrollBarsVisible;
3903     if (pBlockFlags[1] & 0x20)
3904         *pS >> fUnknown1; // another unknown 32 bit ( or is 8 or 16 bit with padding ? )
3905 
3906     if (pBlockFlags[1] & 0x80)
3907     {
3908         ReadAlign(pS, pS->Tell() - nStart, 2);
3909         *pS >> nIcon;
3910         DBG_ASSERT(nIcon == 0xFFFF, "Unexpected nIcon");
3911     }
3912 
3913     bool bCaption = false;
3914 
3915     if (pBlockFlags[2] & 0x01)
3916         *pS >> nCycle;
3917     if (pBlockFlags[2] & 0x02)
3918 		*pS >> nSpecialEffect;
3919 
3920 	if (pBlockFlags[2] & 0x04)
3921 	{
3922 		ReadAlign(pS, pS->Tell() - nStart, 4);
3923 		*pS >> nBorderColor;
3924 	}
3925 
3926     if (pBlockFlags[2] & 0x08)
3927 	{
3928         ReadAlign(pS, pS->Tell() - nStart, 4);
3929 		*pS >> nCaptionLen;
3930         bCaption = true;
3931 	}
3932 
3933     if (pBlockFlags[2] & 0x10)
3934 	{
3935         ReadAlign(pS, pS->Tell() - nStart, 2);
3936         sal_uInt16 nNoIdea;
3937         *pS >> nNoIdea;
3938         DBG_ASSERT(nNoIdea == 0xFFFF, "Expected 0xFFFF, (related to font ?)");
3939 	}
3940 
3941     if (pBlockFlags[2] & 0x20)
3942 	{
3943         ReadAlign(pS, pS->Tell() - nStart, 2);
3944         *pS >> nPicture;
3945         DBG_ASSERT(nPicture == 0xFFFF, "Unexpected nIcon");
3946 	}
3947 
3948     if (pBlockFlags[2] & 0x80)
3949         *pS >> nPictureAlignment;
3950 
3951     if (pBlockFlags[3] & 0x01)
3952         bPictureTiling = true;
3953 
3954     if (pBlockFlags[3] & 0x02)
3955         *pS >> nPictureSizeMode;
3956 
3957     if (pBlockFlags[3] & 0x04)
3958     {
3959         ReadAlign(pS, pS->Tell() - nStart, 4);
3960         *pS >> fUnknown8;
3961     }
3962 
3963     if (pBlockFlags[3] & 0x08)
3964     {
3965         ReadAlign(pS, pS->Tell() - nStart, 4);
3966         *pS >> fUnknown9;
3967     }
3968 
3969     ReadAlign(pS, pS->Tell() - nStart, 4);
3970 	*pS >> nWidth;
3971 	*pS >> nHeight;
3972     *pS >> nScrollWidth;
3973     *pS >> nScrollHeight;
3974 
3975     if (pBlockFlags[1] & 0x10)
3976     {
3977         *pS >> nScrollLeft;
3978         *pS >> nScrollTop;
3979     }
3980 
3981     if ( bCaption )
3982     {
3983         lclReadCharArray( *pS, pCaption, nCaptionLen, pS->Tell() - nStart);
3984     }
3985 
3986     OUString tempCaption =  lclCreateOUString( pCaption, nCaptionLen );
3987 
3988 	if (nIcon)
3989 	{
3990 		pS->Read(pIconHeader,20);
3991 		*pS >> nIconLen;
3992 		pIcon = new sal_uInt8[nIconLen];
3993 		pS->Read(pIcon,nIconLen);
3994 	}
3995 
3996 	if (nPicture)
3997 	{
3998 		pS->Read(pPictureHeader,20);
3999 		*pS >> nPictureLen;
4000 		pPicture = new sal_uInt8[nPictureLen];
4001 		pS->Read(pPicture,nPictureLen);
4002 	}
4003 
4004     ReadAlign( pS, pS->Tell() - nStart, 4);
4005 
4006     if (pBlockFlags[2] & 0x10)
4007     {
4008         //Font Stuff..
4009         pS->SeekRel(0x1a);
4010         sal_uInt8 nFontLen;
4011         *pS >> nFontLen;
4012         pS->SeekRel(nFontLen);
4013     }
4014 
4015 	return OCX_ContainerControl::Read( pS );
4016 }
4017 
Import(com::sun::star::uno::Reference<com::sun::star::beans::XPropertySet> & rPropSet)4018 sal_Bool OCX_Frame::Import(com::sun::star::uno::Reference<
4019     com::sun::star::beans::XPropertySet> &rPropSet)
4020 {
4021     uno::Any aTmp(&sName,getCppuType((OUString *)0));
4022     rPropSet->setPropertyValue(
4023         OUString(RTL_CONSTASCII_USTRINGPARAM("Name")), aTmp);
4024     if ( pCaption )
4025     {
4026         aTmp <<= lclCreateOUString( pCaption, nCaptionLen );
4027 		rPropSet->setPropertyValue( WW8_ASCII2STR("Label"), aTmp);
4028     }
4029 
4030     // Calls import on contained controls
4031     OCX_ContainerControl::Import( rPropSet );
4032     return sal_True;
4033 }
OCX_UserForm(SotStorageRef & parent,const OUString & storageName,const OUString & sN,const::uno::Reference<container::XNameContainer> & rDialog,const::uno::Reference<lang::XMultiServiceFactory> & rMsf)4034 OCX_UserForm::OCX_UserForm( SotStorageRef& parent,
4035             const OUString& storageName,
4036             const OUString& sN,
4037             const ::uno::Reference< container::XNameContainer >  &rDialog,
4038             const ::uno::Reference< lang::XMultiServiceFactory >& rMsf):
4039 		OCX_ContainerControl(parent, storageName, sN, rDialog),
4040         nChildrenA(0), fEnabled(1), fLocked(0),
4041 		fBackStyle(1), fWordWrap(1), fAutoSize(0), nCaptionLen(0), nVertPos(1),
4042 		nHorzPos(7), nMousePointer(0), nBorderColor(0x80000012), nChildrenB(0),
4043 		nKeepScrollBarsVisible(3), nCycle(0), nBorderStyle(0), nSpecialEffect(0),
4044 		nPicture(0), nPictureAlignment(2), nPictureSizeMode(0),
4045 		bPictureTiling(sal_False), nAccelerator(0), nIcon(0), pCaption(0),
4046 		nScrollWidth(0), nScrollHeight(0), nScrollLeft(0), nScrollTop(0), nIconLen(0), pIcon(0), nPictureLen(0),
4047 		pPicture(0)
4048 	{
4049             mnForeColor = 0x80000012;
4050 		    mnBackColor = 0x8000000F;
4051             uno::Reference< beans::XPropertySet> xProps( rMsf, uno::UNO_QUERY);
4052             if ( xProps.is() )
4053             {
4054                 xProps->getPropertyValue(C2S("DefaultContext"))  >>= mxCtx;
4055             }
4056             aFontData.SetHasAlign(sal_True);
4057         }
Read(SvStorageStream * pS)4058 sal_Bool OCX_UserForm::Read(SvStorageStream *pS)
4059 {
4060     long nStart = pS->Tell();
4061 	*pS >> nIdentifier;
4062 	DBG_ASSERT(0x400==nIdentifier,
4063 			"A control that has a different identifier");
4064 	*pS >> nFixedAreaLen;
4065 	pS->Read(pBlockFlags,4);
4066 
4067 	if (pBlockFlags[0] & 0x01)
4068     {
4069             DBG_ASSERT(sal_False, "ARSE");
4070     }
4071 	if (pBlockFlags[0] & 0x02)
4072 		*pS >> mnBackColor;
4073 	if (pBlockFlags[0] & 0x04)
4074         *pS >> mnForeColor;
4075     if (pBlockFlags[0] & 0x08)
4076         *pS >> nChildrenA;
4077     if (pBlockFlags[0] & 0x40)
4078 	{
4079 		sal_uInt8 nTemp;
4080 		*pS >> nTemp;
4081 		fEnabled = (nTemp&0x04)>>2;
4082 		fBackStyle = (nTemp&0x08)>>3;
4083 		*pS >> nTemp;
4084 		*pS >> nTemp;
4085 		fWordWrap = (nTemp&0x80)>>7;
4086 		*pS >> nTemp;
4087 		fAutoSize = (nTemp&0x10)>>4;
4088     }
4089     if (pBlockFlags[0] & 0x80)
4090     {
4091         ReadAlign(pS, pS->Tell() - nStart, 4);
4092         *pS >> nBorderStyle;
4093     }
4094 #if 0
4095         sal_uInt16 nFixedOrAlign;
4096         *pS >> nFixedOrAlign;
4097 #endif
4098     if (pBlockFlags[1] & 0x01)
4099 		*pS >> nMousePointer;
4100     if (pBlockFlags[1] & 0x02)
4101         *pS >> nKeepScrollBarsVisible;
4102     if (pBlockFlags[1] & 0x20)
4103     {
4104         sal_uInt32 nUnknown32;
4105         *pS >> nUnknown32;
4106     }
4107     if (pBlockFlags[1] & 0x80)
4108     {
4109         ReadAlign(pS, pS->Tell() - nStart, 2);
4110         *pS >> nIcon;
4111         DBG_ASSERT(nIcon == 0xFFFF, "Unexpected nIcon");
4112     }
4113     if (pBlockFlags[2] & 0x01)
4114         *pS >> nCycle;
4115     if (pBlockFlags[2] & 0x02)
4116 		*pS >> nSpecialEffect;
4117 
4118 	if (pBlockFlags[2] & 0x04)
4119 	{
4120 		ReadAlign(pS, pS->Tell() - nStart, 4);
4121 		*pS >> nBorderColor;
4122 	}
4123 
4124     if (pBlockFlags[2] & 0x10)
4125 	{
4126         ReadAlign(pS, pS->Tell() - nStart, 2);
4127         sal_uInt16 nNoIdea;
4128         *pS >> nNoIdea;
4129         DBG_ASSERT(nNoIdea == 0xFFFF, "Expected 0xFFFF, (related to font ?)");
4130 	}
4131 
4132     if (pBlockFlags[2] & 0x20)
4133 	{
4134         ReadAlign(pS, pS->Tell() - nStart, 2);
4135         *pS >> nPicture;
4136         DBG_ASSERT(nPicture == 0xFFFF, "Unexpected nIcon");
4137 	}
4138 
4139     if (pBlockFlags[2] & 0x80)
4140         *pS >> nPictureAlignment;
4141 
4142     if (pBlockFlags[3] & 0x01)
4143         bPictureTiling = true;
4144 
4145     if (pBlockFlags[3] & 0x02)
4146         *pS >> nPictureSizeMode;
4147 
4148     if (pBlockFlags[3] & 0x04)
4149     {
4150         ReadAlign(pS, pS->Tell() - nStart, 4);
4151         *pS >> nChildrenB;
4152     }
4153 
4154     ReadAlign(pS, pS->Tell() - nStart, 4);
4155     *pS >> nDrawBuffer;
4156 
4157     ReadAlign(pS, pS->Tell() - nStart, 4);
4158 	*pS >> nWidth;
4159 	*pS >> nHeight;
4160     *pS >> nScrollWidth;
4161     *pS >> nScrollHeight;
4162 
4163     if (pBlockFlags[1] & 0x10)
4164     {
4165         *pS >> nScrollLeft;
4166         *pS >> nScrollTop;
4167     }
4168 
4169 	if (nIcon)
4170 	{
4171 		pS->Read(pIconHeader,20);
4172 		*pS >> nIconLen;
4173 		pIcon = new sal_uInt8[nIconLen];
4174 		pS->Read(pIcon,nIconLen);
4175 	}
4176 
4177 	if (nPicture)
4178 	{
4179 		pS->Read(pPictureHeader,20);
4180 		*pS >> nPictureLen;
4181 		pPicture = new sal_uInt8[nPictureLen];
4182 		pS->Read(pPicture,nPictureLen);
4183 	}
4184 
4185     ReadAlign( pS, pS->Tell() - nStart, 4);
4186 
4187     if (pBlockFlags[2] & 0x10)
4188     {
4189         //Font Stuff..
4190         pS->SeekRel(0x1a);
4191         sal_uInt8 nFontLen;
4192         *pS >> nFontLen;
4193         pS->SeekRel(nFontLen);
4194     }
4195 
4196     sal_Int16 numTrailingRecs = 0;
4197     *pS >> numTrailingRecs;
4198     // seems to be no. of trailing records,
4199     // before container record starts proper
4200     // ( unknown what these trailing records are for)
4201     if ( numTrailingRecs )
4202     {
4203         for ( ; numTrailingRecs ; --numTrailingRecs )
4204         {
4205             OCX_Control skip(C2S("dummy")) ;
4206             skip.Read( pS );
4207         }
4208     }
4209 	return OCX_ContainerControl::Read( pS );
4210 }
4211 
Import(uno::Reference<container::XNameContainer> & rLib)4212 sal_Bool OCX_UserForm::Import(
4213     uno::Reference<container::XNameContainer> &rLib )
4214 {
4215     uno::Reference<beans::XPropertySet>
4216         xDialogPropSet(mxParent, uno::UNO_QUERY);
4217     uno::Any aTmp(&sName,getCppuType((OUString *)0));
4218     xDialogPropSet->setPropertyValue(
4219         OUString(RTL_CONSTASCII_USTRINGPARAM("Name")), aTmp);
4220     xDialogPropSet->setPropertyValue(
4221         OUString(RTL_CONSTASCII_USTRINGPARAM("Title")), aTmp);
4222     aTmp <<= ImportColor(mnBackColor);
4223 	xDialogPropSet->setPropertyValue( WW8_ASCII2STR("BackgroundColor"), aTmp);
4224 
4225     aTmp <<= sal_Int32((nWidth * 2) / 100);
4226     xDialogPropSet->setPropertyValue(WW8_ASCII2STR("Width"), aTmp);
4227     aTmp <<= sal_Int32((nHeight * 2) / 100);
4228     xDialogPropSet->setPropertyValue(WW8_ASCII2STR("Height"), aTmp);
4229 
4230     uno::Reference<beans::XPropertySet> xPropSet( mxParent, uno::UNO_QUERY );
4231     OCX_ContainerControl::Import( xPropSet );
4232 
4233     uno::Reference<io::XInputStreamProvider> xSource =
4234         xmlscript::exportDialogModel(mxParent, mxCtx);
4235     uno::Any aSourceAny(uno::makeAny(xSource));
4236     if (rLib->hasByName(sName))
4237         rLib->replaceByName(sName, aSourceAny);
4238     else
4239         rLib->insertByName(sName, aSourceAny);
4240     return sal_True;
4241 }
4242 
WriteContents(SvStorageStreamRef & rContents,const uno::Reference<beans::XPropertySet> & rPropSet,const awt::Size & rSize)4243 sal_Bool OCX_Label::WriteContents(SvStorageStreamRef &rContents,
4244 	const uno::Reference< beans::XPropertySet > &rPropSet,
4245 	const awt::Size &rSize)
4246 {
4247 	sal_Bool bRet = sal_True;
4248     sal_uInt32 nOldPos = rContents->Tell();
4249 	rContents->SeekRel(8);
4250 	pBlockFlags[0] = 0x20;
4251 	pBlockFlags[1] = 0;
4252 	pBlockFlags[2] = 0;
4253 	pBlockFlags[3] = 0;
4254 
4255 	uno::Any aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("TextColor"));
4256     if (aTmp.hasValue())
4257 	    aTmp >>= mnForeColor;
4258 	*rContents << ExportColor(mnForeColor);
4259 	pBlockFlags[0] |= 0x01;
4260 
4261 	aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("BackgroundColor"));
4262     if (aTmp.hasValue())
4263 	    aTmp >>= mnBackColor;
4264 	*rContents << ExportColor(mnBackColor);
4265 	pBlockFlags[0] |= 0x02;
4266 
4267 	aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("Enabled"));
4268 	fEnabled = any2bool(aTmp);
4269 	sal_uInt8 nTemp=fEnabled;
4270 	if (fEnabled)
4271 		nTemp = nTemp << 1;
4272 	*rContents << nTemp;
4273 	*rContents << sal_uInt8(0x00);
4274 
4275 	aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("MultiLine"));
4276 	fWordWrap = any2bool(aTmp);
4277 	nTemp=fWordWrap;
4278 	nTemp = nTemp << 7;
4279 	*rContents << nTemp;
4280 	*rContents << sal_uInt8(0x00);
4281 	pBlockFlags[0] |= 0x04;
4282 
4283     SvxOcxString aCaption( rPropSet->getPropertyValue(WW8_ASCII2STR("Label")) );
4284     aCaption.WriteLenField( *rContents );
4285     if (aCaption.HasData())
4286 		pBlockFlags[0] |= 0x08;
4287 
4288     WriteAlign(rContents,4);
4289     aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("BorderColor"));
4290     if (aTmp.hasValue())
4291         aTmp >>= nBorderColor;
4292     *rContents << ExportColor(nBorderColor);
4293     pBlockFlags[0] |= 0x80;
4294 
4295 	aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("Border"));
4296 	sal_Int16 nBorder = sal_Int16();
4297 	aTmp >>= nBorder;
4298 	sal_uInt8 nNewBorder;
4299 	nSpecialEffect = ExportBorder(nBorder,nNewBorder);
4300 	nBorderStyle = nNewBorder;
4301 	*rContents << nBorderStyle;
4302 	pBlockFlags[1] |= 0x01;
4303 	*rContents << nSpecialEffect;
4304 	pBlockFlags[1] |= 0x02;
4305 
4306     aCaption.WriteCharArray( *rContents );
4307 
4308 	WriteAlign(rContents,4);
4309 	*rContents << rSize.Width;
4310 	*rContents << rSize.Height;
4311     nFixedAreaLen = static_cast<sal_uInt16>(rContents->Tell()-nOldPos-4);
4312 
4313 	bRet = aFontData.Export(rContents,rPropSet);
4314 
4315     rContents->Seek(nOldPos);
4316 	*rContents << nStandardId;
4317 	*rContents << nFixedAreaLen;
4318 
4319 	*rContents << pBlockFlags[0];
4320 	*rContents << pBlockFlags[1];
4321 	*rContents << pBlockFlags[2];
4322 	*rContents << pBlockFlags[3];
4323 
4324 	DBG_ASSERT((rContents.Is() &&
4325 		(SVSTREAM_OK==rContents->GetError())),"damn");
4326 	return bRet;
4327 }
4328 
4329 
4330 
Export(SvStorageRef & rObj,const uno::Reference<beans::XPropertySet> & rPropSet,const awt::Size & rSize)4331 sal_Bool OCX_Label::Export(SvStorageRef &rObj,
4332 	const uno::Reference< beans::XPropertySet > &rPropSet,
4333 	const awt::Size &rSize)
4334 {
4335 	static sal_uInt8 __READONLY_DATA aCompObj[] = {
4336 		0x01, 0x00, 0xFE, 0xFF, 0x03, 0x0A, 0x00, 0x00,
4337 		0xFF, 0xFF, 0xFF, 0xFF, 0x23, 0x9E, 0x8C, 0x97,
4338 		0xB0, 0xD4, 0xCE, 0x11, 0xBF, 0x2D, 0x00, 0xAA,
4339 		0x00, 0x3F, 0x40, 0xD0, 0x1A, 0x00, 0x00, 0x00,
4340 		0x4D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66,
4341 		0x74, 0x20, 0x46, 0x6F, 0x72, 0x6D, 0x73, 0x20,
4342 		0x32, 0x2E, 0x30, 0x20, 0x4C, 0x61, 0x62, 0x65,
4343 		0x6C, 0x00, 0x10, 0x00, 0x00, 0x00, 0x45, 0x6D,
4344 		0x62, 0x65, 0x64, 0x64, 0x65, 0x64, 0x20, 0x4F,
4345 		0x62, 0x6A, 0x65, 0x63, 0x74, 0x00, 0x0E, 0x00,
4346 		0x00, 0x00, 0x46, 0x6F, 0x72, 0x6D, 0x73, 0x2E,
4347 		0x4C, 0x61, 0x62, 0x65, 0x6C, 0x2E, 0x31, 0x00,
4348 		0xF4, 0x39, 0xB2, 0x71, 0x00, 0x00, 0x00, 0x00,
4349 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
4350 		};
4351 
4352 	{
4353 	SvStorageStreamRef xStor( rObj->OpenSotStream( C2S("\1CompObj")));
4354 	xStor->Write(aCompObj,sizeof(aCompObj));
4355 	DBG_ASSERT((xStor.Is() && (SVSTREAM_OK == xStor->GetError())),"damn");
4356 	}
4357 
4358 	{
4359 	SvStorageStreamRef xStor3( rObj->OpenSotStream( C2S("\3ObjInfo")));
4360 	xStor3->Write(aObjInfo,sizeof(aObjInfo));
4361 	DBG_ASSERT((xStor3.Is() && (SVSTREAM_OK == xStor3->GetError())),"damn");
4362 	}
4363 
4364 	static sal_uInt8 __READONLY_DATA aOCXNAME[] = {
4365 		0x4C, 0x00, 0x61, 0x00, 0x62, 0x00, 0x65, 0x00,
4366 		0x6C, 0x00, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00
4367 		};
4368 
4369 	{
4370 	SvStorageStreamRef xStor2( rObj->OpenSotStream( C2S("\3OCXNAME")));
4371 	xStor2->Write(aOCXNAME,sizeof(aOCXNAME));
4372 	DBG_ASSERT((xStor2.Is() && (SVSTREAM_OK == xStor2->GetError())),"damn");
4373 	}
4374 /*
4375 	static sal_uInt8 __READONLY_DATA aTest[] = {
4376 		0x00, 0x02, 0x20, 0x00, 0x2B, 0x00, 0x00, 0x00,
4377 		0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
4378 		0x06, 0x00, 0x00, 0x80, 0x4C, 0x61, 0x62, 0x65,
4379 		0x6C, 0x31, 0x18, 0x00, 0xEC, 0x09, 0x00, 0x00,
4380 		0x7B, 0x02, 0x00, 0x00, 0x00, 0x02, 0x20, 0x00,
4381 		0x35, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x80,
4382 		0xC3, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
4383 		0x54, 0x69, 0x6D, 0x65, 0x73, 0x20, 0x4E, 0x65,
4384 		0x77, 0x20, 0x52, 0x6F, 0x6D, 0x61, 0x6E, 0x00,
4385 		};
4386 */
4387 	SvStorageStreamRef xContents( rObj->OpenSotStream( C2S("contents")));
4388 	return WriteContents(xContents, rPropSet, rSize);
4389 }
4390 
4391 typedef OCX_Control *(*FNCreate)();
4392 
4393 
4394 struct OCX_map
4395 {
4396 	FNCreate pCreate;
4397 	const char *sId;
4398 	sal_Int16 nId;
4399 	const char *sName;
4400 };
4401 
4402 OCX_map aOCXTab[] =
4403 {
4404     // Command button MUST be at index 0
4405     {&OCX_CommandButton::Create,"D7053240-CE69-11CD-a777-00dd01143c57",
4406         form::FormComponentType::COMMANDBUTTON,"CommandButton"},
4407     // Toggle button MUST be at index 1
4408     {&OCX_ToggleButton::Create,"8BD21D60-EC42-11CE-9e0d-00aa006002f3",
4409         form::FormComponentType::COMMANDBUTTON,"ToggleButton"},
4410 	{&OCX_Label::Create, "978C9E23-D4B0-11CE-bf2d-00aa003f40d0",
4411 		form::FormComponentType::FIXEDTEXT,"Label"},
4412 	{&OCX_TextBox::Create,"8BD21D10-EC42-11CE-9e0d-00aa006002f3",
4413 		form::FormComponentType::TEXTFIELD,"TextBox"},
4414 	{&OCX_ListBox::Create,"8BD21D20-EC42-11CE-9e0d-00aa006002f3",
4415 		form::FormComponentType::LISTBOX,"ListBox"},
4416 	{&OCX_ComboBox::Create,"8BD21D30-EC42-11CE-9e0d-00aa006002f3",
4417 		form::FormComponentType::COMBOBOX,"ComboBox"},
4418 	{&OCX_CheckBox::Create,"8BD21D40-EC42-11CE-9e0d-00aa006002f3",
4419 		form::FormComponentType::CHECKBOX,"CheckBox"},
4420 	{&OCX_OptionButton::Create,"8BD21D50-EC42-11CE-9e0d-00aa006002f3",
4421 		form::FormComponentType::RADIOBUTTON,"OptionButton"},
4422 	{&OCX_Image::Create,"4C599241-6926-101B-9992-00000b65c6f9",
4423 		form::FormComponentType::IMAGECONTROL,"Image"},
4424 	{&OCX_FieldControl::Create,"8BD21D10-EC42-11CE-9e0d-00aa006002f3",
4425 		form::FormComponentType::DATEFIELD,"TextBox"},
4426 	{&OCX_FieldControl::Create,"8BD21D10-EC42-11CE-9e0d-00aa006002f3",
4427 		form::FormComponentType::TIMEFIELD,"TextBox"},
4428 	{&OCX_FieldControl::Create,"8BD21D10-EC42-11CE-9e0d-00aa006002f3",
4429 		form::FormComponentType::NUMERICFIELD,"TextBox"},
4430 	{&OCX_FieldControl::Create,"8BD21D10-EC42-11CE-9e0d-00aa006002f3",
4431 		form::FormComponentType::CURRENCYFIELD,"TextBox"},
4432 	{&OCX_FieldControl::Create,"8BD21D10-EC42-11CE-9e0d-00aa006002f3",
4433 		form::FormComponentType::PATTERNFIELD,"TextBox"},
4434 #if 0
4435 	{&OCX_FieldControl::Create,"8BD21D10-EC42-11CE-9e0d-00aa006002f3",
4436 		form::FormComponentType::FORMULAFIELD,"TextBox"},
4437 #endif
4438 	{&OCX_ImageButton::Create,"D7053240-CE69-11CD-a777-00dd01143c57",
4439 		form::FormComponentType::IMAGEBUTTON,"CommandButton"},
4440     {&OCX_SpinButton::Create,"79176FB0-B7F2-11CE-97ef-00aa006d2776",
4441         form::FormComponentType::SPINBUTTON,"SpinButton"},
4442     {&OCX_ScrollBar::Create,"DFD181E0-5E2F-11CE-a449-00aa004a803d",
4443         form::FormComponentType::SCROLLBAR,"ScrollBar"},
4444 	{&OCX_GroupBox::Create,"",
4445 		form::FormComponentType::GROUPBOX,""},
4446     {&OCX_ProgressBar::Create,"",
4447         form::FormComponentType::CONTROL,""}
4448 };
4449 
4450 const int NO_OCX = sizeof( aOCXTab ) / sizeof( *aOCXTab );
4451 
SvxMSConvertOCXControls(SfxObjectShell * pDSh,SwPaM * pP)4452 SvxMSConvertOCXControls::SvxMSConvertOCXControls(SfxObjectShell *pDSh, SwPaM *pP) :
4453     pDocSh(pDSh), pPaM(pP), nEdit(0), nCheckbox(0)
4454 {
4455     DBG_ASSERT( pDocSh, "No DocShell, Cannot do Controls" );
4456     OCX_Control::FillSystemColors();
4457 }
4458 
~SvxMSConvertOCXControls()4459 SvxMSConvertOCXControls::~SvxMSConvertOCXControls()
4460 {
4461 }
4462 
OCX_Factory(const String & sName)4463 OCX_Control * SvxMSConvertOCXControls::OCX_Factory(const String &sName)
4464 {
4465 	for (int i=0;i<NO_OCX;i++)
4466 	{
4467         if ( sName.EqualsIgnoreCaseAscii( aOCXTab[i].sId ))
4468 			return(aOCXTab[i].pCreate());
4469 	}
4470 	return(NULL);
4471 }
4472 
OCX_Factory(const uno::Reference<awt::XControlModel> & rControlModel,String & rId,String & rName)4473 OCX_Control * SvxMSConvertOCXControls::OCX_Factory(
4474 	const uno::Reference< awt::XControlModel > &rControlModel,
4475 	String &rId, String &rName)
4476 {
4477 	rName.Erase();
4478 	rId.Erase();
4479 
4480 	uno::Reference< beans::XPropertySet > xPropSet(
4481 		rControlModel,uno::UNO_QUERY);
4482 
4483 	uno::Any aTmp = xPropSet->getPropertyValue(
4484 		OUString::createFromAscii("ClassId"));
4485 	sal_Int16 nClassId = *(sal_Int16*) aTmp.getValue();
4486 
4487 //Begin nasty hack
4488 	/*
4489 	There is a truly horrible thing with EditControls and FormattedField
4490 	Controls, they both pretend to have an EDITBOX ClassId for compatibility
4491 	reasons, at some stage in the future hopefully there will be a proper
4492 	FormulaField ClassId rather than this piggybacking two controls onto the
4493 	same ClassId, when this happens uncomment the FORMULAFIELD in the OCX_Tab
4494 	and delete this block, cmc.
4495 
4496 	And also the nClassId for ImageControls is being reported as "CONTROL"
4497 	rather than IMAGECONTROL
4498 	*/
4499 	if (nClassId == form::FormComponentType::TEXTFIELD)
4500 	{
4501 		uno::Reference< lang::XServiceInfo > xInfo(rControlModel,
4502 			uno::UNO_QUERY);
4503 		if (xInfo->
4504 			supportsService(OUString::createFromAscii(
4505 				"com.sun.star.form.component.FormattedField")))
4506 		{
4507 			rId.AppendAscii("8BD21D10-EC42-11CE-9e0d-00aa006002f3");
4508 			rName.AppendAscii("TextBox");
4509 			return new OCX_FieldControl;
4510 		}
4511 	}
4512 	else if (nClassId == form::FormComponentType::CONTROL)
4513 	{
4514 		uno::Reference< lang::XServiceInfo > xInfo(rControlModel,
4515 			uno::UNO_QUERY);
4516 		if (xInfo->
4517 			supportsService(OUString::createFromAscii(
4518 				"com.sun.star.form.component.ImageControl")))
4519 		nClassId = form::FormComponentType::IMAGECONTROL;
4520 	}
4521 //End nasty hack
4522 
4523     const OCX_map* pEntry = 0;
4524 
4525     // distinguish between push button and toggle button
4526     if( nClassId == form::FormComponentType::COMMANDBUTTON )
4527     {
4528         pEntry = any2bool(xPropSet->getPropertyValue(WW8_ASCII2STR("Toggle"))) ?
4529             (aOCXTab + 1) : aOCXTab;
4530     }
4531     else
4532     {
4533         for( int i = 2; (i < NO_OCX) && !pEntry; ++i )
4534             if( nClassId == aOCXTab[ i ].nId )
4535                 pEntry = aOCXTab + i;
4536     }
4537 
4538     if( pEntry )
4539     {
4540         rId.AppendAscii( pEntry->sId );
4541         rName.AppendAscii( pEntry->sName );
4542         return pEntry->pCreate();
4543     }
4544 
4545     return 0;
4546 }
4547 
4548 
ReadOCXStream(SvStorageRef & rSrc1,uno::Reference<drawing::XShape> * pShapeRef,sal_Bool bFloatingCtrl)4549 sal_Bool SvxMSConvertOCXControls::ReadOCXStream( SvStorageRef& rSrc1,
4550 		uno::Reference < drawing::XShape > *pShapeRef,sal_Bool bFloatingCtrl)
4551 {
4552 
4553 	SvStorageStreamRef xCrash = rSrc1->OpenSotStream( WW8_ASCII2STR("contents") );
4554 	sal_Bool bRet=sal_False;
4555 
4556 	SvStorageStreamRef xSrc2 = rSrc1->OpenSotStream( WW8_ASCII2STR("\3OCXNAME") );
4557 	SvStorageStream* pSt = xSrc2;
4558 	pSt->SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
4559 
4560     /* #117832# import control name */
4561     OUString controlName;
4562     bool hasCName = readOCXNAME( controlName, pSt );
4563 
4564 	xSrc2 = rSrc1->OpenSotStream( WW8_ASCII2STR("contents") );
4565 	pSt = xSrc2;
4566 	pSt->SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
4567 
4568 	/*Get Class Id of this object, see if it is one of the types
4569 	 *that this importer can handle, call the appropriate handler
4570 	 to read that control, and call the appropriate handler to
4571 	 insert that control
4572 	 */
4573 
4574 	SvGlobalName aTest = rSrc1->GetClassName();
4575 	OCX_Control *pObj = OCX_Factory(aTest.GetHexName());
4576 	if (pObj)
4577 	{
4578         pObj->pDocSh = pDocSh;
4579         /* #117832# set imported control name */
4580         if ( hasCName )
4581         {
4582             pObj->sName = controlName;
4583         }
4584 		com::sun::star::awt::Size aSz;
4585 		uno::Reference< form::XFormComponent >  xFComp;
4586 		const uno::Reference< lang::XMultiServiceFactory > & rServiceFactory =
4587 			GetServiceFactory();
4588 		if(!rServiceFactory.is())
4589 			return(sal_False);
4590         bRet = pObj->FullRead(pSt);
4591 		if(bRet)
4592 			if (pObj->Import(rServiceFactory,xFComp,aSz))
4593 				bRet = InsertControl( xFComp, aSz,pShapeRef,bFloatingCtrl);
4594 		delete pObj;
4595 	}
4596 	return bRet;
4597 }
4598 
4599 
ReadOCXExcelKludgeStream(SvStorageStreamRef & rSrc1,uno::Reference<drawing::XShape> * pShapeRef,sal_Bool bFloatingCtrl)4600 sal_Bool SvxMSConvertOCXControls::ReadOCXExcelKludgeStream(
4601 	SvStorageStreamRef& rSrc1, uno::Reference < drawing::XShape > *
4602 	pShapeRef,sal_Bool bFloatingCtrl)
4603 {
4604 	sal_Bool bRet=sal_False;
4605 	/*Get Class Id of this object, see if it is one of the types
4606 	 *that this importer can handle, call the appropriate handler
4607 	 to read that control, and call the appropriate handler to
4608 	 insert that control
4609 	 */
4610 	/*The Excel Kludge is to concatenate a class id with a contents
4611 	 * stream, and then concatenate all the controls together,
4612 	 * This means that you should have the cnts stream wound to the
4613 	 * correct location before passing the control stream in here*/
4614 	SvStream *pSt = rSrc1;
4615 	pSt->SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
4616 	SvGlobalName aTest;
4617 	*pSt >> aTest;
4618 	OCX_Control *pObj = OCX_Factory(aTest.GetHexName());
4619 	if (pObj)
4620 	{
4621 
4622 		com::sun::star::awt::Size aSz;
4623 		uno::Reference< form::XFormComponent >  xFComp;
4624 		const uno::Reference< lang::XMultiServiceFactory > & rServiceFactory =
4625 			GetServiceFactory();
4626 		if(!rServiceFactory.is())
4627 			return(sal_False);
4628         bRet = pObj->FullRead(rSrc1);
4629 		if(bRet)
4630 			if (pObj->Import(rServiceFactory,xFComp,aSz))
4631 				bRet = InsertControl( xFComp, aSz,pShapeRef,bFloatingCtrl);
4632 		delete pObj;
4633 	}
4634 	return bRet;
4635 }
4636 
4637 
WriteOCXStream(SvStorageRef & rSrc1,const uno::Reference<awt::XControlModel> & rControlModel,const awt::Size & rSize,String & rName)4638 sal_Bool SvxMSConvertOCXControls::WriteOCXStream( SvStorageRef& rSrc1,
4639 	const uno::Reference< awt::XControlModel > &rControlModel,
4640 	const awt::Size &rSize, String &rName)
4641 {
4642 	sal_Bool bRet=sal_False;
4643 
4644 	DBG_ASSERT( rControlModel.is(), "UNO-Control missing Model, panic!" );
4645 	if( !rControlModel.is() )
4646 		return sal_False;
4647 
4648 #if 0
4649 	uno::Any aTmp = xPropSet->getPropertyValue(
4650 		OUString::createFromAscii("ClassId"));
4651 	sal_Int16 nClassId = *(sal_Int16*) aTmp.getValue();
4652 #endif
4653 
4654 	String sId;
4655 	OCX_Control *pObj = OCX_Factory(rControlModel,sId,rName);
4656 	if (pObj != NULL)
4657 	{
4658 		uno::Reference<beans::XPropertySet> xPropSet(rControlModel,
4659 			uno::UNO_QUERY);
4660 
4661         /* #117832# - also enable export of control name  */
4662         OUString sCName;
4663         xPropSet->getPropertyValue(C2S("Name")) >>= sCName;
4664         pObj->sName = sCName;
4665 
4666 		SvGlobalName aName;
4667 		aName.MakeId(sId);
4668 		String sFullName(String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM(
4669 			"Microsoft Forms 2.0 ")));
4670 		sFullName.Append(rName);
4671 		rSrc1->SetClass(aName,0x5C,sFullName);
4672 		//                    ^^^^, this pathetic 0x5c is the magic number
4673 		// which the lack of originally blocked the implementation of
4674 		// the controls export
4675 		// cmc
4676 
4677 		bRet = pObj->Export(rSrc1,xPropSet,rSize);
4678         SvStorageStreamRef xStor2( rSrc1->OpenSotStream( WW8_ASCII2STR("\3OCXNAME")));
4679         /* #117832# - also enable export of control name  */
4680         writeOCXNAME( sCName, xStor2 );
4681 		delete pObj;
4682 	}
4683 	return bRet;
4684 }
4685 
4686 
4687 //I think this should work for excel documents, create the "Ctls" stream
4688 //and give it here as rContents, we'll append out streams ole id and
4689 //contents here and that appears to be what Excel is doing
WriteOCXExcelKludgeStream(SvStorageStreamRef & rContents,const uno::Reference<awt::XControlModel> & rControlModel,const awt::Size & rSize,String & rName)4690 sal_Bool SvxMSConvertOCXControls::WriteOCXExcelKludgeStream(
4691 	SvStorageStreamRef& rContents,
4692 	const uno::Reference< awt::XControlModel > &rControlModel,
4693 	const awt::Size &rSize, String &rName)
4694 {
4695 	sal_Bool bRet=sal_False;
4696 
4697 	DBG_ASSERT( rControlModel.is(), "UNO-Control missing Model, panic!" );
4698 	if( !rControlModel.is() )
4699 		return sal_False;
4700 
4701 	String sId;
4702 	OCX_Control *pObj = OCX_Factory(rControlModel,sId,rName);
4703 	if (pObj != NULL)
4704 	{
4705 		uno::Reference<beans::XPropertySet> xPropSet(rControlModel,
4706 			uno::UNO_QUERY);
4707 
4708 		SvGlobalName aName;
4709 		aName.MakeId(sId);
4710 		String sFullName(String::CreateFromAscii(RTL_CONSTASCII_STRINGPARAM(
4711 			"Microsoft Forms 2.0 ")));
4712 		sFullName.Append(rName);
4713 		SvStream *pS=rContents;
4714 		*pS << aName;
4715 		bRet = pObj->WriteContents(rContents,xPropSet,rSize);
4716 		delete pObj;
4717         // export needs correct stream position
4718         rContents->Seek( STREAM_SEEK_TO_END );
4719 	}
4720 	return bRet;
4721 }
4722 
4723 
4724 
4725 
4726 
4727 
4728 
Import(com::sun::star::uno::Reference<com::sun::star::beans::XPropertySet> & rPropSet)4729 sal_Bool OCX_CheckBox::Import(com::sun::star::uno::Reference<
4730     com::sun::star::beans::XPropertySet> &rPropSet)
4731 {
4732 	uno::Any aTmp(&sName,getCppuType((OUString *)0));
4733 	rPropSet->setPropertyValue( WW8_ASCII2STR("Name"), aTmp );
4734 
4735     // background color: fBackStyle==0 -> transparent
4736     if( fBackStyle )
4737         aTmp <<= ImportColor(mnBackColor);
4738     else
4739         aTmp = uno::Any();
4740     rPropSet->setPropertyValue( WW8_ASCII2STR("BackgroundColor"), aTmp);
4741 
4742 	sal_Bool bTemp;
4743 	if ((!(fEnabled)) || (fLocked))
4744 		bTemp = sal_False;
4745 	else
4746 		bTemp = sal_True;
4747 	aTmp = bool2any(bTemp);
4748 	rPropSet->setPropertyValue( WW8_ASCII2STR("Enabled"), aTmp);
4749 
4750     bTemp = fWordWrap != 0;
4751     aTmp = bool2any(bTemp);
4752     rPropSet->setPropertyValue( WW8_ASCII2STR("MultiLine"), aTmp);
4753 
4754 	aTmp <<= ImportColor(mnForeColor);
4755 	rPropSet->setPropertyValue( WW8_ASCII2STR("TextColor"), aTmp);
4756 
4757 	bTemp = nMultiState;
4758 	aTmp = bool2any(bTemp);
4759 	rPropSet->setPropertyValue( WW8_ASCII2STR("TriState"), aTmp);
4760 
4761     aTmp <<= ImportSpecEffect( nSpecialEffect );
4762     rPropSet->setPropertyValue( WW8_ASCII2STR("VisualEffect"), aTmp);
4763 
4764 	if (pValue && !bSetInDialog)
4765 	{
4766 		sal_Int16 nTmp=pValue[0]-0x30;
4767 		aTmp <<= nTmp;
4768 		rPropSet->setPropertyValue( WW8_ASCII2STR("DefaultState"), aTmp);
4769 	}
4770 
4771 	if (pCaption)
4772 	{
4773         aTmp <<= lclCreateOUString( pCaption, nCaptionLen );
4774 		rPropSet->setPropertyValue( WW8_ASCII2STR("Label"), aTmp);
4775 	}
4776 
4777     // #i40279# always centered vertically
4778     aTmp <<= ::com::sun::star::style::VerticalAlignment_MIDDLE;
4779     rPropSet->setPropertyValue( WW8_ASCII2STR("VerticalAlign"), aTmp );
4780 
4781     aFontData.Import(rPropSet);
4782 	return(sal_True);
4783 }
4784 
WriteContents(SvStorageStreamRef & rContents,const uno::Reference<beans::XPropertySet> & rPropSet,const awt::Size & rSize)4785 sal_Bool OCX_CheckBox::WriteContents(SvStorageStreamRef &rContents,
4786     const uno::Reference< beans::XPropertySet > &rPropSet,
4787 	const awt::Size &rSize)
4788 
4789 {
4790 	sal_Bool bRet=sal_True;
4791     sal_uInt32 nOldPos = rContents->Tell();
4792 	rContents->SeekRel(12);
4793 
4794 	pBlockFlags[0] = 0;
4795 	pBlockFlags[1] = 0x01;
4796 	pBlockFlags[2] = 0;
4797 	pBlockFlags[3] = 0x80;
4798 	pBlockFlags[4] = 0;
4799 	pBlockFlags[5] = 0;
4800 	pBlockFlags[6] = 0;
4801 	pBlockFlags[7] = 0;
4802 
4803 	uno::Any aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("Enabled"));
4804 	fEnabled = any2bool(aTmp);
4805 
4806     aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("BackgroundColor"));
4807     fBackStyle = aTmp.hasValue() ? 1 : 0;
4808     if (fBackStyle)
4809         aTmp >>= mnBackColor;
4810 
4811 	sal_uInt8 nTemp=fEnabled;
4812 	if (fEnabled)
4813 		nTemp = nTemp << 1;
4814     if (fBackStyle)
4815         nTemp |= 0x08;
4816 	*rContents << nTemp;
4817 	pBlockFlags[0] |= 0x01;
4818 	*rContents << sal_uInt8(0x00);
4819     nTemp = 0;
4820     aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("MultiLine"));
4821     fWordWrap = any2bool(aTmp);
4822     if (fWordWrap)
4823         nTemp |= 0x80;
4824     *rContents << nTemp;
4825     *rContents << sal_uInt8(0x00);
4826 
4827     *rContents << ExportColor(mnBackColor);
4828     pBlockFlags[0] |= 0x02;
4829 
4830 	aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("TextColor"));
4831     if (aTmp.hasValue())
4832 	    aTmp >>= mnForeColor;
4833 	*rContents << ExportColor(mnForeColor);
4834 	pBlockFlags[0] |= 0x04;
4835 
4836 	nStyle = 4;
4837 	*rContents << nStyle;
4838 	pBlockFlags[0] |= 0x40;
4839 
4840 	aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("TriState"));
4841 	nMultiState = any2bool(aTmp);
4842 	*rContents << nMultiState;
4843 	pBlockFlags[2] |= 0x20;
4844 
4845 	WriteAlign(rContents,4);
4846     nValueLen = 1|SVX_MSOCX_COMPRESSED;
4847 	aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("DefaultState"));
4848 	sal_Int16 nDefault = sal_Int16();
4849 	aTmp >>= nDefault;
4850 	*rContents << nValueLen;
4851 	pBlockFlags[2] |= 0x40;
4852 
4853     SvxOcxString aCaption( rPropSet->getPropertyValue(WW8_ASCII2STR("Label")) );
4854     aCaption.WriteLenField( *rContents );
4855     if (aCaption.HasData())
4856 		pBlockFlags[2] |= 0x80;
4857 
4858     aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("VisualEffect"));
4859     if (aTmp.hasValue())
4860     {
4861         sal_Int16 nApiSpecEffect = sal_Int16();
4862         aTmp >>= nApiSpecEffect;
4863         nSpecialEffect = ExportSpecEffect( nApiSpecEffect );
4864     }
4865 	WriteAlign(rContents,4);
4866     *rContents << nSpecialEffect;
4867     pBlockFlags[3] |= 0x04;
4868 
4869 	WriteAlign(rContents,4);
4870 	*rContents << rSize.Width;
4871 	*rContents << rSize.Height;
4872 
4873 	nDefault += 0x30;
4874 	*rContents << sal_uInt8(nDefault);
4875 	*rContents << sal_uInt8(0x00);
4876 
4877     aCaption.WriteCharArray( *rContents );
4878 
4879 	WriteAlign(rContents,4);
4880     nFixedAreaLen = static_cast<sal_uInt16>(rContents->Tell()-nOldPos-4);
4881 	bRet = aFontData.Export(rContents,rPropSet);
4882     rContents->Seek(nOldPos);
4883 	*rContents << nStandardId;
4884 	*rContents << nFixedAreaLen;
4885 
4886 	*rContents << pBlockFlags[0];
4887 	*rContents << pBlockFlags[1];
4888 	*rContents << pBlockFlags[2];
4889 	*rContents << pBlockFlags[3];
4890 	*rContents << pBlockFlags[4];
4891 	*rContents << pBlockFlags[5];
4892 	*rContents << pBlockFlags[6];
4893 	*rContents << pBlockFlags[7];
4894 
4895 	DBG_ASSERT((rContents.Is() &&
4896 		(SVSTREAM_OK==rContents->GetError())),"damn");
4897 	return bRet;
4898 }
4899 
4900 
Export(SvStorageRef & rObj,const uno::Reference<beans::XPropertySet> & rPropSet,const awt::Size & rSize)4901 sal_Bool OCX_CheckBox::Export(SvStorageRef &rObj,
4902     const uno::Reference< beans::XPropertySet > &rPropSet,
4903 	const awt::Size &rSize)
4904 
4905 {
4906 	static sal_uInt8 __READONLY_DATA aCompObj[] = {
4907 		0x01, 0x00, 0xFE, 0xFF, 0x03, 0x0A, 0x00, 0x00,
4908 		0xFF, 0xFF, 0xFF, 0xFF, 0x40, 0x1D, 0xD2, 0x8B,
4909 		0x42, 0xEC, 0xCE, 0x11, 0x9E, 0x0D, 0x00, 0xAA,
4910 		0x00, 0x60, 0x02, 0xF3, 0x1D, 0x00, 0x00, 0x00,
4911 		0x4D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66,
4912 		0x74, 0x20, 0x46, 0x6F, 0x72, 0x6D, 0x73, 0x20,
4913 		0x32, 0x2E, 0x30, 0x20, 0x43, 0x68, 0x65, 0x63,
4914 		0x6B, 0x42, 0x6F, 0x78, 0x00, 0x10, 0x00, 0x00,
4915 		0x00, 0x45, 0x6D, 0x62, 0x65, 0x64, 0x64, 0x65,
4916 		0x64, 0x20, 0x4F, 0x62, 0x6A, 0x65, 0x63, 0x74,
4917 		0x00, 0x11, 0x00, 0x00, 0x00, 0x46, 0x6F, 0x72,
4918 		0x6D, 0x73, 0x2E, 0x43, 0x68, 0x65, 0x63, 0x6B,
4919 		0x42, 0x6F, 0x78, 0x2E, 0x31, 0x00, 0xF4, 0x39,
4920 		0xB2, 0x71, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4921 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00
4922 	};
4923 
4924 	{
4925 	SvStorageStreamRef xStor( rObj->OpenSotStream( C2S("\1CompObj")));
4926 	xStor->Write(aCompObj,sizeof(aCompObj));
4927 	DBG_ASSERT((xStor.Is() && (SVSTREAM_OK == xStor->GetError())),"damn");
4928 	}
4929 
4930 	{
4931 	SvStorageStreamRef xStor3( rObj->OpenSotStream( C2S("\3ObjInfo")));
4932 	xStor3->Write(aObjInfo,sizeof(aObjInfo));
4933 	DBG_ASSERT((xStor3.Is() && (SVSTREAM_OK == xStor3->GetError())),"damn");
4934 	}
4935 
4936 	static sal_uInt8 __READONLY_DATA aOCXNAME[] = {
4937 		0x43, 0x00, 0x68, 0x00, 0x65, 0x00, 0x63, 0x00,
4938 		0x6B, 0x00, 0x42, 0x00, 0x6F, 0x00, 0x78, 0x00,
4939 		0x31, 0x00, 0x00, 0x00, 0x00, 0x00
4940 		};
4941 	{
4942 	SvStorageStreamRef xStor2( rObj->OpenSotStream( C2S("\3OCXNAME")));
4943 	xStor2->Write(aOCXNAME,sizeof(aOCXNAME));
4944 	DBG_ASSERT((xStor2.Is() && (SVSTREAM_OK == xStor2->GetError())),"damn");
4945 	}
4946 /*
4947 	static sal_uInt8 __READONLY_DATA aTest[] = {
4948 		0x00, 0x02, 0x34, 0x00, 0x46, 0x01, 0xC0, 0x80,
4949 		0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x00,
4950 		0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
4951 		0x01, 0x00, 0x00, 0x80, 0x09, 0x00, 0x00, 0x80,
4952 		0xE2, 0x0E, 0x00, 0x00, 0x95, 0x02, 0x00, 0x00,
4953 		0x30, 0x69, 0x1D, 0x00, 0x43, 0x68, 0x65, 0x63,
4954 		0x6B, 0x42, 0x6F, 0x78, 0x31, 0x20, 0x52, 0x6F,
4955 		0x00, 0x02, 0x20, 0x00, 0x35, 0x00, 0x00, 0x00,
4956 		0x0F, 0x00, 0x00, 0x80, 0xC3, 0x00, 0x00, 0x00,
4957 		0x00, 0x02, 0x00, 0x00, 0x54, 0x69, 0x6D, 0x65,
4958 		0x73, 0x20, 0x4E, 0x65, 0x77, 0x20, 0x52, 0x6F,
4959 		0x6D, 0x61, 0x6E, 0x00,
4960 	};
4961 */
4962 	SvStorageStreamRef xContents( rObj->OpenSotStream( C2S("contents")));
4963 	return WriteContents(xContents, rPropSet, rSize);
4964 }
4965 
4966 
Read(SvStorageStream * pS)4967 sal_Bool OCX_FontData::Read(SvStorageStream *pS)
4968 {
4969     long nStart = pS->Tell();
4970 	*pS >> nIdentifier;
4971 	*pS >> nFixedAreaLen;
4972 	pS->Read(pBlockFlags,4);
4973 
4974     bool bFontName = (pBlockFlags[0] & 0x01) != 0;
4975     if (bFontName)
4976 		*pS >> nFontNameLen;
4977 	if (pBlockFlags[0] & 0x02)
4978 	{
4979 		sal_uInt8 nTmp;
4980 		*pS >> nTmp;
4981 		fBold = nTmp & 0x01;
4982 		fItalic = (nTmp & 0x02) >> 1;
4983 		fUnderline = (nTmp & 0x04) >> 2;
4984 		fStrike = (nTmp & 0x08) >> 3;
4985 		fUnknown1 = (nTmp & 0xF0) >> 4;
4986 		*pS >> nUnknown2;
4987 		*pS >> nUnknown3;
4988 		*pS >> nUnknown4;
4989 	}
4990 	if (pBlockFlags[0] & 0x04)
4991 	{
4992 		ReadAlign(pS, pS->Tell() - nStart, 4);
4993 		*pS >> nFontSize;
4994 	}
4995     else
4996         nFontSize = 240;
4997 	if (pBlockFlags[0] & 0x10)
4998 	{
4999 		ReadAlign(pS, pS->Tell() - nStart, 2);
5000 		*pS >> nLanguageID;
5001 	}
5002 	if (pBlockFlags[0] & 0x40)
5003     {
5004 		*pS >> nJustification;
5005     }
5006     if (pBlockFlags[0] & 0x80)  // font weight before font name
5007     {
5008         ReadAlign(pS, pS->Tell() - nStart, 2);
5009         *pS >> nFontWeight;
5010     }
5011 
5012     if (bFontName)
5013         lclReadCharArray( *pS, pFontName, nFontNameLen, pS->Tell() - nStart);
5014 
5015 	ReadAlign(pS, pS->Tell() - nStart, 4);
5016 	return(sal_True);
5017 }
5018 
Import(uno::Reference<beans::XPropertySet> & rPropSet)5019 void OCX_FontData::Import(uno::Reference< beans::XPropertySet > &rPropSet)
5020 {
5021 	uno::Any aTmp;
5022 	if (pFontName)
5023 	{
5024         aTmp <<= lclCreateOUString( pFontName, nFontNameLen );
5025 		rPropSet->setPropertyValue( WW8_ASCII2STR("FontName"), aTmp);
5026 	}
5027 
5028 	if (bHasAlign)
5029 	{
5030 		sal_Int16 nAlign = ImportAlign(nJustification);
5031 		aTmp <<= nAlign;
5032 		rPropSet->setPropertyValue( WW8_ASCII2STR("Align"), aTmp);
5033 	}
5034 
5035 	if (fBold)
5036 	{
5037         aTmp <<= awt::FontWeight::BOLD;
5038 		rPropSet->setPropertyValue( WW8_ASCII2STR("FontWeight"), aTmp);
5039 	}
5040 
5041     if (fItalic)
5042     {
5043         aTmp <<= (sal_Int16)awt::FontSlant_ITALIC;
5044         rPropSet->setPropertyValue( WW8_ASCII2STR("FontSlant"), aTmp);
5045     }
5046 
5047     if (fUnderline)
5048     {
5049         aTmp <<= awt::FontUnderline::SINGLE;
5050         rPropSet->setPropertyValue( WW8_ASCII2STR("FontUnderline"), aTmp);
5051     }
5052 
5053     if (fStrike)
5054     {
5055         aTmp <<= awt::FontStrikeout::SINGLE;
5056         rPropSet->setPropertyValue( WW8_ASCII2STR("FontStrikeout"), aTmp);
5057     }
5058 
5059     // 2004-09-17: very strange way of storing font sizes...
5060     // 1pt->30, 2pt->45, 3pt->60, 4pt->75, 5pt->105, 6pt->120, 7pt->135
5061     // 8pt->165, 9pt->180, 10pt->195, 11pt->225, ...
5062     aTmp <<= sal_Int16( (nFontSize <= 30) ? 1 : ((nFontSize + 10) / 20) );
5063     rPropSet->setPropertyValue( WW8_ASCII2STR("FontHeight"), aTmp);
5064 }
5065 
Export(SvStorageStreamRef & rContent,const uno::Reference<beans::XPropertySet> & rPropSet)5066 sal_Bool OCX_FontData::Export(SvStorageStreamRef &rContent,
5067 	const uno::Reference< beans::XPropertySet > &rPropSet)
5068 {
5069 	sal_uInt8 nFlags=0x00;
5070     sal_uInt32 nOldPos = rContent->Tell();
5071 	rContent->SeekRel(8);
5072     SvxOcxString aFontName;
5073 	uno::Any aTmp;
5074 
5075 	if (bHasFont)
5076         aFontName = rPropSet->getPropertyValue(WW8_ASCII2STR("FontName"));
5077     if (!aFontName.HasData())
5078         aFontName = OUString( RTL_CONSTASCII_USTRINGPARAM( "Times New Roman" ) );
5079     aFontName.WriteLenField( *rContent );
5080 	nFlags |= 0x01;
5081 
5082 	if (bHasFont)
5083 	{
5084 		aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("FontWeight"));
5085 		//Export font related props
5086 		if ( aTmp.hasValue() )
5087 		{
5088 			float nBold = 0.0;
5089 			aTmp >>= nBold;
5090 			if ( nBold >= 150 )
5091 				fBold = 1;
5092 		}
5093 
5094 		aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("FontSlant"));
5095 		if ( aTmp.hasValue() )
5096 		{
5097 			short eItalic = 0 ;
5098 			aTmp >>= eItalic ;
5099 			if ( eItalic == awt::FontSlant_ITALIC )
5100 				fItalic = 1;
5101 		}
5102 
5103 		aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("FontUnderline"));
5104 		if ( aTmp.hasValue() )
5105 		{
5106 			short eUnderline = 0 ;
5107 			aTmp >>= eUnderline;
5108 			if ( eUnderline == awt::FontUnderline::SINGLE )
5109 				fUnderline = 1;
5110 		}
5111 
5112 		aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("FontStrikeout"));
5113 		if ( aTmp.hasValue() )
5114 		{
5115 			short eLtStrikeout = 0;
5116 			aTmp >>= eLtStrikeout;
5117 			if ( eLtStrikeout == awt::FontStrikeout::SINGLE )
5118 				fStrike = 1;
5119 		}
5120 
5121 		sal_uInt8 nTmp= 1 * fBold  +  2* fItalic  + 4* fUnderline +  8 * fStrike;
5122 		if ( nTmp > 0 )
5123 		{
5124 			nFlags |= 0x02;
5125 			*rContent << nTmp;
5126 			nTmp=0x00;
5127 			*rContent << nTmp;
5128 			*rContent << nTmp;
5129 			*rContent << nTmp;
5130 		}
5131 
5132         aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("FontHeight"));
5133         float nFontHeight = 0;
5134         aTmp >>= nFontHeight;
5135         if (nFontHeight)
5136         {
5137             nFlags |= 0x04;
5138             // 2004-09-17: very strange way of storing font sizes:
5139             // 1pt->30, 2pt->45, 3pt->60, 4pt->75, 5pt->105, 6pt->120, 7pt->135
5140             // 8pt->165, 9pt->180, 10pt->195, 11pt->225, ...
5141             nFontSize = (nFontHeight == 1) ? 30 : (static_cast<sal_uInt32>((nFontHeight*4+1)/3)*15);
5142             *rContent << nFontSize;
5143         }
5144 
5145 		if (bHasAlign)
5146 		{
5147 			*rContent << sal_uInt16(0x0200);
5148 			nFlags |= 0x10;
5149 
5150 			nFlags |= 0x20; // ?
5151 
5152 			aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("Align"));
5153 			nFlags |= 0x40;
5154 			sal_Int16 nAlign = nDefaultAlign;
5155             if (aTmp.hasValue())
5156 			    aTmp >>= nAlign;
5157 			nJustification = ExportAlign(nAlign);
5158 			*rContent << nJustification;
5159 		}
5160 	}
5161 
5162     aFontName.WriteCharArray( *rContent );
5163 	WriteAlign(rContent,4);
5164 
5165     sal_uInt16 nFixedAreaLn = static_cast<sal_uInt16>(rContent->Tell()-nOldPos-4);
5166 	rContent->Seek(nOldPos);
5167 	*rContent << nStandardId;
5168 	*rContent << nFixedAreaLn;
5169 	*rContent << nFlags;
5170 	*rContent << sal_uInt8(0x00);
5171 	*rContent << sal_uInt8(0x00);
5172 	*rContent << sal_uInt8(0x00);
5173 
5174 	WriteAlign(rContent,4);
5175 	return sal_True;
5176 }
5177 
5178 // Doesn't really read anything but just skips the
5179 // record.
Read(SotStorageStream * pS)5180 sal_Bool OCX_TabStrip::Read(SotStorageStream *pS)
5181 {
5182     const long skipLen = 0x18;
5183 	*pS >> nIdentifier;
5184 	DBG_ASSERT(nStandardId==nIdentifier,
5185 		"A control that has a different identifier");
5186 	*pS >> nFixedAreaLen;
5187 
5188     pS->Read(pBlockFlags, sizeof(pBlockFlags));
5189     pS->SeekRel(skipLen);
5190     *pS >> nNumTabs;
5191     // skip to end of control
5192     pS->SeekRel(nFixedAreaLen - sizeof(pBlockFlags) - sizeof(nNumTabs) - skipLen );
5193     return sal_True;
5194 }
5195 
ReadFontData(SotStorageStream * pS)5196 sal_Bool OCX_TabStrip::ReadFontData(SotStorageStream *pS)
5197 {
5198     // Seems like there is a real font record followed by
5199     // a number of blank records ( e.g. nFixedAreaLen = 0 )
5200     // The number of trailing blank records is equal to the number of tabs
5201     OCX_Control::ReadFontData(pS);
5202     for ( sal_uInt16 index = 0; index < nNumTabs; index++ )
5203     {
5204         OCX_Control::Read(pS); // read trailing records
5205     }
5206     return sal_True;
5207 }
5208 
Read(SotStorageStream * pS)5209 sal_Bool OCX_Image::Read(SotStorageStream *pS)
5210 {
5211     if ( !bSetInDialog )
5212     {
5213         // preserve the present behavior at the moment.
5214         // only import image control for UserForms
5215         return sal_False;
5216     }
5217     sal_uLong nStart = pS->Tell();
5218 	*pS >> nIdentifier;
5219 	DBG_ASSERT(nStandardId==nIdentifier,
5220 		"A control that has a different identifier");
5221 	*pS >> nFixedAreaLen;
5222 
5223     pS->Read(pBlockFlags, sizeof(pBlockFlags));
5224 
5225     bool hasEmbeddedImage = false;
5226 
5227     if ( pBlockFlags[0] & 0x04 )
5228     {
5229         bAutoSize = true;
5230     }
5231     if ( pBlockFlags[0] & 0x08 )
5232     {
5233         *pS >> nBorderColor;
5234     }
5235     if ( pBlockFlags[0] & 0x10 )
5236     {
5237         *pS >> mnBackColor;
5238     }
5239     if ( pBlockFlags[0] & 0x20 )
5240     {
5241         *pS >> nBorderStyle;
5242     }
5243     if ( pBlockFlags[0] & 0x40 )
5244     {
5245         *pS >> nMousePointer;
5246     }
5247     if ( pBlockFlags[0] & 0x80 )
5248     {
5249         *pS >> nPictureSizeMode;
5250     }
5251 
5252     if ( pBlockFlags[ 1 ] & 0x1 )
5253     {
5254         *pS >> nSpecialEffect;
5255     }
5256     // investigate if valid also for formcontrols, although for controls
5257     // images themselves seem to come through from escher ( as shape, think
5258     // its probably a preview? )
5259 
5260     // np a bit of a guess ( until proved incorrect )
5261     if ( pBlockFlags[ 1 ] & 0x4 )
5262     {
5263         ReadAlign(pS, pS->Tell() - nStart, 2);
5264         hasEmbeddedImage = true;
5265         sal_uInt16 unknown;
5266         *pS >> unknown;
5267     }
5268 
5269 
5270     if ( pBlockFlags[ 1 ] & 0x8 )
5271     {
5272         ReadAlign(pS, pS->Tell() - nStart, 2);
5273         *pS >> nPictureAlignment;
5274 
5275     }
5276     if ( pBlockFlags[ 1 ] & 0x10 )
5277     {
5278         bPictureTiling = true;
5279     }
5280     if ( pBlockFlags[1] & 0x20 )
5281     {
5282         ReadAlign(pS, pS->Tell() - nStart, 4);
5283         sal_uInt8 nTemp;
5284         *pS >> nTemp;
5285         fEnabled = (nTemp&0x02)>>1;
5286         fBackStyle = (nTemp&0x08)>>3;
5287         // padding?
5288         *pS >> nTemp;
5289         *pS >> nTemp;
5290         *pS >> nTemp;
5291     }
5292     ReadAlign(pS, pS->Tell() - nStart, 4);
5293     *pS >> nWidth;
5294     *pS >> nHeight;
5295 
5296     if ( hasEmbeddedImage )
5297     {
5298         //image follows this block
5299         //len of image is 0x14 relative to end of this block
5300         pS->Seek( pS->Tell() + 0x14 );
5301 
5302         sal_uInt32 nImageLen = 0;
5303         *pS >> nImageLen;
5304 
5305         long imagePos = pS->Tell();
5306 
5307         pS->Seek( imagePos );
5308 
5309         sImageUrl =  C2U("vnd.sun.star.expand:${$OOO_BASE_DIR/program/") + C2U( SAL_CONFIGFILE( "bootstrap" ) ) + C2U("::UserInstallation}/user/temp/") + sName;
5310 
5311         sal_uInt8* pImage = new sal_uInt8[ nImageLen ];
5312         pS->Read(pImage, nImageLen);
5313         bool result = storePictureInFileSystem( sImageUrl, pImage, nImageLen );
5314         OUString pictName = sImageUrl.copy( sImageUrl.lastIndexOf('/') + 1 );
5315         result = storePictureInDoc( pDocSh, pictName, pImage, nImageLen );
5316         delete [] pImage;
5317     }
5318     return sal_True;
5319 }
5320 
Import(uno::Reference<beans::XPropertySet> & rPropSet)5321 sal_Bool OCX_Image::Import( uno::Reference< beans::XPropertySet > &rPropSet )
5322 {
5323 	uno::Any aTmp(&sName,getCppuType((OUString *)0));
5324 	rPropSet->setPropertyValue( WW8_ASCII2STR("Name"), aTmp );
5325 
5326     if( fBackStyle )
5327         aTmp <<= ImportColor(mnBackColor);
5328     else
5329         aTmp = uno::Any();
5330     rPropSet->setPropertyValue( WW8_ASCII2STR("BackgroundColor"), aTmp);
5331 
5332 	sal_Bool bTemp;
5333 	if (fEnabled)
5334 		bTemp = sal_True;
5335 	else
5336 		bTemp = sal_False;
5337 	aTmp = bool2any(bTemp);
5338 	rPropSet->setPropertyValue( WW8_ASCII2STR("Enabled"), aTmp);
5339     if ( sImageUrl.getLength() )
5340     {
5341         aTmp <<= sImageUrl;
5342         rPropSet->setPropertyValue( WW8_ASCII2STR("ImageURL"), aTmp);
5343     }
5344 	return sal_True;
5345 }
5346 
WriteContents(SvStorageStreamRef & rContents,const uno::Reference<beans::XPropertySet> & rPropSet,const awt::Size & rSize)5347 sal_Bool OCX_Image::WriteContents(SvStorageStreamRef &rContents,
5348 	const uno::Reference< beans::XPropertySet > &rPropSet,
5349 	const awt::Size &rSize)
5350 {
5351 	sal_Bool bRet=sal_True;
5352     sal_uInt32 nOldPos = rContents->Tell();
5353 	rContents->SeekRel(8);
5354 
5355 	pBlockFlags[0] = 0;
5356 	pBlockFlags[1] = 0x02;
5357 	pBlockFlags[2] = 0;
5358 	pBlockFlags[3] = 0;
5359 
5360 	uno::Any aTmp = rPropSet->getPropertyValue(
5361 		WW8_ASCII2STR("BackgroundColor"));
5362     if (aTmp.hasValue())
5363 	    aTmp >>= mnBackColor;
5364 	*rContents << ExportColor(mnBackColor);
5365 	pBlockFlags[0] |= 0x10;
5366 
5367 
5368 	aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("Border"));
5369 	sal_Int16 nBorder = sal_Int16();
5370 	aTmp >>= nBorder;
5371 	nSpecialEffect = ExportBorder(nBorder,nBorderStyle);
5372 	*rContents << nBorderStyle;
5373 	pBlockFlags[0] |= 0x20;
5374 
5375 	*rContents << nSpecialEffect;
5376 	pBlockFlags[1] |= 0x01;
5377 
5378 	WriteAlign(rContents,4);
5379 
5380 	aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("Enabled"));
5381 	fEnabled = any2bool(aTmp);
5382 	if (fEnabled)
5383 	{
5384 		sal_uInt8 nTemp = 0x19;
5385 		*rContents << nTemp;
5386 		pBlockFlags[1] |= 0x20;
5387 		*rContents << sal_uInt8(0x00);
5388 		*rContents << sal_uInt8(0x00);
5389 		*rContents << sal_uInt8(0x00);
5390 	}
5391 
5392 	aTmp = rPropSet->getPropertyValue(WW8_ASCII2STR("ImageURL"));
5393 //	OUString *pStr = (OUString *)aTmp.getValue();
5394 	/*Magically fetch that image and turn it into something that
5395 	 *we can store in ms controls, wmf,png,jpg are almost certainly
5396 	 *the options we have for export...*/
5397 
5398 	WriteAlign(rContents,4);
5399 	*rContents << rSize.Width;
5400 	*rContents << rSize.Height;
5401 
5402 	WriteAlign(rContents,4);
5403     nFixedAreaLen = static_cast<sal_uInt16>(rContents->Tell()-nOldPos-4);
5404 
5405     rContents->Seek(nOldPos);
5406 	*rContents << nStandardId;
5407 	*rContents << nFixedAreaLen;
5408 
5409 	*rContents << pBlockFlags[0];
5410 	*rContents << pBlockFlags[1];
5411 	*rContents << pBlockFlags[2];
5412 	*rContents << pBlockFlags[3];
5413 	DBG_ASSERT((rContents.Is() &&
5414 		(SVSTREAM_OK==rContents->GetError())),"damn");
5415 	return bRet;
5416 }
5417 
5418 
Export(SvStorageRef & rObj,const uno::Reference<beans::XPropertySet> & rPropSet,const awt::Size & rSize)5419 sal_Bool OCX_Image::Export(SvStorageRef &rObj,
5420 	const uno::Reference< beans::XPropertySet > &rPropSet,
5421 	const awt::Size &rSize)
5422 {
5423 	static sal_uInt8 __READONLY_DATA aCompObj[] = {
5424 		0x01, 0x00, 0xFE, 0xFF, 0x03, 0x0A, 0x00, 0x00,
5425 		0xFF, 0xFF, 0xFF, 0xFF, 0x41, 0x92, 0x59, 0x4C,
5426 		0x26, 0x69, 0x1B, 0x10, 0x99, 0x92, 0x00, 0x00,
5427 		0x0B, 0x65, 0xC6, 0xF9, 0x1A, 0x00, 0x00, 0x00,
5428 		0x4D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66,
5429 		0x74, 0x20, 0x46, 0x6F, 0x72, 0x6D, 0x73, 0x20,
5430 		0x32, 0x2E, 0x30, 0x20, 0x49, 0x6D, 0x61, 0x67,
5431 		0x65, 0x00, 0x10, 0x00, 0x00, 0x00, 0x45, 0x6D,
5432 		0x62, 0x65, 0x64, 0x64, 0x65, 0x64, 0x20, 0x4F,
5433 		0x62, 0x6A, 0x65, 0x63, 0x74, 0x00, 0x0E, 0x00,
5434 		0x00, 0x00, 0x46, 0x6F, 0x72, 0x6D, 0x73, 0x2E,
5435 		0x49, 0x6D, 0x61, 0x67, 0x65, 0x2E, 0x31, 0x00,
5436 		0xF4, 0x39, 0xB2, 0x71, 0x00, 0x00, 0x00, 0x00,
5437 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
5438 		};
5439 
5440 	{
5441 	SvStorageStreamRef xStor( rObj->OpenSotStream( C2S("\1CompObj")));
5442 	xStor->Write(aCompObj,sizeof(aCompObj));
5443 	DBG_ASSERT((xStor.Is() && (SVSTREAM_OK == xStor->GetError())),"damn");
5444 	}
5445 
5446 	{
5447 	SvStorageStreamRef xStor3( rObj->OpenSotStream( C2S("\3ObjInfo")));
5448 	xStor3->Write(aObjInfo,sizeof(aObjInfo));
5449 	DBG_ASSERT((xStor3.Is() && (SVSTREAM_OK == xStor3->GetError())),"damn");
5450 	}
5451 
5452 	static sal_uInt8 __READONLY_DATA aOCXNAME[] = {
5453 		0x49, 0x00, 0x6D, 0x00, 0x61, 0x00, 0x67, 0x00,
5454 		0x65, 0x00, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00
5455 		};
5456 
5457 	{
5458 	SvStorageStreamRef xStor2( rObj->OpenSotStream( C2S("\3OCXNAME")));
5459 	xStor2->Write(aOCXNAME,sizeof(aOCXNAME));
5460 	DBG_ASSERT((xStor2.Is() && (SVSTREAM_OK == xStor2->GetError())),"damn");
5461 	}
5462 
5463 	SvStorageStreamRef xContents( rObj->OpenSotStream( C2S("contents")));
5464 	return WriteContents(xContents, rPropSet, rSize);
5465 }
5466 
5467 // ============================================================================
5468 
OCX_SpinButton()5469 OCX_SpinButton::OCX_SpinButton() :
5470     OCX_Control( OUString( RTL_CONSTASCII_USTRINGPARAM( "SpinButton" ) ) ),
5471     mnBlockFlags( 0 ),
5472     mnValue( 0 ),
5473     mnMin( 0 ),
5474     mnMax( 100 ),
5475     mnSmallStep( 1 ),
5476     mnPageStep( 1 ),
5477     mnOrient( -1 ),
5478     mnDelay( 50 ),
5479     mbEnabled( true ),
5480     mbLocked( false ),
5481     mbPropThumb( true )
5482 {
5483     msFormType = C2U("com.sun.star.form.component.SpinButton");
5484     msDialogType = C2U("com.sun.star.awt.UnoControlSpinButtonModel");
5485     mnBackColor = 0x8000000F;
5486     mnForeColor = 0x80000012;
5487 }
5488 
Create()5489 OCX_Control* OCX_SpinButton::Create()
5490 {
5491     return new OCX_SpinButton;
5492 }
5493 
Read(SvStorageStream * pS)5494 sal_Bool OCX_SpinButton::Read( SvStorageStream *pS )
5495 {
5496     if( !pS ) return sal_False;
5497 
5498     SvStream& rStrm = *pS;
5499     sal_uInt16 nId, nSize;
5500     sal_Int32 nIcon = 0;
5501 
5502     rStrm >> nId >> nSize >> mnBlockFlags;
5503 
5504     DBG_ASSERT( nStandardId == nId, "OCX_SpinButton::Read - unknown identifier" );
5505 
5506     if( mnBlockFlags & 0x00000001 )     rStrm >> mnForeColor;
5507     if( mnBlockFlags & 0x00000002 )     rStrm >> mnBackColor;
5508     if( mnBlockFlags & 0x00000004 )
5509     {
5510         sal_Int32 nFlags;
5511         rStrm >> nFlags;
5512         mbEnabled = (nFlags & 0x00000002) != 0;
5513         mbLocked = (nFlags & 0x00000004) != 0;
5514     }
5515     if( mnBlockFlags & 0x00000010 )     rStrm.SeekRel( 4 );     // mouse pointer
5516     if( mnBlockFlags & 0x00000020 )     rStrm >> mnMin;
5517     if( mnBlockFlags & 0x00000040 )     rStrm >> mnMax;
5518     if( mnBlockFlags & 0x00000080 )     rStrm >> mnValue;
5519     if( mnBlockFlags & 0x00000100 )     rStrm.SeekRel( 4 );     // unknown
5520     if( mnBlockFlags & 0x00000200 )     rStrm.SeekRel( 4 );     // unknown
5521     if( mnBlockFlags & 0x00000400 )     rStrm.SeekRel( 4 );     // unknown
5522     if( mnBlockFlags & 0x00000800 )     rStrm >> mnSmallStep;
5523     if( mnBlockFlags & 0x00001000 )     rStrm >> mnPageStep;
5524     if( mnBlockFlags & 0x00002000 )     rStrm >> mnOrient;
5525     if( mnBlockFlags & 0x00004000 )
5526     {
5527         sal_Int32 nThumb;
5528         *pS >> nThumb;
5529         mbPropThumb = nThumb != 0;
5530     }
5531     if( mnBlockFlags & 0x00008000 )     rStrm >> mnDelay;
5532     if( mnBlockFlags & 0x00010000 )     rStrm >> nIcon;
5533     if( mnBlockFlags & 0x00000008 )     rStrm >> nWidth >> nHeight;
5534 
5535     if( nIcon )
5536     {
5537         sal_Int32 nIconSize;
5538         pS->SeekRel( 20 );
5539         *pS >> nIconSize;
5540         pS->SeekRel( nIconSize );
5541     }
5542 
5543     return sal_True;
5544 }
5545 
ReadFontData(SvStorageStream *)5546 sal_Bool OCX_SpinButton::ReadFontData( SvStorageStream* /* pS */ )
5547 {
5548     // spin buttons and scroll bars do not support font data
5549     return sal_True;
5550 }
5551 
Import(com::sun::star::uno::Reference<com::sun::star::beans::XPropertySet> & rPropSet)5552 sal_Bool OCX_SpinButton::Import(com::sun::star::uno::Reference<
5553     com::sun::star::beans::XPropertySet> &rPropSet)
5554 {
5555     if( (nWidth < 1) || (nHeight < 1) )
5556         return sal_False;
5557 
5558     uno::Any aTmp( &sName, getCppuType((OUString *)0) );
5559     rPropSet->setPropertyValue( WW8_ASCII2STR( "Name" ), aTmp );
5560 
5561     aTmp <<= ImportColor( mnForeColor );
5562     rPropSet->setPropertyValue( WW8_ASCII2STR("SymbolColor"), aTmp);
5563 
5564     aTmp <<= ImportColor( mnBackColor );
5565     rPropSet->setPropertyValue( WW8_ASCII2STR("BackgroundColor"), aTmp);
5566 
5567     aTmp = bool2any( mbEnabled && !mbLocked );
5568     rPropSet->setPropertyValue( WW8_ASCII2STR("Enabled"), aTmp);
5569 
5570     aTmp <<= mnValue;
5571     if ( bSetInDialog )
5572     {
5573         rPropSet->setPropertyValue( WW8_ASCII2STR("SpinValue"), aTmp );
5574     }
5575     else
5576     {
5577         rPropSet->setPropertyValue( WW8_ASCII2STR("DefaultSpinValue"), aTmp );
5578     }
5579 
5580     aTmp <<= mnMin;
5581     rPropSet->setPropertyValue( WW8_ASCII2STR("SpinValueMin"), aTmp );
5582 
5583     aTmp <<= mnMax;
5584     rPropSet->setPropertyValue( WW8_ASCII2STR("SpinValueMax"), aTmp );
5585 
5586     aTmp <<= mnSmallStep;
5587     rPropSet->setPropertyValue( WW8_ASCII2STR("SpinIncrement"), aTmp );
5588 
5589     namespace AwtScrollOrient = ::com::sun::star::awt::ScrollBarOrientation;
5590     switch( mnOrient )
5591     {
5592         case 0:     aTmp <<= AwtScrollOrient::VERTICAL;     break;
5593         case 1:     aTmp <<= AwtScrollOrient::HORIZONTAL;   break;
5594         default:    aTmp <<= (nWidth < nHeight) ? AwtScrollOrient::VERTICAL : AwtScrollOrient::HORIZONTAL;
5595     }
5596     rPropSet->setPropertyValue( WW8_ASCII2STR("Orientation"), aTmp );
5597 
5598     aTmp = bool2any( true );
5599     rPropSet->setPropertyValue( WW8_ASCII2STR("Repeat"), aTmp );
5600 
5601     aTmp <<= mnDelay;
5602     rPropSet->setPropertyValue( WW8_ASCII2STR("RepeatDelay"), aTmp );
5603 
5604     aTmp <<= sal_Int16( 0 );
5605     rPropSet->setPropertyValue( WW8_ASCII2STR("Border"), aTmp);
5606 
5607     return sal_True;
5608 }
5609 
Export(SvStorageRef & rObj,const uno::Reference<beans::XPropertySet> & rPropSet,const awt::Size & rSize)5610 sal_Bool OCX_SpinButton::Export(
5611         SvStorageRef &rObj,
5612         const uno::Reference< beans::XPropertySet>& rPropSet,
5613         const awt::Size& rSize )
5614 {
5615     static sal_uInt8 __READONLY_DATA aCompObj[] =
5616     {
5617         0x01, 0x00, 0xFE, 0xFF, 0x03, 0x0A, 0x00, 0x00,
5618         0xFF, 0xFF, 0xFF, 0xFF, 0xB0, 0x6F, 0x17, 0x79,
5619         0xF2, 0xB7, 0xCE, 0x11, 0x97, 0xEF, 0x00, 0xAA,
5620         0x00, 0x6D, 0x27, 0x76, 0x1F, 0x00, 0x00, 0x00,
5621         0x4D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66,
5622         0x74, 0x20, 0x46, 0x6F, 0x72, 0x6D, 0x73, 0x20,
5623         0x32, 0x2E, 0x30, 0x20, 0x53, 0x70, 0x69, 0x6E,
5624         0x42, 0x75, 0x74, 0x74, 0x6F, 0x6E, 0x00, 0x10,
5625         0x00, 0x00, 0x00, 0x45, 0x6D, 0x62, 0x65, 0x64,
5626         0x64, 0x65, 0x64, 0x20, 0x4F, 0x62, 0x6A, 0x65,
5627         0x63, 0x74, 0x00, 0x13, 0x00, 0x00, 0x00, 0x46,
5628         0x6F, 0x72, 0x6D, 0x73, 0x2E, 0x53, 0x70, 0x69,//Add those to avoid MS crash when open
5629         0x6E, 0x42, 0x75, 0x74, 0x74, 0x6F, 0x6E, 0x2E,
5630         0x31, 0x00, 0xF4, 0x39, 0xB2, 0x71, 0x00, 0x00,
5631         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5632         0x00, 0x00
5633     };
5634 
5635     {
5636         SvStorageStreamRef xStor( rObj->OpenSotStream( C2S("\1CompObj")));
5637         xStor->Write(aCompObj,sizeof(aCompObj));
5638         DBG_ASSERT((xStor.Is() && (SVSTREAM_OK == xStor->GetError())),"damn");
5639     }
5640 
5641     {
5642         SvStorageStreamRef xStor3( rObj->OpenSotStream( C2S("\3ObjInfo")));
5643         xStor3->Write(aObjInfo,sizeof(aObjInfo));
5644         DBG_ASSERT((xStor3.Is() && (SVSTREAM_OK == xStor3->GetError())),"damn");
5645     }
5646 
5647     static sal_uInt8 __READONLY_DATA aOCXNAME[] =
5648     {
5649         0x53, 0x00, 0x70, 0x00, 0x69, 0x00, 0x6E, 0x00,
5650         0x42, 0x00, 0x75, 0x00, 0x74, 0x00, 0x74, 0x00,
5651         0x6F, 0x00, 0x6E, 0x00, 0x31, 0x00, 0x00, 0x00,
5652         0x00, 0x00
5653     };
5654 
5655     {
5656         SvStorageStreamRef xStor2( rObj->OpenSotStream( C2S("\3OCXNAME")));
5657         xStor2->Write(aOCXNAME,sizeof(aOCXNAME));
5658         DBG_ASSERT((xStor2.Is() && (SVSTREAM_OK == xStor2->GetError())),"damn");
5659     }
5660 
5661     SvStorageStreamRef xContents( rObj->OpenSotStream( C2S("contents")));
5662     return WriteContents(xContents, rPropSet, rSize);
5663 }
5664 
WriteContents(SvStorageStreamRef & rObj,const uno::Reference<beans::XPropertySet> & rPropSet,const awt::Size & rSize)5665 sal_Bool OCX_SpinButton::WriteContents(
5666         SvStorageStreamRef &rObj,
5667         const uno::Reference< beans::XPropertySet> &rPropSet,
5668         const awt::Size& rSize )
5669 {
5670     if( !rObj.Is() )
5671         return sal_False;
5672 
5673     mnBlockFlags = 0x00000008;
5674     nWidth = rSize.Width;
5675     nHeight = rSize.Height;
5676 
5677     GetInt32Property( mnForeColor, rPropSet, WW8_ASCII2STR( "SymbolColor" ),     0x00000001 );
5678     GetInt32Property( mnBackColor, rPropSet, WW8_ASCII2STR( "BackgroundColor" ), 0x00000002 );
5679     GetBoolProperty(  mbEnabled,   rPropSet, WW8_ASCII2STR( "Enabled" ),         0x00000304 );
5680     GetInt32Property( mnMin,       rPropSet, WW8_ASCII2STR( "SpinValueMin" ),    0x00000020 );
5681     GetInt32Property( mnMax,       rPropSet, WW8_ASCII2STR( "SpinValueMax" ),    0x00000040 );
5682     GetInt32Property( mnValue,     rPropSet, WW8_ASCII2STR( "SpinValue" ),       0x00000080 );
5683     GetInt32Property( mnSmallStep, rPropSet, WW8_ASCII2STR( "SpinIncrement" ),   0x00000800 );
5684     GetInt32Property( mnDelay,     rPropSet, WW8_ASCII2STR( "RepeatDelay" ),     0x00008000 );
5685 
5686     namespace AwtScrollOrient = ::com::sun::star::awt::ScrollBarOrientation;
5687     sal_Int16 nApiOrient = sal_Int16();
5688     if( rPropSet->getPropertyValue( WW8_ASCII2STR( "Orientation" ) ) >>= nApiOrient )
5689         UpdateInt32Property( mnOrient, (nApiOrient == AwtScrollOrient::VERTICAL) ? 0 : 1, 0x00002000 );
5690 
5691     return WriteData( *rObj );
5692 }
5693 
UpdateInt32Property(sal_Int32 & rnCoreValue,sal_Int32 nNewValue,sal_Int32 nBlockFlag)5694 void OCX_SpinButton::UpdateInt32Property(
5695         sal_Int32& rnCoreValue, sal_Int32 nNewValue, sal_Int32 nBlockFlag )
5696 {
5697     if( nNewValue != rnCoreValue )
5698     {
5699         rnCoreValue = nNewValue;
5700         mnBlockFlags |= nBlockFlag;
5701     }
5702 }
5703 
GetInt32Property(sal_Int32 & rnCoreValue,const uno::Reference<beans::XPropertySet> & rxPropSet,const OUString & rPropName,sal_Int32 nBlockFlag)5704 void OCX_SpinButton::GetInt32Property(
5705         sal_Int32& rnCoreValue, const uno::Reference< beans::XPropertySet>& rxPropSet,
5706         const OUString& rPropName, sal_Int32 nBlockFlag )
5707 {
5708     sal_Int32 nNewValue = 0;
5709     if( rxPropSet->getPropertyValue( rPropName ) >>= nNewValue )
5710         UpdateInt32Property( rnCoreValue, nNewValue, nBlockFlag );
5711 }
5712 
UpdateBoolProperty(bool & rbCoreValue,bool bNewValue,sal_Int32 nBlockFlag)5713 void OCX_SpinButton::UpdateBoolProperty(
5714         bool& rbCoreValue, bool bNewValue, sal_Int32 nBlockFlag )
5715 {
5716     if( bNewValue != rbCoreValue )
5717     {
5718         rbCoreValue = bNewValue;
5719         mnBlockFlags |= nBlockFlag;
5720     }
5721 }
5722 
GetBoolProperty(bool & rbCoreValue,const uno::Reference<beans::XPropertySet> & rxPropSet,const OUString & rPropName,sal_Int32 nBlockFlag)5723 void OCX_SpinButton::GetBoolProperty(
5724         bool& rbCoreValue, const uno::Reference< beans::XPropertySet>& rxPropSet,
5725         const OUString& rPropName, sal_Int32 nBlockFlag )
5726 {
5727     UpdateBoolProperty( rbCoreValue,
5728         any2bool( rxPropSet->getPropertyValue( rPropName ) ), nBlockFlag );
5729 }
5730 
WriteData(SvStream & rStrm) const5731 sal_Bool OCX_SpinButton::WriteData( SvStream& rStrm ) const
5732 {
5733     sal_Bool bRet = sal_True;
5734     sal_uLong nStartPos = rStrm.Tell();
5735 
5736     rStrm << sal_Int32( 0 ) << mnBlockFlags;
5737 
5738     if( mnBlockFlags & 0x00000001 )     rStrm << ExportColor( mnForeColor );
5739     if( mnBlockFlags & 0x00000002 )     rStrm << ExportColor( mnBackColor );
5740     if( mnBlockFlags & 0x00000004 )
5741     {
5742         sal_Int32 nFlags = 0x00000019;  // always set
5743         if( mbEnabled ) nFlags |= 0x00000002;
5744         if( mbLocked )  nFlags |= 0x00000004;
5745         rStrm << nFlags;
5746     }
5747     if( mnBlockFlags & 0x00000020 )     rStrm << mnMin;
5748     if( mnBlockFlags & 0x00000040 )     rStrm << mnMax;
5749     if( mnBlockFlags & 0x00000080 )     rStrm << mnValue;
5750     if( mnBlockFlags & 0x00000100 )     rStrm << sal_Int32( 0 );    // unknown
5751     if( mnBlockFlags & 0x00000200 )     rStrm << sal_Int32( 0 );    // unknown
5752     if( mnBlockFlags & 0x00000400 )     rStrm << sal_Int32( 0 );    // unknown
5753     if( mnBlockFlags & 0x00000800 )     rStrm << mnSmallStep;
5754     if( mnBlockFlags & 0x00001000 )     rStrm << mnPageStep;
5755     if( mnBlockFlags & 0x00002000 )     rStrm << mnOrient;
5756     if( mnBlockFlags & 0x00004000 )     rStrm << sal_Int32( mbPropThumb ? 1 : 0 );
5757     if( mnBlockFlags & 0x00008000 )     rStrm << mnDelay;
5758     if( mnBlockFlags & 0x00000008 )     rStrm << nWidth << nHeight;
5759 
5760     sal_uInt16 nSize = static_cast< sal_uInt16 >( rStrm.Tell() - nStartPos - 4 );
5761     rStrm.Seek( nStartPos );
5762     rStrm << nStandardId << nSize;
5763 
5764     DBG_ASSERT( rStrm.GetError() == SVSTREAM_OK, "OCX_SpinButton::WriteData - error in stream" );
5765     return bRet;
5766 }
5767 
5768 // ============================================================================
5769 
OCX_ScrollBar()5770 OCX_ScrollBar::OCX_ScrollBar()
5771 {
5772     sName = OUString( RTL_CONSTASCII_USTRINGPARAM( "ScrollBar" ) );
5773     mnMax = 32767;
5774     msFormType = C2U("com.sun.star.form.component.ScrollBar");
5775     msDialogType = C2U("com.sun.star.awt.UnoControlScrollBarModel");
5776 
5777 }
5778 
Create()5779 OCX_Control* OCX_ScrollBar::Create()
5780 {
5781     return new OCX_ScrollBar;
5782 }
5783 
Import(com::sun::star::uno::Reference<com::sun::star::beans::XPropertySet> & rPropSet)5784 sal_Bool OCX_ScrollBar::Import(com::sun::star::uno::Reference<
5785     com::sun::star::beans::XPropertySet> &rPropSet)
5786 {
5787     if( (nWidth < 1) || (nHeight < 1) )
5788         return sal_False;
5789 
5790     uno::Any aTmp( &sName, getCppuType((OUString *)0) );
5791     rPropSet->setPropertyValue( WW8_ASCII2STR( "Name" ), aTmp );
5792 
5793     aTmp <<= ImportColor( mnForeColor );
5794     rPropSet->setPropertyValue( WW8_ASCII2STR("SymbolColor"), aTmp);
5795 
5796     aTmp <<= ImportColor( mnBackColor );
5797     rPropSet->setPropertyValue( WW8_ASCII2STR("BackgroundColor"), aTmp);
5798 
5799     aTmp = bool2any( mbEnabled && !mbLocked );
5800     rPropSet->setPropertyValue( WW8_ASCII2STR("Enabled"), aTmp);
5801 
5802     aTmp <<= mnValue;
5803     if ( bSetInDialog )
5804     {
5805         rPropSet->setPropertyValue( WW8_ASCII2STR("ScrollValue"), aTmp );
5806     }
5807     else
5808     {
5809         rPropSet->setPropertyValue( WW8_ASCII2STR("DefaultScrollValue"), aTmp );
5810     }
5811 
5812     aTmp <<= mnMin;
5813     rPropSet->setPropertyValue( WW8_ASCII2STR("ScrollValueMin"), aTmp );
5814 
5815     aTmp <<= mnMax;
5816     rPropSet->setPropertyValue( WW8_ASCII2STR("ScrollValueMax"), aTmp );
5817 
5818     aTmp <<= mnSmallStep;
5819     rPropSet->setPropertyValue( WW8_ASCII2STR("LineIncrement"), aTmp );
5820 
5821     aTmp <<= mnPageStep;
5822     rPropSet->setPropertyValue( WW8_ASCII2STR("BlockIncrement"), aTmp );
5823     if( mbPropThumb && (mnPageStep > 0) )
5824         rPropSet->setPropertyValue( WW8_ASCII2STR("VisibleSize"), aTmp );
5825 
5826     namespace AwtScrollOrient = ::com::sun::star::awt::ScrollBarOrientation;
5827     switch( mnOrient )
5828     {
5829         case 0:     aTmp <<= AwtScrollOrient::VERTICAL;     break;
5830         case 1:     aTmp <<= AwtScrollOrient::HORIZONTAL;   break;
5831         default:    aTmp <<= (nWidth < nHeight) ? AwtScrollOrient::VERTICAL : AwtScrollOrient::HORIZONTAL;
5832     }
5833     rPropSet->setPropertyValue( WW8_ASCII2STR("Orientation"), aTmp );
5834 
5835     aTmp <<= mnDelay;
5836     rPropSet->setPropertyValue( WW8_ASCII2STR("RepeatDelay"), aTmp );
5837 
5838     aTmp <<= sal_Int16( 0 );
5839     rPropSet->setPropertyValue( WW8_ASCII2STR("Border"), aTmp);
5840 
5841     return sal_True;
5842 }
5843 
Export(SvStorageRef & rObj,const uno::Reference<beans::XPropertySet> & rPropSet,const awt::Size & rSize)5844 sal_Bool OCX_ScrollBar::Export(
5845         SvStorageRef &rObj,
5846         const uno::Reference< beans::XPropertySet>& rPropSet,
5847         const awt::Size& rSize )
5848 {
5849     static sal_uInt8 __READONLY_DATA aCompObj[] =
5850     {
5851         0x01, 0x00, 0xFE, 0xFF, 0x03, 0x0A, 0x00, 0x00,
5852         0xFF, 0xFF, 0xFF, 0xFF, 0xE0, 0x81, 0xD1, 0xDF,
5853         0x2F, 0x5E, 0xCE, 0x11, 0xA4, 0x49, 0x00, 0xAA,
5854         0x00, 0x4A, 0x80, 0x3D, 0x1E, 0x00, 0x00, 0x00,
5855         0x4D, 0x69, 0x63, 0x72, 0x6F, 0x73, 0x6F, 0x66,
5856         0x74, 0x20, 0x46, 0x6F, 0x72, 0x6D, 0x73, 0x20,
5857         0x32, 0x2E, 0x30, 0x20, 0x53, 0x63, 0x72, 0x6F,
5858         0x6C, 0x6C, 0x42, 0x61, 0x72, 0x00, 0x10, 0x00,
5859         0x00, 0x00, 0x45, 0x6D, 0x62, 0x65, 0x64, 0x64,
5860         0x65, 0x64, 0x20, 0x4F, 0x62, 0x6A, 0x65, 0x63,
5861         0x74, 0x00, 0x12, 0x00, 0x00, 0x00, 0x46, 0x6F,
5862         0x72, 0x6D, 0x73, 0x2E, 0x53, 0x63, 0x72, 0x6F,
5863         0x6C, 0x6C, 0x42, 0x61, 0x72, 0x2E, 0x31, 0x00,
5864         0xF4, 0x39, 0xB2, 0x71, 0x00, 0x00, 0x00, 0x00,
5865         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
5866     };
5867 
5868     {
5869         SvStorageStreamRef xStor( rObj->OpenSotStream( C2S("\1CompObj")));
5870         xStor->Write(aCompObj,sizeof(aCompObj));
5871         DBG_ASSERT((xStor.Is() && (SVSTREAM_OK == xStor->GetError())),"damn");
5872     }
5873 
5874     {
5875         SvStorageStreamRef xStor3( rObj->OpenSotStream( C2S("\3ObjInfo")));
5876         xStor3->Write(aObjInfo,sizeof(aObjInfo));
5877         DBG_ASSERT((xStor3.Is() && (SVSTREAM_OK == xStor3->GetError())),"damn");
5878     }
5879 
5880     static sal_uInt8 __READONLY_DATA aOCXNAME[] =
5881     {
5882         0x53, 0x00, 0x63, 0x00, 0x72, 0x00, 0x6F, 0x00,
5883         0x6C, 0x00, 0x6C, 0x00, 0x42, 0x00, 0x61, 0x00,
5884         0x72, 0x00, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00
5885     };
5886 
5887     {
5888         SvStorageStreamRef xStor2( rObj->OpenSotStream( C2S("\3OCXNAME")));
5889         xStor2->Write(aOCXNAME,sizeof(aOCXNAME));
5890         DBG_ASSERT((xStor2.Is() && (SVSTREAM_OK == xStor2->GetError())),"damn");
5891     }
5892 
5893     SvStorageStreamRef xContents( rObj->OpenSotStream( C2S("contents")));
5894     return WriteContents(xContents, rPropSet, rSize);
5895 }
5896 
WriteContents(SvStorageStreamRef & rObj,const uno::Reference<beans::XPropertySet> & rPropSet,const awt::Size & rSize)5897 sal_Bool OCX_ScrollBar::WriteContents(
5898         SvStorageStreamRef &rObj,
5899         const uno::Reference< beans::XPropertySet> &rPropSet,
5900         const awt::Size& rSize )
5901 {
5902     if( !rObj.Is() )
5903         return sal_False;
5904 
5905     mnBlockFlags = 0x00000008;
5906     nWidth = rSize.Width;
5907     nHeight = rSize.Height;
5908 
5909     GetInt32Property( mnForeColor, rPropSet, WW8_ASCII2STR( "SymbolColor" ),     0x00000001 );
5910     GetInt32Property( mnBackColor, rPropSet, WW8_ASCII2STR( "BackgroundColor" ), 0x00000002 );
5911     GetBoolProperty(  mbEnabled,   rPropSet, WW8_ASCII2STR( "Enabled" ),         0x00000304 );
5912     GetInt32Property( mnMin,       rPropSet, WW8_ASCII2STR( "ScrollValueMin" ),  0x00000020 );
5913     GetInt32Property( mnMax,       rPropSet, WW8_ASCII2STR( "ScrollValueMax" ),  0x00000040 );
5914     GetInt32Property( mnValue,     rPropSet, WW8_ASCII2STR( "ScrollValue" ),     0x00000080 );
5915     GetInt32Property( mnSmallStep, rPropSet, WW8_ASCII2STR( "LineIncrement" ),   0x00000800 );
5916     GetInt32Property( mnPageStep,  rPropSet, WW8_ASCII2STR( "BlockIncrement" ),  0x00001000 );
5917     GetInt32Property( mnDelay,     rPropSet, WW8_ASCII2STR( "RepeatDelay" ),     0x00008000 );
5918 
5919     namespace AwtScrollOrient = ::com::sun::star::awt::ScrollBarOrientation;
5920     sal_Int16 nApiOrient = sal_Int16();
5921     if( rPropSet->getPropertyValue( WW8_ASCII2STR( "Orientation" ) ) >>= nApiOrient )
5922         UpdateInt32Property( mnOrient, (nApiOrient == AwtScrollOrient::VERTICAL) ? 0 : 1, 0x00002000 );
5923 
5924     UpdateBoolProperty( mbPropThumb, true, 0x00004000 );
5925 
5926     return WriteData( *rObj );
5927 }
5928 
OCX_ProgressBar()5929 OCX_ProgressBar::OCX_ProgressBar() :
5930     OCX_Control( OUString( RTL_CONSTASCII_USTRINGPARAM( "ProgressBar" ) ) ),
5931     nMin( 0 ),
5932     nMax( 0 ),
5933     bFixedSingle(true),
5934     bEnabled( true ),
5935     b3d( true )
5936 {
5937 	msDialogType = C2U("com.sun.star.awt.UnoControlProgressBarModel");
5938 	bSetInDialog = true;
5939 }
5940 
Read(SvStorageStream * pS)5941 sal_Bool OCX_ProgressBar::Read( SvStorageStream *pS )
5942 {
5943     pS->SeekRel( 8 );
5944     *pS >> nWidth >> nHeight;
5945     pS->SeekRel( 12 );
5946 
5947     float fMin, fMax;
5948     *pS >> fMin >> fMax;
5949     nMin = static_cast< sal_Int32 >( fMin );
5950     nMax = static_cast< sal_Int32 >( fMax );
5951 	bool bVisible = true;
5952 	sal_uInt8 pUnknownFlags[4];
5953 	pS->Read(pUnknownFlags,4);
5954 
5955 	// complete guess, but we don't handle visible anyway
5956 	if ( ( pUnknownFlags[2] & 0x8 ) &&  (  pUnknownFlags[2] & 0x2 ) )
5957 		bVisible = false;
5958 
5959     sal_uInt32 nFlags;
5960     *pS >> nFlags;
5961 
5962 	// seems these work out
5963     bFixedSingle = (nFlags & 0x01) != 0;
5964     bEnabled = (nFlags & 0x02) != 0;
5965     b3d = (nFlags & 0x04) != 0;
5966 
5967 	return true;
5968 }
5969 
Create()5970 OCX_Control* OCX_ProgressBar::Create()
5971 {
5972     return new OCX_ProgressBar;
5973 }
5974 
Import(uno::Reference<beans::XPropertySet> & rPropSet)5975 sal_Bool OCX_ProgressBar::Import(uno::Reference< beans::XPropertySet > &rPropSet)
5976 {
5977 	uno::Any aTmp(&sName,getCppuType((OUString *)0));
5978 	rPropSet->setPropertyValue( WW8_ASCII2STR("Name"), aTmp );
5979 	aTmp <<= nMax;
5980 	rPropSet->setPropertyValue( WW8_ASCII2STR("ProgressValueMax"), aTmp );
5981 	aTmp <<= nMin;
5982 	rPropSet->setPropertyValue( WW8_ASCII2STR("ProgressValueMin"), aTmp );
5983 
5984 	if ( !bEnabled )
5985 		rPropSet->setPropertyValue( WW8_ASCII2STR("Enabled"), uno::makeAny( sal_False ) );
5986 	return sal_True;
5987 }
5988 // ============================================================================
5989 
5990 /* vi:set tabstop=4 shiftwidth=4 expandtab: */
5991