?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fix toolbar import
[ooovba.git] / tools / source / generic / gen.cxx
blob4be5471d84c9240845e415ffe8669c0323f0a486
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: gen.cxx,v $
10 * $Revision: 1.5 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_tools.hxx"
33 #include <tools/debug.hxx>
34 #include <tools/gen.hxx>
35 #include <tools/stream.hxx>
36
37 // =======================================================================
38
39 SvStream& operator>>( SvStream& rIStream, Pair& rPair )
40 {
41 DBG_ASSERTWARNING( rIStream.GetVersion(), "Pair::>> - Solar-Version not set on rIStream" );
42
43 if ( rIStream.GetCompressMode() == COMPRESSMODE_FULL )
44 {
45 unsigned char cId;
46 unsigned char cAry[8];
47 int i;
48 int i1;
49 int i2;
50 UINT32 nNum;
51
52 rIStream >> cId;
53 i1 = (cId & 0x70) >> 4;
54 i2 = cId & 0x07;
55 rIStream.Read( cAry, i1+i2 );
56
57 nNum = 0;
58 i = i1;
59 while ( i )
60 {
61 i--;
62 nNum <<= 8;
63 nNum |= cAry[i];
64 }
65 if ( cId & 0x80 )
66 nNum ^= 0xFFFFFFFF;
67 rPair.nA = (INT32)nNum;
68
69 nNum = 0;
70 i = i1+i2;
71 while ( i > i1 )
72 {
73 i--;
74 nNum <<= 8;
75 nNum |= cAry[i];
76 }
77 if ( cId & 0x08 )
78 nNum ^= 0xFFFFFFFF;
79 rPair.nB = (INT32)nNum;
80 }
81 else
82 {
83 rIStream >> rPair.nA >> rPair.nB;
84 }
85
86 return rIStream;
87 }
88
89 // -----------------------------------------------------------------------
90
91 SvStream& operator<<( SvStream& rOStream, const Pair& rPair )
92 {
93 DBG_ASSERTWARNING( rOStream.GetVersion(), "Pair::<< - Solar-Version not set on rOStream" );
94
95 if ( rOStream.GetCompressMode() == COMPRESSMODE_FULL )
96 {
97 unsigned char cAry[9];
98 int i = 1;
99 UINT32 nNum;
100
101 cAry[0] = 0;
102
103 nNum = (UINT32)(INT32)rPair.nA;
104 if ( rPair.nA < 0 )
105 {
106 cAry[0] |= 0x80;
107 nNum ^= 0xFFFFFFFF;
108 }
109 if ( nNum )
110 {
111 cAry[i] = (unsigned char)(nNum & 0xFF);
112 nNum >>= 8;
113 i++;
114
115 if ( nNum )
116 {
117 cAry[i] = (unsigned char)(nNum & 0xFF);
118 nNum >>= 8;
119 i++;
120
121 if ( nNum )
122 {
123 cAry[i] = (unsigned char)(nNum & 0xFF);
124 nNum >>= 8;
125 i++;
126
127 if ( nNum )
128 {
129 cAry[i] = (unsigned char)(nNum & 0xFF);
130 nNum >>= 8;
131 i++;
132 cAry[0] |= 0x40;
133 }
134 else
135 cAry[0] |= 0x30;
136 }
137 else
138 cAry[0] |= 0x20;
139 }
140 else
141 cAry[0] |= 0x10;
142 }
143
144 nNum = (UINT32)(INT32)rPair.nB;
145 if ( rPair.nB < 0 )
146 {
147 cAry[0] |= 0x08;
148 nNum ^= 0xFFFFFFFF;
149 }
150 if ( nNum )
151 {
152 cAry[i] = (unsigned char)(nNum & 0xFF);
153 nNum >>= 8;
154 i++;
155
156 if ( nNum )
157 {
158 cAry[i] = (unsigned char)(nNum & 0xFF);
159 nNum >>= 8;
160 i++;
161
162 if ( nNum )
163 {
164 cAry[i] = (unsigned char)(nNum & 0xFF);
165 nNum >>= 8;
166 i++;
167
168 if ( nNum )
169 {
170 cAry[i] = (unsigned char)(nNum & 0xFF);
171 nNum >>= 8;
172 i++;
173 cAry[0] |= 0x04;
174 }
175 else
176 cAry[0] |= 0x03;
177 }
178 else
179 cAry[0] |= 0x02;
180 }
181 else
182 cAry[0] |= 0x01;
183 }
184
185 rOStream.Write( cAry, i );
186 }
187 else
188 {
189 rOStream << rPair.nA << rPair.nB;
190 }
191
192 return rOStream;
193 }
194
195 /*************************************************************************
196 |*
197 |* Rectangle::SetSize()
198 |*
199 |* Beschreibung GEN.SDW
200 |* Ersterstellung DV 29.10.91
201 |* Letzte Aenderung MM 21.04.94
202 |*
203 *************************************************************************/
204
205 void Rectangle::SetSize( const Size& rSize )
206 {
207 if ( rSize.Width() < 0 )
208 nRight = nLeft + rSize.Width() +1;
209 else if ( rSize.Width() > 0 )
210 nRight = nLeft + rSize.Width() -1;
211 else
212 nRight = RECT_EMPTY;
213
214 if ( rSize.Height() < 0 )
215 nBottom = nTop + rSize.Height() +1;
216 else if ( rSize.Height() > 0 )
217 nBottom = nTop + rSize.Height() -1;
218 else
219 nBottom = RECT_EMPTY;
220 }
221
222 /*************************************************************************
223 |*
224 |* Rectangle::Union()
225 |*
226 |* Beschreibung GEN.SDW
227 |* Ersterstellung TH 20.10.92
228 |* Letzte Aenderung MM 21.04.94
229 |*
230 *************************************************************************/
231
232 Rectangle& Rectangle::Union( const Rectangle& rRect )
233 {
234 if ( rRect.IsEmpty() )
235 return *this;
236
237 if ( IsEmpty() )
238 *this = rRect;
239 else
240 {
241 nLeft = Min( Min( nLeft, rRect.nLeft ), Min( nRight, rRect.nRight ) );
242 nRight = Max( Max( nLeft, rRect.nLeft ), Max( nRight, rRect.nRight ) );
243 nTop = Min( Min( nTop, rRect.nTop ), Min( nBottom, rRect.nBottom ) );
244 nBottom = Max( Max( nTop, rRect.nTop ), Max( nBottom, rRect.nBottom ) );
245 }
246
247 return *this;
248 }
249
250 /*************************************************************************
251 |*
252 |* Rectangle::Intersection()
253 |*
254 |* Beschreibung GEN.SDW
255 |* Ersterstellung TH 20.10.92
256 |* Letzte Aenderung MM 21.04.94
257 |*
258 *************************************************************************/
259
260 Rectangle& Rectangle::Intersection( const Rectangle& rRect )
261 {
262 if ( IsEmpty() )
263 return *this;
264 if ( rRect.IsEmpty() )
265 {
266 *this = Rectangle();
267 return *this;
268 }
269
270 // nicht mit umgedrehten Rechtecken arbeiten
271 Rectangle aTmpRect( rRect );
272 Justify();
273 aTmpRect.Justify();
274
275 // Schnitt bilden
276 nLeft = Max( nLeft, aTmpRect.nLeft );
277 nRight = Min( nRight, aTmpRect.nRight );
278 nTop = Max( nTop, aTmpRect.nTop );
279 nBottom= Min( nBottom, aTmpRect.nBottom );
280
281 // Feststellen ob Schnitt leer
282 if ( nRight < nLeft || nBottom < nTop )
283 *this = Rectangle();
284
285 return *this;
286 }
287
288 /*************************************************************************
289 |*
290 |* Rectangle::Justify()
291 |*
292 |* Beschreibung GEN.SDW
293 |* Ersterstellung DV 07.03.91
294 |* Letzte Aenderung DV 07.03.91
295 |*
296 *************************************************************************/
297
298 void Rectangle::Justify()
299 {
300 long nHelp;
301
302 // Abfrage, ob Right kleiner Left
303 if ( (nRight < nLeft) && (nRight != RECT_EMPTY) )
304 {
305 nHelp = nLeft;
306 nLeft = nRight;
307 nRight = nHelp;
308 }
309
310 // Abfrage, ob Bottom kleiner Top
311 if ( (nBottom < nTop) && (nBottom != RECT_EMPTY) )
312 {
313 nHelp = nBottom;
314 nBottom = nTop;
315 nTop = nHelp;
316 }
317 }
318
319 /*************************************************************************
320 |*
321 |* Rectangle::IsInside()
322 |*
323 |* Beschreibung GEN.SDW
324 |* Ersterstellung TH 19.03.90
325 |* Letzte Aenderung MM 21.04.94
326 |*
327 *************************************************************************/
328
329 BOOL Rectangle::IsInside( const Point& rPoint ) const
330 {
331 if ( IsEmpty() )
332 return FALSE;
333
334 BOOL bRet = TRUE;
335 if ( nLeft <= nRight )
336 {
337 if ( (rPoint.X() < nLeft) || (rPoint.X() > nRight) )
338 bRet = FALSE;
339 }
340 else
341 {
342 if ( (rPoint.X() > nLeft) || (rPoint.X() < nRight) )
343 bRet = FALSE;
344 }
345 if ( nTop <= nBottom )
346 {
347 if ( (rPoint.Y() < nTop) || (rPoint.Y() > nBottom) )
348 bRet = FALSE;
349 }
350 else
351 {
352 if ( (rPoint.Y() > nTop) || (rPoint.Y() < nBottom) )
353 bRet = FALSE;
354 }
355 return bRet;
356 }
357
358 /*************************************************************************
359 |*
360 |* Rectangle::IsInside()
361 |*
362 |* Beschreibung GEN.SDW
363 |* Ersterstellung TH 19.03.90
364 |* Letzte Aenderung MM 21.04.94
365 |*
366 *************************************************************************/
367
368 BOOL Rectangle::IsInside( const Rectangle& rRect ) const
369 {
370 if ( IsInside( rRect.TopLeft() ) && IsInside( rRect.BottomRight() ) )
371 return TRUE;
372 else
373 return FALSE;
374 }
375
376 /*************************************************************************
377 |*
378 |* Rectangle::IsOver()
379 |*
380 |* Beschreibung GEN.SDW
381 |* Ersterstellung TH 19.03.90
382 |* Letzte Aenderung MM 21.04.94
383 |*
384 *************************************************************************/
385
386 BOOL Rectangle::IsOver( const Rectangle& rRect ) const
387 {
388 // Wenn sie sich nicht schneiden, ueberlappen sie auch nicht
389 return !GetIntersection( rRect ).IsEmpty();
390 }
391
392 // =======================================================================
393
394 SvStream& operator>>( SvStream& rIStream, Rectangle& rRect )
395 {
396 DBG_ASSERTWARNING( rIStream.GetVersion(), "Rectangle::>> - Solar-Version not set on rIStream" );
397
398 if ( rIStream.GetCompressMode() == COMPRESSMODE_FULL )
399 {
400 unsigned char cIdAry[2];
401 unsigned char cAry[16];
402 int i;
403 int iLast;
404 int i1;
405 int i2;
406 int i3;
407 int i4;
408 UINT32 nNum;
409
410 rIStream.Read( cIdAry, 2 );
411 i1 = (cIdAry[0] & 0x70) >> 4;
412 i2 = cIdAry[0] & 0x07;
413 i3 = (cIdAry[1] & 0x70) >> 4;
414 i4 = cIdAry[1] & 0x07;
415 rIStream.Read( cAry, i1+i2+i3+i4 );
416
417 nNum = 0;
418 i = i1;
419 iLast = i;
420 while ( i )
421 {
422 i--;
423 nNum <<= 8;
424 nNum |= cAry[i];
425 }
426 iLast = i1;
427 if ( cIdAry[0] & 0x80 )
428 nNum ^= 0xFFFFFFFF;
429 rRect.nLeft = (INT32)nNum;
430
431 nNum = 0;
432 i = iLast+i2;
433 while ( i > iLast )
434 {
435 i--;
436 nNum <<= 8;
437 nNum |= cAry[i];
438 }
439 iLast += i2;
440 if ( cIdAry[0] & 0x08 )
441 nNum ^= 0xFFFFFFFF;
442 rRect.nTop = (INT32)nNum;
443
444 nNum = 0;
445 i = iLast+i3;
446 while ( i > iLast )
447 {
448 i--;
449 nNum <<= 8;
450 nNum |= cAry[i];
451 }
452 iLast += i3;
453 if ( cIdAry[1] & 0x80 )
454 nNum ^= 0xFFFFFFFF;
455 rRect.nRight = (INT32)nNum;
456
457 nNum = 0;
458 i = iLast+i4;
459 while ( i > iLast )
460 {
461 i--;
462 nNum <<= 8;
463 nNum |= cAry[i];
464 }
465 if ( cIdAry[1] & 0x08 )
466 nNum ^= 0xFFFFFFFF;
467 rRect.nBottom = (INT32)nNum;
468 }
469 else
470 {
471 rIStream >> rRect.nLeft >> rRect.nTop >> rRect.nRight >> rRect.nBottom;
472 }
473
474 return rIStream;
475 }
476
477 // -----------------------------------------------------------------------
478
479 SvStream& operator<<( SvStream& rOStream, const Rectangle& rRect )
480 {
481 DBG_ASSERTWARNING( rOStream.GetVersion(), "Rectangle::<< - Solar-Version not set on rOStream" );
482
483 if ( rOStream.GetCompressMode() == COMPRESSMODE_FULL )
484 {
485 unsigned char cAry[18];
486 int i = 2;
487 UINT32 nNum;
488
489 cAry[0] = 0;
490 cAry[1] = 0;
491
492 nNum = (UINT32)(INT32)rRect.nLeft;
493 if ( rRect.nLeft < 0 )
494 {
495 cAry[0] |= 0x80;
496 nNum ^= 0xFFFFFFFF;
497 }
498 if ( nNum )
499 {
500 cAry[i] = (unsigned char)(nNum & 0xFF);
501 nNum >>= 8;
502 i++;
503
504 if ( nNum )
505 {
506 cAry[i] = (unsigned char)(nNum & 0xFF);
507 nNum >>= 8;
508 i++;
509
510 if ( nNum )
511 {
512 cAry[i] = (unsigned char)(nNum & 0xFF);
513 nNum >>= 8;
514 i++;
515
516 if ( nNum )
517 {
518 cAry[i] = (unsigned char)(nNum & 0xFF);
519 nNum >>= 8;
520 i++;
521 cAry[0] |= 0x40;
522 }
523 else
524 cAry[0] |= 0x30;
525 }
526 else
527 cAry[0] |= 0x20;
528 }
529 else
530 cAry[0] |= 0x10;
531 }
532
533 nNum = (UINT32)(INT32)rRect.nTop;
534 if ( rRect.nTop < 0 )
535 {
536 cAry[0] |= 0x08;
537 nNum ^= 0xFFFFFFFF;
538 }
539 if ( nNum )
540 {
541 cAry[i] = (unsigned char)(nNum & 0xFF);
542 nNum >>= 8;
543 i++;
544
545 if ( nNum )
546 {
547 cAry[i] = (unsigned char)(nNum & 0xFF);
548 nNum >>= 8;
549 i++;
550
551 if ( nNum )
552 {
553 cAry[i] = (unsigned char)(nNum & 0xFF);
554 nNum >>= 8;
555 i++;
556
557 if ( nNum )
558 {
559 cAry[i] = (unsigned char)(nNum & 0xFF);
560 nNum >>= 8;
561 i++;
562 cAry[0] |= 0x04;
563 }
564 else
565 cAry[0] |= 0x03;
566 }
567 else
568 cAry[0] |= 0x02;
569 }
570 else
571 cAry[0] |= 0x01;
572 }
573
574 nNum = (UINT32)(INT32)rRect.nRight;
575 if ( rRect.nRight < 0 )
576 {
577 cAry[1] |= 0x80;
578 nNum ^= 0xFFFFFFFF;
579 }
580 if ( nNum )
581 {
582 cAry[i] = (unsigned char)(nNum & 0xFF);
583 nNum >>= 8;
584 i++;
585
586 if ( nNum )
587 {
588 cAry[i] = (unsigned char)(nNum & 0xFF);
589 nNum >>= 8;
590 i++;
591
592 if ( nNum )
593 {
594 cAry[i] = (unsigned char)(nNum & 0xFF);
595 nNum >>= 8;
596 i++;
597
598 if ( nNum )
599 {
600 cAry[i] = (unsigned char)(nNum & 0xFF);
601 nNum >>= 8;
602 i++;
603 cAry[1] |= 0x40;
604 }
605 else
606 cAry[1] |= 0x30;
607 }
608 else
609 cAry[1] |= 0x20;
610 }
611 else
612 cAry[1] |= 0x10;
613 }
614
615 nNum = (UINT32)(INT32)rRect.nBottom;
616 if ( rRect.nBottom < 0 )
617 {
618 cAry[1] |= 0x08;
619 nNum ^= 0xFFFFFFFF;
620 }
621 if ( nNum )
622 {
623 cAry[i] = (unsigned char)(nNum & 0xFF);
624 nNum >>= 8;
625 i++;
626
627 if ( nNum )
628 {
629 cAry[i] = (unsigned char)(nNum & 0xFF);
630 nNum >>= 8;
631 i++;
632
633 if ( nNum )
634 {
635 cAry[i] = (unsigned char)(nNum & 0xFF);
636 nNum >>= 8;
637 i++;
638
639 if ( nNum )
640 {
641 cAry[i] = (unsigned char)(nNum & 0xFF);
642 nNum >>= 8;
643 i++;
644 cAry[1] |= 0x04;
645 }
646 else
647 cAry[1] |= 0x03;
648 }
649 else
650 cAry[1] |= 0x02;
651 }
652 else
653 cAry[1] |= 0x01;
654 }
655
656 rOStream.Write( cAry, i );
657 }
658 else
659 {
660 rOStream << rRect.nLeft << rRect.nTop << rRect.nRight << rRect.nBottom;
661 }
662
663 return rOStream;
664 }
vba interoperability for OOo