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