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_svx.hxx" 26 #include <tools/debug.hxx> 27 28 #include <svx/svdglue.hxx> 29 #include <svx/svdobj.hxx> 30 #include <svx/svdtrans.hxx> 31 32 33 void SdrGluePoint::SetReallyAbsolute(FASTBOOL bOn, const SdrObject& rObj) 34 { 35 if ( bReallyAbsolute != bOn ) 36 { 37 if ( bOn ) 38 { 39 aPos=GetAbsolutePos(rObj); 40 bReallyAbsolute=bOn; 41 } 42 else 43 { 44 bReallyAbsolute=bOn; 45 Point aPt(aPos); 46 SetAbsolutePos(aPt,rObj); 47 } 48 } 49 } 50 51 Point SdrGluePoint::GetAbsolutePos(const SdrObject& rObj) const 52 { 53 if (bReallyAbsolute) return aPos; 54 Rectangle aSnap(rObj.GetSnapRect()); 55 Rectangle aBound(rObj.GetSnapRect()); 56 Point aPt(aPos); 57 58 Point aOfs(aSnap.Center()); 59 switch (GetHorzAlign()) { 60 case SDRHORZALIGN_LEFT : aOfs.X()=aSnap.Left(); break; 61 case SDRHORZALIGN_RIGHT : aOfs.X()=aSnap.Right(); break; 62 } 63 switch (GetVertAlign()) { 64 case SDRVERTALIGN_TOP : aOfs.Y()=aSnap.Top(); break; 65 case SDRVERTALIGN_BOTTOM: aOfs.Y()=aSnap.Bottom(); break; 66 } 67 if (!bNoPercent) { 68 long nXMul=aSnap.Right()-aSnap.Left(); 69 long nYMul=aSnap.Bottom()-aSnap.Top(); 70 long nXDiv=10000; 71 long nYDiv=10000; 72 if (nXMul!=nXDiv) { 73 aPt.X()*=nXMul; 74 aPt.X()/=nXDiv; 75 } 76 if (nYMul!=nYDiv) { 77 aPt.Y()*=nYMul; 78 aPt.Y()/=nYDiv; 79 } 80 } 81 aPt+=aOfs; 82 // Und nun auf's BoundRect des Objekts begrenzen 83 if (aPt.X()<aBound.Left ()) aPt.X()=aBound.Left (); 84 if (aPt.X()>aBound.Right ()) aPt.X()=aBound.Right (); 85 if (aPt.Y()<aBound.Top ()) aPt.Y()=aBound.Top (); 86 if (aPt.Y()>aBound.Bottom()) aPt.Y()=aBound.Bottom(); 87 return aPt; 88 } 89 90 void SdrGluePoint::SetAbsolutePos(const Point& rNewPos, const SdrObject& rObj) 91 { 92 if (bReallyAbsolute) { 93 aPos=rNewPos; 94 return; 95 } 96 Rectangle aSnap(rObj.GetSnapRect()); 97 Point aPt(rNewPos); 98 99 Point aOfs(aSnap.Center()); 100 switch (GetHorzAlign()) { 101 case SDRHORZALIGN_LEFT : aOfs.X()=aSnap.Left(); break; 102 case SDRHORZALIGN_RIGHT : aOfs.X()=aSnap.Right(); break; 103 } 104 switch (GetVertAlign()) { 105 case SDRVERTALIGN_TOP : aOfs.Y()=aSnap.Top(); break; 106 case SDRVERTALIGN_BOTTOM: aOfs.Y()=aSnap.Bottom(); break; 107 } 108 aPt-=aOfs; 109 if (!bNoPercent) { 110 long nXMul=aSnap.Right()-aSnap.Left(); 111 long nYMul=aSnap.Bottom()-aSnap.Top(); 112 if (nXMul==0) nXMul=1; 113 if (nYMul==0) nYMul=1; 114 long nXDiv=10000; 115 long nYDiv=10000; 116 if (nXMul!=nXDiv) { 117 aPt.X()*=nXDiv; 118 aPt.X()/=nXMul; 119 } 120 if (nYMul!=nYDiv) { 121 aPt.Y()*=nYDiv; 122 aPt.Y()/=nYMul; 123 } 124 } 125 aPos=aPt; 126 } 127 128 long SdrGluePoint::GetAlignAngle() const 129 { 130 switch (nAlign) { 131 case SDRHORZALIGN_CENTER|SDRVERTALIGN_CENTER: return 0; // Invalid! 132 case SDRHORZALIGN_RIGHT |SDRVERTALIGN_CENTER: return 0; 133 case SDRHORZALIGN_RIGHT |SDRVERTALIGN_TOP : return 4500; 134 case SDRHORZALIGN_CENTER|SDRVERTALIGN_TOP : return 9000; 135 case SDRHORZALIGN_LEFT |SDRVERTALIGN_TOP : return 13500; 136 case SDRHORZALIGN_LEFT |SDRVERTALIGN_CENTER: return 18000; 137 case SDRHORZALIGN_LEFT |SDRVERTALIGN_BOTTOM: return 22500; 138 case SDRHORZALIGN_CENTER|SDRVERTALIGN_BOTTOM: return 27000; 139 case SDRHORZALIGN_RIGHT |SDRVERTALIGN_BOTTOM: return 31500; 140 } // switch 141 return 0; 142 } 143 144 void SdrGluePoint::SetAlignAngle(long nWink) 145 { 146 nWink=NormAngle360(nWink); 147 if (nWink>=33750 || nWink<2250) nAlign=SDRHORZALIGN_RIGHT |SDRVERTALIGN_CENTER; 148 else if (nWink< 6750) nAlign=SDRHORZALIGN_RIGHT |SDRVERTALIGN_TOP ; 149 else if (nWink<11250) nAlign=SDRHORZALIGN_CENTER|SDRVERTALIGN_TOP ; 150 else if (nWink<15750) nAlign=SDRHORZALIGN_LEFT |SDRVERTALIGN_TOP ; 151 else if (nWink<20250) nAlign=SDRHORZALIGN_LEFT |SDRVERTALIGN_CENTER; 152 else if (nWink<24750) nAlign=SDRHORZALIGN_LEFT |SDRVERTALIGN_BOTTOM; 153 else if (nWink<29250) nAlign=SDRHORZALIGN_CENTER|SDRVERTALIGN_BOTTOM; 154 else if (nWink<33750) nAlign=SDRHORZALIGN_RIGHT |SDRVERTALIGN_BOTTOM; 155 } 156 157 long SdrGluePoint::EscDirToAngle(sal_uInt16 nEsc) const 158 { 159 switch (nEsc) { 160 case SDRESC_RIGHT : return 0; 161 case SDRESC_TOP : return 9000; 162 case SDRESC_LEFT : return 18000; 163 case SDRESC_BOTTOM: return 27000; 164 } // switch 165 return 0; 166 } 167 168 sal_uInt16 SdrGluePoint::EscAngleToDir(long nWink) const 169 { 170 nWink=NormAngle360(nWink); 171 if (nWink>=31500 || nWink<4500) return SDRESC_RIGHT; 172 if (nWink<13500) return SDRESC_TOP; 173 if (nWink<22500) return SDRESC_LEFT; 174 if (nWink<31500) return SDRESC_BOTTOM; 175 return 0; 176 } 177 178 void SdrGluePoint::Rotate(const Point& rRef, long nWink, double sn, double cs, const SdrObject* pObj) 179 { 180 Point aPt(pObj!=NULL ? GetAbsolutePos(*pObj) : GetPos()); 181 RotatePoint(aPt,rRef,sn,cs); 182 // Bezugskante drehen 183 if(nAlign != (SDRHORZALIGN_CENTER|SDRVERTALIGN_CENTER)) 184 { 185 SetAlignAngle(GetAlignAngle()+nWink); 186 } 187 // rotate escape directions 188 sal_uInt16 nEscDir0=nEscDir; 189 sal_uInt16 nEscDir1=0; 190 if ((nEscDir0&SDRESC_LEFT )!=0) nEscDir1|=EscAngleToDir(EscDirToAngle(SDRESC_LEFT )+nWink); 191 if ((nEscDir0&SDRESC_TOP )!=0) nEscDir1|=EscAngleToDir(EscDirToAngle(SDRESC_TOP )+nWink); 192 if ((nEscDir0&SDRESC_RIGHT )!=0) nEscDir1|=EscAngleToDir(EscDirToAngle(SDRESC_RIGHT )+nWink); 193 if ((nEscDir0&SDRESC_BOTTOM)!=0) nEscDir1|=EscAngleToDir(EscDirToAngle(SDRESC_BOTTOM)+nWink); 194 nEscDir=nEscDir1; 195 if (pObj!=NULL) SetAbsolutePos(aPt,*pObj); else SetPos(aPt); 196 } 197 198 void SdrGluePoint::Mirror(const Point& rRef1, const Point& rRef2, const SdrObject* pObj) 199 { 200 Point aPt(rRef2); aPt-=rRef1; 201 long nWink=GetAngle(aPt); 202 Mirror(rRef1,rRef2,nWink,pObj); 203 } 204 205 void SdrGluePoint::Mirror(const Point& rRef1, const Point& rRef2, long nWink, const SdrObject* pObj) 206 { 207 Point aPt(pObj!=NULL ? GetAbsolutePos(*pObj) : GetPos()); 208 MirrorPoint(aPt,rRef1,rRef2); 209 // Bezugskante spiegeln 210 if(nAlign != (SDRHORZALIGN_CENTER|SDRVERTALIGN_CENTER)) 211 { 212 long nAW=GetAlignAngle(); 213 nAW+=2*(nWink-nAW); 214 SetAlignAngle(nAW); 215 } 216 // mirror escape directions 217 sal_uInt16 nEscDir0=nEscDir; 218 sal_uInt16 nEscDir1=0; 219 if ((nEscDir0&SDRESC_LEFT)!=0) { 220 long nEW=EscDirToAngle(SDRESC_LEFT); 221 nEW+=2*(nWink-nEW); 222 nEscDir1|=EscAngleToDir(nEW); 223 } 224 if ((nEscDir0&SDRESC_TOP)!=0) { 225 long nEW=EscDirToAngle(SDRESC_TOP); 226 nEW+=2*(nWink-nEW); 227 nEscDir1|=EscAngleToDir(nEW); 228 } 229 if ((nEscDir0&SDRESC_RIGHT)!=0) { 230 long nEW=EscDirToAngle(SDRESC_RIGHT); 231 nEW+=2*(nWink-nEW); 232 nEscDir1|=EscAngleToDir(nEW); 233 } 234 if ((nEscDir0&SDRESC_BOTTOM)!=0) { 235 long nEW=EscDirToAngle(SDRESC_BOTTOM); 236 nEW+=2*(nWink-nEW); 237 nEscDir1|=EscAngleToDir(nEW); 238 } 239 nEscDir=nEscDir1; 240 if (pObj!=NULL) SetAbsolutePos(aPt,*pObj); else SetPos(aPt); 241 } 242 243 void SdrGluePoint::Shear(const Point& rRef, long /*nWink*/, double tn, FASTBOOL bVShear, const SdrObject* pObj) 244 { 245 Point aPt(pObj!=NULL ? GetAbsolutePos(*pObj) : GetPos()); 246 ShearPoint(aPt,rRef,tn,bVShear); 247 if (pObj!=NULL) SetAbsolutePos(aPt,*pObj); else SetPos(aPt); 248 } 249 250 void SdrGluePoint::Invalidate(Window& rWin, const SdrObject* pObj) const 251 { 252 bool bMapMerk=rWin.IsMapModeEnabled(); 253 Point aPt(pObj!=NULL ? GetAbsolutePos(*pObj) : GetPos()); 254 aPt=rWin.LogicToPixel(aPt); 255 rWin.EnableMapMode(sal_False); 256 long x=aPt.X(),y=aPt.Y(); // size 9x9 pixel 257 258 // #111096# 259 // do not erase background, that causes flicker (!) 260 rWin.Invalidate(Rectangle(Point(x-4,y-4),Point(x+4,y+4)), INVALIDATE_NOERASE); 261 262 rWin.EnableMapMode(bMapMerk); 263 } 264 265 FASTBOOL SdrGluePoint::IsHit(const Point& rPnt, const OutputDevice& rOut, const SdrObject* pObj) const 266 { 267 Point aPt(pObj!=NULL ? GetAbsolutePos(*pObj) : GetPos()); 268 Size aSiz=rOut.PixelToLogic(Size(4,4)); 269 Rectangle aRect(aPt.X()-aSiz.Width(),aPt.Y()-aSiz.Height(),aPt.X()+aSiz.Width(),aPt.Y()+aSiz.Height()); 270 return aRect.IsInside(rPnt); 271 } 272 273 274 void SdrGluePointList::Clear() 275 { 276 sal_uInt16 nAnz=GetCount(); 277 for (sal_uInt16 i=0; i<nAnz; i++) { 278 delete GetObject(i); 279 } 280 aList.Clear(); 281 } 282 283 void SdrGluePointList::operator=(const SdrGluePointList& rSrcList) 284 { 285 if (GetCount()!=0) Clear(); 286 sal_uInt16 nAnz=rSrcList.GetCount(); 287 for (sal_uInt16 i=0; i<nAnz; i++) { 288 Insert(rSrcList[i]); 289 } 290 } 291 292 // Die Id's der Klebepunkte in der Liste sind stets streng monoton steigend! 293 // Ggf. wird dem neuen Klebepunkt eine neue Id zugewiesen (wenn diese bereits 294 // vergeben ist). Die Id 0 ist reserviert. 295 sal_uInt16 SdrGluePointList::Insert(const SdrGluePoint& rGP) 296 { 297 SdrGluePoint* pGP=new SdrGluePoint(rGP); 298 sal_uInt16 nId=pGP->GetId(); 299 sal_uInt16 nAnz=GetCount(); 300 sal_uInt16 nInsPos=nAnz; 301 sal_uInt16 nLastId=nAnz!=0 ? GetObject(nAnz-1)->GetId() : 0; 302 DBG_ASSERT(nLastId>=nAnz,"SdrGluePointList::Insert(): nLastId<nAnz"); 303 FASTBOOL bHole=nLastId>nAnz; 304 if (nId<=nLastId) { 305 if (!bHole || nId==0) { 306 nId=nLastId+1; 307 } else { 308 FASTBOOL bBrk=sal_False; 309 for (sal_uInt16 nNum=0; nNum<nAnz && !bBrk; nNum++) { 310 const SdrGluePoint* pGP2=GetObject(nNum); 311 sal_uInt16 nTmpId=pGP2->GetId(); 312 if (nTmpId==nId) { 313 nId=nLastId+1; // bereits vorhanden 314 bBrk=sal_True; 315 } 316 if (nTmpId>nId) { 317 nInsPos=nNum; // Hier einfuegen (einsortieren) 318 bBrk=sal_True; 319 } 320 } 321 } 322 pGP->SetId(nId); 323 } 324 aList.Insert(pGP,nInsPos); 325 return nInsPos; 326 } 327 328 void SdrGluePointList::Invalidate(Window& rWin, const SdrObject* pObj) const 329 { 330 sal_uInt16 nAnz=GetCount(); 331 for (sal_uInt16 nNum=0; nNum<nAnz; nNum++) { 332 GetObject(nNum)->Invalidate(rWin,pObj); 333 } 334 } 335 336 sal_uInt16 SdrGluePointList::FindGluePoint(sal_uInt16 nId) const 337 { 338 // TODO: Hier noch einen optimaleren Suchalgorithmus implementieren. 339 // Die Liste sollte stets sortiert sein! 340 sal_uInt16 nAnz=GetCount(); 341 sal_uInt16 nRet=SDRGLUEPOINT_NOTFOUND; 342 for (sal_uInt16 nNum=0; nNum<nAnz && nRet==SDRGLUEPOINT_NOTFOUND; nNum++) { 343 const SdrGluePoint* pGP=GetObject(nNum); 344 if (pGP->GetId()==nId) nRet=nNum; 345 } 346 return nRet; 347 } 348 349 sal_uInt16 SdrGluePointList::HitTest(const Point& rPnt, const OutputDevice& rOut, const SdrObject* pObj, FASTBOOL bBack, FASTBOOL bNext, sal_uInt16 nId0) const 350 { 351 sal_uInt16 nAnz=GetCount(); 352 sal_uInt16 nRet=SDRGLUEPOINT_NOTFOUND; 353 sal_uInt16 nNum=bBack ? 0 : nAnz; 354 while ((bBack ? nNum<nAnz : nNum>0) && nRet==SDRGLUEPOINT_NOTFOUND) { 355 if (!bBack) nNum--; 356 const SdrGluePoint* pGP=GetObject(nNum); 357 if (bNext) { 358 if (pGP->GetId()==nId0) bNext=sal_False; 359 } else { 360 if (pGP->IsHit(rPnt,rOut,pObj)) nRet=nNum; 361 } 362 if (bBack) nNum++; 363 } 364 return nRet; 365 } 366 367 void SdrGluePointList::SetReallyAbsolute(FASTBOOL bOn, const SdrObject& rObj) 368 { 369 sal_uInt16 nAnz=GetCount(); 370 for (sal_uInt16 nNum=0; nNum<nAnz; nNum++) { 371 GetObject(nNum)->SetReallyAbsolute(bOn,rObj); 372 } 373 } 374 375 void SdrGluePointList::Rotate(const Point& rRef, long nWink, double sn, double cs, const SdrObject* pObj) 376 { 377 sal_uInt16 nAnz=GetCount(); 378 for (sal_uInt16 nNum=0; nNum<nAnz; nNum++) { 379 GetObject(nNum)->Rotate(rRef,nWink,sn,cs,pObj); 380 } 381 } 382 383 void SdrGluePointList::Mirror(const Point& rRef1, const Point& rRef2, const SdrObject* pObj) 384 { 385 Point aPt(rRef2); aPt-=rRef1; 386 long nWink=GetAngle(aPt); 387 Mirror(rRef1,rRef2,nWink,pObj); 388 } 389 390 void SdrGluePointList::Mirror(const Point& rRef1, const Point& rRef2, long nWink, const SdrObject* pObj) 391 { 392 sal_uInt16 nAnz=GetCount(); 393 for (sal_uInt16 nNum=0; nNum<nAnz; nNum++) { 394 GetObject(nNum)->Mirror(rRef1,rRef2,nWink,pObj); 395 } 396 } 397 398 void SdrGluePointList::Shear(const Point& rRef, long nWink, double tn, FASTBOOL bVShear, const SdrObject* pObj) 399 { 400 sal_uInt16 nAnz=GetCount(); 401 for (sal_uInt16 nNum=0; nNum<nAnz; nNum++) { 402 GetObject(nNum)->Shear(rRef,nWink,tn,bVShear,pObj); 403 } 404 } 405 406 /* vim: set noet sw=4 ts=4: */ 407