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 27 // include --------------------------------------------------------------- 28 #include <tools/shl.hxx> 29 #include <vcl/svapp.hxx> 30 #include <svx/xtable.hxx> 31 #include <svx/xpool.hxx> 32 #include <svx/dialogs.hrc> 33 #include <accessibility.hrc> 34 #include <svx/dlgctrl.hxx> 35 #include <svx/dialmgr.hxx> 36 #include <tools/poly.hxx> 37 #include <vcl/region.hxx> 38 #include <vcl/gradient.hxx> 39 #include <vcl/hatch.hxx> 40 #ifndef _COM_SUN_STAR_ACCESSIBILITY_ACCESSIBLEEVENTOBJECT_HPP_ 41 #include <com/sun/star/accessibility/AccessibleEventObject.hpp> 42 #endif 43 #ifndef _COM_SUN_STAR_ACCESSIBILITY_ACCESSIBLEEVENTID_HPP_ 44 #include <com/sun/star/accessibility/AccessibleEventId.hpp> 45 #endif 46 #ifndef _COM_SUN_STAR_ACCESSIBILITY_ACCESSIBLESTATETYPE_HPP_ 47 #include <com/sun/star/accessibility/AccessibleStateType.hpp> 48 #endif 49 #include "svxpixelctlaccessiblecontext.hxx" 50 #include <svtools/colorcfg.hxx> 51 #include <svxrectctaccessiblecontext.hxx> 52 #include <com/sun/star/lang/XUnoTunnel.hpp> 53 #include <basegfx/point/b2dpoint.hxx> 54 #include <basegfx/polygon/b2dpolygon.hxx> 55 #include <svx/svdorect.hxx> 56 #include <svx/svdmodel.hxx> 57 #include <svx/svdopath.hxx> 58 #include <svx/sdr/contact/objectcontactofobjlistpainter.hxx> 59 #include <svx/sdr/contact/displayinfo.hxx> 60 #include <vcl/bmpacc.hxx> 61 #include <svx/xbtmpit.hxx> 62 63 #define OUTPUT_DRAWMODE_COLOR (DRAWMODE_DEFAULT) 64 #define OUTPUT_DRAWMODE_CONTRAST (DRAWMODE_SETTINGSLINE | DRAWMODE_SETTINGSFILL | DRAWMODE_SETTINGSTEXT | DRAWMODE_SETTINGSGRADIENT) 65 66 using namespace ::com::sun::star::uno; 67 using namespace ::com::sun::star::lang; 68 using namespace ::com::sun::star::accessibility; 69 70 71 /************************************************************************* 72 |* 73 |* Control zur Darstellung und Auswahl der Eckpunkte (und Mittelpunkt) 74 |* eines Objekts 75 |* 76 \************************************************************************/ 77 78 Bitmap& SvxRectCtl::GetRectBitmap( void ) 79 { 80 if( !pBitmap ) 81 InitRectBitmap(); 82 83 return *pBitmap; 84 } 85 86 SvxRectCtl::SvxRectCtl( Window* pParent, const ResId& rResId, RECT_POINT eRpt, 87 sal_uInt16 nBorder, sal_uInt16 nCircle, CTL_STYLE eStyle ) : 88 89 Control( pParent, rResId ), 90 91 pAccContext ( NULL ), 92 nBorderWidth( nBorder ), 93 nRadius ( nCircle), 94 eDefRP ( eRpt ), 95 eCS ( eStyle ), 96 pBitmap ( NULL ), 97 m_nState ( 0 ), 98 mbCompleteDisable(sal_False) 99 { 100 SetMapMode( MAP_100TH_MM ); 101 Resize_Impl(); 102 } 103 104 // ----------------------------------------------------------------------- 105 106 SvxRectCtl::~SvxRectCtl() 107 { 108 delete pBitmap; 109 110 if( pAccContext ) 111 pAccContext->release(); 112 } 113 114 // ----------------------------------------------------------------------- 115 void SvxRectCtl::Resize() 116 { 117 Resize_Impl(); 118 Control::Resize(); 119 } 120 121 // ----------------------------------------------------------------------- 122 123 void SvxRectCtl::Resize_Impl() 124 { 125 aSize = GetOutputSize(); 126 127 switch( eCS ) 128 { 129 case CS_RECT: 130 case CS_ANGLE: 131 case CS_SHADOW: 132 aPtLT = Point( 0 + nBorderWidth, 0 + nBorderWidth ); 133 aPtMT = Point( aSize.Width() / 2, 0 + nBorderWidth ); 134 aPtRT = Point( aSize.Width() - nBorderWidth, 0 + nBorderWidth ); 135 136 aPtLM = Point( 0 + nBorderWidth, aSize.Height() / 2 ); 137 aPtMM = Point( aSize.Width() / 2, aSize.Height() / 2 ); 138 aPtRM = Point( aSize.Width() - nBorderWidth, aSize.Height() / 2 ); 139 140 aPtLB = Point( 0 + nBorderWidth, aSize.Height() - nBorderWidth ); 141 aPtMB = Point( aSize.Width() / 2, aSize.Height() - nBorderWidth ); 142 aPtRB = Point( aSize.Width() - nBorderWidth, aSize.Height() - nBorderWidth ); 143 break; 144 145 case CS_LINE: 146 aPtLT = Point( 0 + 3 * nBorderWidth, 0 + nBorderWidth ); 147 aPtMT = Point( aSize.Width() / 2, 0 + nBorderWidth ); 148 aPtRT = Point( aSize.Width() - 3 * nBorderWidth, 0 + nBorderWidth ); 149 150 aPtLM = Point( 0 + 3 * nBorderWidth, aSize.Height() / 2 ); 151 aPtMM = Point( aSize.Width() / 2, aSize.Height() / 2 ); 152 aPtRM = Point( aSize.Width() - 3 * nBorderWidth, aSize.Height() / 2 ); 153 154 aPtLB = Point( 0 + 3 * nBorderWidth, aSize.Height() - nBorderWidth ); 155 aPtMB = Point( aSize.Width() / 2, aSize.Height() - nBorderWidth ); 156 aPtRB = Point( aSize.Width() - 3 * nBorderWidth, aSize.Height() - nBorderWidth ); 157 break; 158 } 159 Reset(); 160 InitSettings( sal_True, sal_True ); 161 } 162 // ----------------------------------------------------------------------- 163 164 void SvxRectCtl::InitRectBitmap( void ) 165 { 166 if( pBitmap ) 167 delete pBitmap; 168 169 const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings(); 170 svtools::ColorConfig aColorConfig; 171 172 pBitmap = new Bitmap( SVX_RES( RID_SVXCTRL_RECTBTNS ) ); 173 174 // set bitmap-colors 175 Color aColorAry1[7]; 176 Color aColorAry2[7]; 177 aColorAry1[0] = Color( 0xC0, 0xC0, 0xC0 ); // light-gray 178 aColorAry1[1] = Color( 0xFF, 0xFF, 0x00 ); // yellow 179 aColorAry1[2] = Color( 0xFF, 0xFF, 0xFF ); // white 180 aColorAry1[3] = Color( 0x80, 0x80, 0x80 ); // dark-gray 181 aColorAry1[4] = Color( 0x00, 0x00, 0x00 ); // black 182 aColorAry1[5] = Color( 0x00, 0xFF, 0x00 ); // green 183 aColorAry1[6] = Color( 0x00, 0x00, 0xFF ); // blue 184 aColorAry2[0] = rStyles.GetDialogColor(); // background 185 aColorAry2[1] = rStyles.GetWindowColor(); 186 aColorAry2[2] = rStyles.GetLightColor(); 187 aColorAry2[3] = rStyles.GetShadowColor(); 188 aColorAry2[4] = rStyles.GetDarkShadowColor(); 189 aColorAry2[5] = Color( aColorConfig.GetColorValue( svtools::FONTCOLOR ).nColor ); 190 aColorAry2[6] = rStyles.GetDialogColor(); 191 192 #ifdef DBG_UTIL 193 static sal_Bool bModify = sal_False; 194 sal_Bool& rModify = bModify; 195 if( rModify ) 196 { 197 static int n = 0; 198 static sal_uInt8 r = 0xFF; 199 static sal_uInt8 g = 0x00; 200 static sal_uInt8 b = 0xFF; 201 int& rn = n; 202 sal_uInt8& rr = r; 203 sal_uInt8& rg = g; 204 sal_uInt8& rb = b; 205 aColorAry2[ rn ] = Color( rr, rg, rb ); 206 } 207 #endif 208 209 pBitmap->Replace( aColorAry1, aColorAry2, 7, NULL ); 210 } 211 212 // ----------------------------------------------------------------------- 213 214 void SvxRectCtl::InitSettings( sal_Bool bForeground, sal_Bool bBackground ) 215 { 216 const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); 217 218 if( bForeground ) 219 { 220 svtools::ColorConfig aColorConfig; 221 Color aTextColor( aColorConfig.GetColorValue( svtools::FONTCOLOR ).nColor ); 222 223 if ( IsControlForeground() ) 224 aTextColor = GetControlForeground(); 225 SetTextColor( aTextColor ); 226 } 227 228 if( bBackground ) 229 { 230 if ( IsControlBackground() ) 231 SetBackground( GetControlBackground() ); 232 else 233 SetBackground( rStyleSettings.GetWindowColor() ); 234 } 235 236 delete pBitmap; 237 pBitmap = NULL; // forces new creating of bitmap 238 239 Invalidate(); 240 } 241 242 /************************************************************************* 243 |* 244 |* Das angeklickte Rechteck (3 x 3) wird ermittelt und der Parent (Dialog) 245 |* wird benachrichtigt, dass der Punkt geaendert wurde 246 |* 247 \************************************************************************/ 248 249 void SvxRectCtl::MouseButtonDown( const MouseEvent& rMEvt ) 250 { 251 // #103516# CompletelyDisabled() added to have a disabled state for SvxRectCtl 252 if(!IsCompletelyDisabled()) 253 { 254 Point aPtLast = aPtNew; 255 256 aPtNew = GetApproxLogPtFromPixPt( rMEvt.GetPosPixel() ); 257 258 if( aPtNew == aPtMM && ( eCS == CS_SHADOW || eCS == CS_ANGLE ) ) 259 { 260 aPtNew = aPtLast; 261 } 262 else 263 { 264 Invalidate( Rectangle( aPtLast - Point( nRadius, nRadius ), 265 aPtLast + Point( nRadius, nRadius ) ) ); 266 Invalidate( Rectangle( aPtNew - Point( nRadius, nRadius ), 267 aPtNew + Point( nRadius, nRadius ) ) ); 268 eRP = GetRPFromPoint( aPtNew ); 269 270 SetActualRP( eRP ); 271 272 if( WINDOW_TABPAGE == GetParent()->GetType() ) 273 ( (SvxTabPage*) GetParent() )->PointChanged( this, eRP ); 274 } 275 } 276 } 277 278 // ----------------------------------------------------------------------- 279 280 void SvxRectCtl::KeyInput( const KeyEvent& rKeyEvt ) 281 { 282 // #103516# CompletelyDisabled() added to have a disabled state for SvxRectCtl 283 if(!IsCompletelyDisabled()) 284 { 285 RECT_POINT eNewRP = eRP; 286 sal_Bool bUseMM = (eCS != CS_SHADOW) && (eCS != CS_ANGLE); 287 288 switch( rKeyEvt.GetKeyCode().GetCode() ) 289 { 290 case KEY_DOWN: 291 { 292 if( !(m_nState & CS_NOVERT) ) 293 switch( eNewRP ) 294 { 295 case RP_LT: eNewRP = RP_LM; break; 296 case RP_MT: eNewRP = bUseMM ? RP_MM : RP_MB; break; 297 case RP_RT: eNewRP = RP_RM; break; 298 case RP_LM: eNewRP = RP_LB; break; 299 case RP_MM: eNewRP = RP_MB; break; 300 case RP_RM: eNewRP = RP_RB; break; 301 default: ; //prevent warning 302 } 303 } 304 break; 305 case KEY_UP: 306 { 307 if( !(m_nState & CS_NOVERT) ) 308 switch( eNewRP ) 309 { 310 case RP_LM: eNewRP = RP_LT; break; 311 case RP_MM: eNewRP = RP_MT; break; 312 case RP_RM: eNewRP = RP_RT; break; 313 case RP_LB: eNewRP = RP_LM; break; 314 case RP_MB: eNewRP = bUseMM ? RP_MM : RP_MT; break; 315 case RP_RB: eNewRP = RP_RM; break; 316 default: ; //prevent warning 317 } 318 } 319 break; 320 case KEY_LEFT: 321 { 322 if( !(m_nState & CS_NOHORZ) ) 323 switch( eNewRP ) 324 { 325 case RP_MT: eNewRP = RP_LT; break; 326 case RP_RT: eNewRP = RP_MT; break; 327 case RP_MM: eNewRP = RP_LM; break; 328 case RP_RM: eNewRP = bUseMM ? RP_MM : RP_LM; break; 329 case RP_MB: eNewRP = RP_LB; break; 330 case RP_RB: eNewRP = RP_MB; break; 331 default: ; //prevent warning 332 } 333 } 334 break; 335 case KEY_RIGHT: 336 { 337 if( !(m_nState & CS_NOHORZ) ) 338 switch( eNewRP ) 339 { 340 case RP_LT: eNewRP = RP_MT; break; 341 case RP_MT: eNewRP = RP_RT; break; 342 case RP_LM: eNewRP = bUseMM ? RP_MM : RP_RM; break; 343 case RP_MM: eNewRP = RP_RM; break; 344 case RP_LB: eNewRP = RP_MB; break; 345 case RP_MB: eNewRP = RP_RB; break; 346 default: ; //prevent warning 347 } 348 } 349 break; 350 default: 351 Control::KeyInput( rKeyEvt ); 352 return; 353 } 354 if( eNewRP != eRP ) 355 { 356 SetActualRP( eNewRP ); 357 358 if( WINDOW_TABPAGE == GetParent()->GetType() ) 359 ( (SvxTabPage*) GetParent() )->PointChanged( this, eRP ); 360 361 SetFocusRect(); 362 } 363 } 364 } 365 366 // ----------------------------------------------------------------------- 367 368 void SvxRectCtl::StateChanged( StateChangedType nType ) 369 { 370 if ( nType == STATE_CHANGE_CONTROLFOREGROUND ) 371 InitSettings( sal_True, sal_False ); 372 else if ( nType == STATE_CHANGE_CONTROLBACKGROUND ) 373 InitSettings( sal_False, sal_True ); 374 375 Window::StateChanged( nType ); 376 } 377 378 // ----------------------------------------------------------------------- 379 380 void SvxRectCtl::DataChanged( const DataChangedEvent& rDCEvt ) 381 { 382 if ( ( rDCEvt.GetType() == DATACHANGED_SETTINGS ) && ( rDCEvt.GetFlags() & SETTINGS_STYLE ) ) 383 InitSettings( sal_True, sal_True ); 384 else 385 Window::DataChanged( rDCEvt ); 386 } 387 388 /************************************************************************* 389 |* 390 |* Zeichnet das Control (Rechteck mit 9 Kreisen) 391 |* 392 \************************************************************************/ 393 394 void SvxRectCtl::Paint( const Rectangle& ) 395 { 396 Point aPtDiff( PixelToLogic( Point( 1, 1 ) ) ); 397 398 const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings(); 399 400 SetLineColor( rStyles.GetDialogColor() ); 401 SetFillColor( rStyles.GetDialogColor() ); 402 DrawRect( Rectangle( Point(0,0), GetOutputSize() ) ); 403 404 if( IsEnabled() ) 405 SetLineColor( rStyles.GetLabelTextColor() ); 406 else 407 SetLineColor( rStyles.GetShadowColor() ); 408 409 SetFillColor(); 410 411 switch( eCS ) 412 { 413 414 case CS_RECT: 415 case CS_SHADOW: 416 if( !IsEnabled() ) 417 { 418 Color aOldCol = GetLineColor(); 419 SetLineColor( rStyles.GetLightColor() ); 420 DrawRect( Rectangle( aPtLT + aPtDiff, aPtRB + aPtDiff ) ); 421 SetLineColor( aOldCol ); 422 } 423 DrawRect( Rectangle( aPtLT, aPtRB ) ); 424 break; 425 426 case CS_LINE: 427 if( !IsEnabled() ) 428 { 429 Color aOldCol = GetLineColor(); 430 SetLineColor( rStyles.GetLightColor() ); 431 DrawLine( aPtLM - Point( 2 * nBorderWidth, 0) + aPtDiff, 432 aPtRM + Point( 2 * nBorderWidth, 0 ) + aPtDiff ); 433 SetLineColor( aOldCol ); 434 } 435 DrawLine( aPtLM - Point( 2 * nBorderWidth, 0), 436 aPtRM + Point( 2 * nBorderWidth, 0 ) ); 437 break; 438 439 case CS_ANGLE: 440 if( !IsEnabled() ) 441 { 442 Color aOldCol = GetLineColor(); 443 SetLineColor( rStyles.GetLightColor() ); 444 DrawLine( aPtLT + aPtDiff, aPtRB + aPtDiff ); 445 DrawLine( aPtLB + aPtDiff, aPtRT + aPtDiff ); 446 DrawLine( aPtLM + aPtDiff, aPtRM + aPtDiff ); 447 DrawLine( aPtMT + aPtDiff, aPtMB + aPtDiff ); 448 SetLineColor( aOldCol ); 449 } 450 DrawLine( aPtLT, aPtRB ); 451 DrawLine( aPtLB, aPtRT ); 452 DrawLine( aPtLM, aPtRM ); 453 DrawLine( aPtMT, aPtMB ); 454 break; 455 456 default: 457 break; 458 } 459 SetFillColor( GetBackground().GetColor() ); 460 461 Size aBtnSize( 11, 11 ); 462 Size aDstBtnSize( PixelToLogic( aBtnSize ) ); 463 Point aToCenter( aDstBtnSize.Width() >> 1, aDstBtnSize.Height() >> 1); 464 Point aBtnPnt1( IsEnabled()?0:22,0 ); 465 Point aBtnPnt2( 11,0 ); 466 Point aBtnPnt3( 22,0 ); 467 468 sal_Bool bNoHorz = (m_nState & CS_NOHORZ) != 0; 469 sal_Bool bNoVert = (m_nState & CS_NOVERT) != 0; 470 471 Bitmap& rBitmap = GetRectBitmap(); 472 473 // #103516# CompletelyDisabled() added to have a disabled state for SvxRectCtl 474 if(IsCompletelyDisabled()) 475 { 476 DrawBitmap( aPtLT - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap ); 477 DrawBitmap( aPtMT - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap ); 478 DrawBitmap( aPtRT - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap ); 479 DrawBitmap( aPtLM - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap ); 480 if( eCS == CS_RECT || eCS == CS_LINE ) 481 DrawBitmap( aPtMM - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap ); 482 DrawBitmap( aPtRM - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap ); 483 DrawBitmap( aPtLB - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap ); 484 DrawBitmap( aPtMB - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap ); 485 DrawBitmap( aPtRB - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap ); 486 } 487 else 488 { 489 DrawBitmap( aPtLT - aToCenter, aDstBtnSize, (bNoHorz | bNoVert)?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap ); 490 DrawBitmap( aPtMT - aToCenter, aDstBtnSize, bNoVert?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap ); 491 DrawBitmap( aPtRT - aToCenter, aDstBtnSize, (bNoHorz | bNoVert)?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap ); 492 493 DrawBitmap( aPtLM - aToCenter, aDstBtnSize, bNoHorz?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap ); 494 495 // Mittelpunkt bei Rechteck und Linie 496 if( eCS == CS_RECT || eCS == CS_LINE ) 497 DrawBitmap( aPtMM - aToCenter, aDstBtnSize, aBtnPnt1, aBtnSize, rBitmap ); 498 499 DrawBitmap( aPtRM - aToCenter, aDstBtnSize, bNoHorz?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap ); 500 501 DrawBitmap( aPtLB - aToCenter, aDstBtnSize, (bNoHorz | bNoVert)?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap ); 502 DrawBitmap( aPtMB - aToCenter, aDstBtnSize, bNoVert?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap ); 503 DrawBitmap( aPtRB - aToCenter, aDstBtnSize, (bNoHorz | bNoVert)?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap ); 504 } 505 506 // draw active button, avoid center pos for angle 507 // #103516# CompletelyDisabled() added to have a disabled state for SvxRectCtl 508 if(!IsCompletelyDisabled()) 509 { 510 if( IsEnabled() && (eCS != CS_ANGLE || aPtNew != aPtMM) ) 511 { 512 Point aCenterPt( aPtNew ); 513 aCenterPt -= aToCenter; 514 515 DrawBitmap( aCenterPt, aDstBtnSize, aBtnPnt2, aBtnSize, rBitmap ); 516 } 517 } 518 } 519 520 /************************************************************************* 521 |* 522 |* Konvertiert RECT_POINT in Point 523 |* 524 \************************************************************************/ 525 526 Point SvxRectCtl::GetPointFromRP( RECT_POINT _eRP) const 527 { 528 switch( _eRP ) 529 { 530 case RP_LT: return aPtLT; 531 case RP_MT: return aPtMT; 532 case RP_RT: return aPtRT; 533 case RP_LM: return aPtLM; 534 case RP_MM: return aPtMM; 535 case RP_RM: return aPtRM; 536 case RP_LB: return aPtLB; 537 case RP_MB: return aPtMB; 538 case RP_RB: return aPtRB; 539 } 540 return( aPtMM ); // default 541 } 542 543 544 void SvxRectCtl::SetFocusRect( const Rectangle* pRect ) 545 { 546 HideFocus(); 547 548 if( pRect ) 549 ShowFocus( *pRect ); 550 else 551 ShowFocus( CalculateFocusRectangle() ); 552 } 553 554 Point SvxRectCtl::SetActualRPWithoutInvalidate( RECT_POINT eNewRP ) 555 { 556 Point aPtLast = aPtNew; 557 aPtNew = GetPointFromRP( eNewRP ); 558 559 if( (m_nState & CS_NOHORZ) != 0 ) 560 aPtNew.X() = aPtMM.X(); 561 562 if( (m_nState & CS_NOVERT) != 0 ) 563 aPtNew.Y() = aPtMM.Y(); 564 565 eNewRP = GetRPFromPoint( aPtNew ); 566 567 eDefRP = eNewRP; 568 eRP = eNewRP; 569 570 return aPtLast; 571 } 572 573 void SvxRectCtl::GetFocus() 574 { 575 SetFocusRect(); 576 //Solution: Send the accessible focused event 577 Control::GetFocus(); 578 // Send accessibility event. 579 if(pAccContext) 580 { 581 pAccContext->FireChildFocus(GetActualRP()); 582 } 583 } 584 585 586 void SvxRectCtl::LoseFocus() 587 { 588 HideFocus(); 589 } 590 591 592 Point SvxRectCtl::GetApproxLogPtFromPixPt( const Point& rPt ) const 593 { 594 Point aPt = PixelToLogic( rPt ); 595 long x; 596 long y; 597 598 if( ( m_nState & CS_NOHORZ ) == 0 ) 599 { 600 if( aPt.X() < aSize.Width() / 3 ) 601 x = aPtLT.X(); 602 else if( aPt.X() < aSize.Width() * 2 / 3 ) 603 x = aPtMM.X(); 604 else 605 x = aPtRB.X(); 606 } 607 else 608 x = aPtMM.X(); 609 610 if( ( m_nState & CS_NOVERT ) == 0 ) 611 { 612 if( aPt.Y() < aSize.Height() / 3 ) 613 y = aPtLT.Y(); 614 else if( aPt.Y() < aSize.Height() * 2 / 3 ) 615 y = aPtMM.Y(); 616 else 617 y = aPtRB.Y(); 618 } 619 else 620 y = aPtMM.Y(); 621 622 return Point( x, y ); 623 } 624 625 626 /************************************************************************* 627 |* 628 |* Konvertiert Point in RECT_POINT 629 |* 630 \************************************************************************/ 631 632 RECT_POINT SvxRectCtl::GetRPFromPoint( Point aPt ) const 633 { 634 if ( aPt == aPtLT) return RP_LT; 635 else if( aPt == aPtMT) return RP_MT; 636 else if( aPt == aPtRT) return RP_RT; 637 else if( aPt == aPtLM) return RP_LM; 638 else if( aPt == aPtRM) return RP_RM; 639 else if( aPt == aPtLB) return RP_LB; 640 else if( aPt == aPtMB) return RP_MB; 641 else if( aPt == aPtRB) return RP_RB; 642 643 else 644 return RP_MM; // default 645 } 646 647 /************************************************************************* 648 |* 649 |* Bewirkt den Ursprungszustand des Controls 650 |* 651 \************************************************************************/ 652 653 void SvxRectCtl::Reset() 654 { 655 aPtNew = GetPointFromRP( eDefRP ); 656 eRP = eDefRP; 657 Invalidate(); 658 } 659 660 /************************************************************************* 661 |* 662 |* Gibt den aktuell ausgewaehlten RECT_POINT zur�ck 663 |* 664 \************************************************************************/ 665 666 RECT_POINT SvxRectCtl::GetActualRP() const 667 { 668 return( eRP ); 669 } 670 671 /************************************************************************* 672 |* 673 |* Gibt den aktuell ausgewaehlten RECT_POINT zur�ck 674 |* 675 \************************************************************************/ 676 void SvxRectCtl::SetActualRP( RECT_POINT eNewRP /* MT: , sal_Bool bFireFocus */ ) 677 { 678 // MT: bFireFox as API parameter is ugly... 679 Point aPtLast( SetActualRPWithoutInvalidate( eNewRP ) ); 680 681 Invalidate( Rectangle( aPtLast - Point( nRadius, nRadius ), aPtLast + Point( nRadius, nRadius ) ) ); 682 Invalidate( Rectangle( aPtNew - Point( nRadius, nRadius ), aPtNew + Point( nRadius, nRadius ) ) ); 683 684 // notify accessibility object about change 685 if( pAccContext ) 686 pAccContext->selectChild( eNewRP /* MT, bFireFocus */ ); 687 } 688 void SvxRectCtl::SetState( CTL_STATE nState ) 689 { 690 m_nState = nState; 691 692 Point aPtLast( GetPointFromRP( eRP ) ); 693 Point _aPtNew( aPtLast ); 694 695 if( (m_nState & CS_NOHORZ) != 0 ) 696 _aPtNew.X() = aPtMM.X(); 697 698 if( (m_nState & CS_NOVERT) != 0 ) 699 _aPtNew.Y() = aPtMM.Y(); 700 701 eRP = GetRPFromPoint( _aPtNew ); 702 Invalidate(); 703 704 if( WINDOW_TABPAGE == GetParent()->GetType() ) 705 ( (SvxTabPage*) GetParent() )->PointChanged( this, eRP ); 706 } 707 708 sal_uInt8 SvxRectCtl::GetNumOfChilds( void ) const 709 { 710 return ( eCS == CS_ANGLE )? 8 : 9; 711 } 712 713 Rectangle SvxRectCtl::CalculateFocusRectangle( void ) const 714 { 715 Size aDstBtnSize( PixelToLogic( Size( 15, 15 ) ) ); 716 return Rectangle( aPtNew - Point( aDstBtnSize.Width() >> 1, aDstBtnSize.Height() >> 1 ), aDstBtnSize ); 717 } 718 719 Rectangle SvxRectCtl::CalculateFocusRectangle( RECT_POINT eRectPoint ) const 720 { 721 Rectangle aRet; 722 RECT_POINT eOldRectPoint = GetActualRP(); 723 724 if( eOldRectPoint == eRectPoint ) 725 aRet = CalculateFocusRectangle(); 726 else 727 { 728 SvxRectCtl* pThis = const_cast< SvxRectCtl* >( this ); 729 730 pThis->SetActualRPWithoutInvalidate( eRectPoint ); // no invalidation because it's only temporary! 731 aRet = CalculateFocusRectangle(); 732 733 pThis->SetActualRPWithoutInvalidate( eOldRectPoint ); // no invalidation because nothing has changed! 734 } 735 736 return aRet; 737 } 738 739 Reference< XAccessible > SvxRectCtl::CreateAccessible() 740 { 741 Window* pParent = GetAccessibleParentWindow(); 742 743 DBG_ASSERT( pParent, "-SvxRectCtl::CreateAccessible(): No Parent!" ); 744 745 Reference< XAccessible > xAccParent = pParent->GetAccessible(); 746 if( xAccParent.is() ) 747 { 748 pAccContext = new SvxRectCtlAccessibleContext( xAccParent, *this ); 749 pAccContext->acquire(); 750 751 SetActualRP( GetActualRP() ); 752 753 return pAccContext; 754 } 755 else 756 return Reference< XAccessible >(); 757 } 758 759 RECT_POINT SvxRectCtl::GetApproxRPFromPixPt( const ::com::sun::star::awt::Point& r ) const 760 { 761 return GetRPFromPoint( GetApproxLogPtFromPixPt( Point( r.X, r.Y ) ) ); 762 } 763 764 // #103516# CompletelyDisabled() added to have a disabled state for SvxRectCtl 765 void SvxRectCtl::DoCompletelyDisable(sal_Bool bNew) 766 { 767 mbCompleteDisable = bNew; 768 Invalidate(); 769 } 770 771 /************************************************************************* 772 |* 773 |* Konstruktor ohne Size-Parameter 774 |* 775 \************************************************************************/ 776 777 SvxAngleCtl::SvxAngleCtl( Window* pParent, const ResId& rResId ) : 778 779 SvxRectCtl( pParent, rResId ), 780 781 aFont( Application::GetSettings().GetStyleSettings().GetAppFont() ) 782 { 783 aFontSize = Size( 250, 400 ); 784 Initialize(); 785 } 786 787 /************************************************************************* 788 |* 789 |* Konstruktor mit Size-Parameter 790 |* 791 \************************************************************************/ 792 793 SvxAngleCtl::SvxAngleCtl( Window* pParent, const ResId& rResId, Size _aSize ) : 794 795 SvxRectCtl( pParent, rResId ), 796 797 aFont( Application::GetSettings().GetStyleSettings().GetAppFont() ) 798 { 799 aFontSize = _aSize; 800 Initialize(); 801 } 802 803 /************************************************************************* 804 |* 805 |* Initialisierung 806 |* 807 \************************************************************************/ 808 809 void SvxAngleCtl::Initialize() 810 { 811 bPositive = sal_True; 812 813 // aFont.SetName( "Helvetica" ); 814 aFont.SetSize( aFontSize ); 815 aFont.SetWeight( WEIGHT_NORMAL ); 816 aFont.SetTransparent( sal_False ); 817 818 SetFont( aFont ); 819 } 820 821 /************************************************************************* 822 |* 823 |* Zeichnet das (Mini-)Koordinatensystem 824 |* 825 \************************************************************************/ 826 827 void SvxAngleCtl::Paint( const Rectangle& ) 828 { 829 SetLineColor( Color( COL_BLACK ) ); // PEN_DOT ??? 830 DrawLine( aPtLT - Point( 0, 0), aPtRB + Point( 0, 0 ) ); 831 DrawLine( aPtLB - Point( 0, 0), aPtRT + Point( 0, 0 ) ); 832 833 SetLineColor( Color( COL_BLACK ) ); 834 DrawLine( aPtLM - Point( 0, 0), aPtRM + Point( 0, 0 ) ); 835 DrawLine( aPtMT - Point( 0, 0), aPtMB + Point( 0, 0 ) ); 836 837 Point aDiff(aFontSize.Width() / 2, aFontSize.Height() / 2); 838 839 DrawText( aPtLT - aDiff, UniString::CreateFromAscii( 840 RTL_CONSTASCII_STRINGPARAM( "135" ) ) ); 841 DrawText( aPtLM - aDiff, UniString::CreateFromAscii( 842 RTL_CONSTASCII_STRINGPARAM( "180" ) ) ); 843 844 if ( bPositive ) 845 DrawText( aPtLB - aDiff, UniString::CreateFromAscii( 846 RTL_CONSTASCII_STRINGPARAM( "225" ) ) ); 847 else 848 DrawText( aPtLB - aDiff, UniString::CreateFromAscii( 849 RTL_CONSTASCII_STRINGPARAM( "-135" ) ) ); 850 851 aDiff.X() = aFontSize.Width(); 852 DrawText( aPtMT - aDiff, UniString::CreateFromAscii( 853 RTL_CONSTASCII_STRINGPARAM( "90" ) ) ); 854 DrawText( aPtRT - aDiff, UniString::CreateFromAscii( 855 RTL_CONSTASCII_STRINGPARAM( "45" ) ) ); 856 aDiff.X() = aDiff .X() * 3 / 2; 857 858 if ( bPositive ) 859 DrawText( aPtMB - aDiff, UniString::CreateFromAscii( 860 RTL_CONSTASCII_STRINGPARAM( "270" ) ) ); 861 else 862 DrawText( aPtMB - aDiff, UniString::CreateFromAscii( 863 RTL_CONSTASCII_STRINGPARAM( "-90" ) ) ); 864 865 DrawText( aPtRM - Point( 0, aDiff.Y() ), UniString::CreateFromAscii( 866 RTL_CONSTASCII_STRINGPARAM( "0" ) ) ); 867 aDiff.X() = aFontSize.Width() * 2; 868 869 if ( bPositive ) 870 DrawText( aPtRB - aDiff, UniString::CreateFromAscii( 871 RTL_CONSTASCII_STRINGPARAM( "315" ) ) ); 872 else 873 DrawText( aPtRB - aDiff, UniString::CreateFromAscii( 874 RTL_CONSTASCII_STRINGPARAM( "-45" ) ) ); 875 } 876 877 /************************************************************************* 878 |* 879 |* Control zum Editieren von Bitmaps 880 |* 881 \************************************************************************/ 882 883 ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > SvxPixelCtl::CreateAccessible() 884 { 885 if(!m_xAccess.is()) 886 { 887 m_xAccess = m_pAccess = new SvxPixelCtlAccessible(*this); 888 } 889 return m_xAccess; 890 } 891 892 //Logic Pixel 893 long SvxPixelCtl::PointToIndex(const Point &aPt) const 894 { 895 sal_uInt16 nX, nY; 896 897 nX = (sal_uInt16) ( aPt.X() * nLines / aRectSize.Width() ); 898 nY = (sal_uInt16) ( aPt.Y() * nLines / aRectSize.Height() ); 899 900 return nX + nY * nLines ; 901 } 902 Point SvxPixelCtl::IndexToPoint(long nIndex) const 903 { 904 DBG_ASSERT(nIndex >= 0 && nIndex < nSquares ," Check Index"); 905 906 sal_uInt16 nXIndex = nIndex % nLines ; 907 sal_uInt16 nYIndex = sal_uInt16(nIndex / nLines) ; 908 909 Point aPtTl; 910 aPtTl.Y() = aRectSize.Height() * nYIndex / nLines + 1; 911 aPtTl.X() = aRectSize.Width() * nXIndex / nLines + 1; 912 913 return aPtTl; 914 } 915 long SvxPixelCtl::GetFoucsPosIndex() const 916 { 917 return aFocusPosition.getX() + aFocusPosition.getY() * nLines ; 918 } 919 long SvxPixelCtl::ShowPosition( const Point &pt) 920 { 921 Point aPt = PixelToLogic( pt ); 922 923 sal_uInt16 nX, nY; 924 nX = (sal_uInt16) ( aPt.X() * nLines / aRectSize.Width() ); 925 nY = (sal_uInt16) ( aPt.Y() * nLines / aRectSize.Height() ); 926 927 ChangePixel( nX + nY * nLines ); 928 929 //Solution:Set new focus position and repaint 930 //Invalidate( Rectangle( aPtTl, aPtBr ) ); 931 aFocusPosition.setX(nX); 932 aFocusPosition.setY(nY); 933 Invalidate(Rectangle(Point(0,0),aRectSize)); 934 935 if( WINDOW_TABPAGE == GetParent()->GetType() ) 936 ( (SvxTabPage*) GetParent() )->PointChanged( this, RP_MM ); // RectPoint ist dummy 937 938 return GetFoucsPosIndex(); 939 940 } 941 SvxPixelCtl::SvxPixelCtl( Window* pParent, const ResId& rResId, sal_uInt16 nNumber ) : 942 Control ( pParent, rResId ), 943 nLines ( nNumber ), 944 bPaintable ( sal_True ) 945 //Solution:Initialize it's value to Point(0,0) 946 ,aFocusPosition(0,0) 947 { 948 // SetMapMode( MAP_100TH_MM ); 949 aRectSize = GetOutputSize(); 950 951 SetPixelColor( Color( COL_BLACK ) ); 952 SetBackgroundColor( Color( COL_WHITE ) ); 953 SetLineColor( Application::GetSettings().GetStyleSettings().GetShadowColor() ); 954 955 nSquares = nLines * nLines; 956 pPixel = new sal_uInt16[ nSquares ]; 957 rtl_zeroMemory(pPixel, nSquares * sizeof(sal_uInt16)); 958 m_pAccess=NULL; 959 } 960 961 /************************************************************************* 962 |* 963 |* Destruktor dealociert dyn. Array 964 |* 965 \************************************************************************/ 966 967 SvxPixelCtl::~SvxPixelCtl( ) 968 { 969 delete []pPixel; 970 } 971 972 /************************************************************************* 973 |* 974 |* Wechselt die Vordergrund- ,bzw. Hintergrundfarbe 975 |* 976 \************************************************************************/ 977 978 void SvxPixelCtl::ChangePixel( sal_uInt16 nPixel ) 979 { 980 if( *( pPixel + nPixel) == 0 ) 981 *( pPixel + nPixel) = 1; // koennte erweitert werden auf mehrere Farben 982 else 983 *( pPixel + nPixel) = 0; 984 } 985 986 /************************************************************************* 987 |* 988 |* Das angeklickte Rechteck wird ermittelt um die Farbe zu wechseln 989 |* 990 \************************************************************************/ 991 992 void SvxPixelCtl::MouseButtonDown( const MouseEvent& rMEvt ) 993 { 994 //Point aPt = PixelToLogic( rMEvt.GetPosPixel() ); 995 //Point aPtTl, aPtBr; 996 //sal_uInt16 nX, nY; 997 998 //nX = (sal_uInt16) ( aPt.X() * nLines / aRectSize.Width() ); 999 //nY = (sal_uInt16) ( aPt.Y() * nLines / aRectSize.Height() ); 1000 1001 //ChangePixel( nX + nY * nLines ); 1002 1003 //aPtTl.X() = aRectSize.Width() * nX / nLines + 1; 1004 //aPtBr.X() = aRectSize.Width() * (nX + 1) / nLines - 1; 1005 //aPtTl.Y() = aRectSize.Height() * nY / nLines + 1; 1006 //aPtBr.Y() = aRectSize.Height() * (nY + 1) / nLines - 1; 1007 1008 //Invalidate( Rectangle( aPtTl, aPtBr ) ); 1009 1010 //if( WINDOW_TABPAGE == GetParent()->GetType() ) 1011 // ( (SvxTabPage*) GetParent() )->PointChanged( this, RP_MM ); // RectPoint ist dummy 1012 //Solution:Grab focus when click in window 1013 if( !HasFocus() ) 1014 { 1015 GrabFocus(); 1016 } 1017 long nIndex = ShowPosition(rMEvt.GetPosPixel()); 1018 1019 if(m_pAccess) 1020 { 1021 m_pAccess->NotifyChild(nIndex,sal_True,sal_True); 1022 } 1023 } 1024 1025 /************************************************************************* 1026 |* 1027 |* Zeichnet das Control (Rechteck mit 9 Kreisen) 1028 |* 1029 \************************************************************************/ 1030 1031 void SvxPixelCtl::Paint( const Rectangle& ) 1032 { 1033 sal_uInt16 i, j, nTmp; 1034 Point aPtTl, aPtBr; 1035 1036 if( bPaintable ) 1037 { 1038 // Linien Zeichnen 1039 Control::SetLineColor( aLineColor ); 1040 for( i = 1; i < nLines; i++) 1041 { 1042 // horizontal 1043 nTmp = (sal_uInt16) ( aRectSize.Height() * i / nLines ); 1044 DrawLine( Point( 0, nTmp ), Point( aRectSize.Width(), nTmp ) ); 1045 // vertikal 1046 nTmp = (sal_uInt16) ( aRectSize.Width() * i / nLines ); 1047 DrawLine( Point( nTmp, 0 ), Point( nTmp, aRectSize.Height() ) ); 1048 } 1049 1050 // Rechtecke (Quadrate) zeichnen 1051 Control::SetLineColor(); 1052 sal_uInt16 nLastPixel = *pPixel ? 0 : 1; 1053 1054 for( i = 0; i < nLines; i++) 1055 { 1056 aPtTl.Y() = aRectSize.Height() * i / nLines + 1; 1057 aPtBr.Y() = aRectSize.Height() * (i + 1) / nLines - 1; 1058 1059 for( j = 0; j < nLines; j++) 1060 { 1061 aPtTl.X() = aRectSize.Width() * j / nLines + 1; 1062 aPtBr.X() = aRectSize.Width() * (j + 1) / nLines - 1; 1063 1064 if ( *( pPixel + i * nLines + j ) != nLastPixel ) 1065 { 1066 nLastPixel = *( pPixel + i * nLines + j ); 1067 // Farbe wechseln: 0 -> Hintergrundfarbe 1068 SetFillColor( nLastPixel ? aPixelColor : aBackgroundColor ); 1069 } 1070 DrawRect( Rectangle( aPtTl, aPtBr ) ); 1071 } 1072 } 1073 //Solution:Draw visual focus when has focus 1074 if( HasFocus() ) 1075 { 1076 ShowFocus(implCalFocusRect(aFocusPosition)); 1077 } 1078 } // bPaintable 1079 else 1080 { 1081 SetBackground( Wallpaper( Color( COL_LIGHTGRAY ) ) ); 1082 Control::SetLineColor( Color( COL_LIGHTRED ) ); 1083 DrawLine( Point( 0, 0 ), Point( aRectSize.Width(), aRectSize.Height() ) ); 1084 DrawLine( Point( 0, aRectSize.Height() ), Point( aRectSize.Width(), 0 ) ); 1085 } 1086 } 1087 //Solution:Caculate visual focus rectangle via focus position 1088 Rectangle SvxPixelCtl::implCalFocusRect( const Point& aPosition ) 1089 { 1090 long nLeft,nTop,nRight,nBottom; 1091 long i,j; 1092 i = aPosition.Y(); 1093 j = aPosition.X(); 1094 nLeft = aRectSize.Width() * j / nLines + 1; 1095 nRight = aRectSize.Width() * (j + 1) / nLines - 1; 1096 nTop = aRectSize.Height() * i / nLines + 1; 1097 nBottom = aRectSize.Height() * (i + 1) / nLines - 1; 1098 return Rectangle(nLeft,nTop,nRight,nBottom); 1099 } 1100 1101 //Solution:Keyboard fucntion 1102 void SvxPixelCtl::KeyInput( const KeyEvent& rKEvt ) 1103 { 1104 KeyCode aKeyCode = rKEvt.GetKeyCode(); 1105 sal_uInt16 nCode = aKeyCode.GetCode(); 1106 sal_Bool bIsMod = aKeyCode.IsShift() || aKeyCode.IsMod1() || aKeyCode.IsMod2(); 1107 1108 if( !bIsMod ) 1109 { 1110 Point pRepaintPoint( aRectSize.Width() *( aFocusPosition.getX() - 1)/ nLines - 1, 1111 aRectSize.Height() *( aFocusPosition.getY() - 1)/ nLines -1 1112 ); 1113 Size mRepaintSize( aRectSize.Width() *3/ nLines + 2,aRectSize.Height() *3/ nLines + 2); 1114 Rectangle mRepaintRect( pRepaintPoint, mRepaintSize ); 1115 sal_Bool bFocusPosChanged=sal_False; 1116 switch(nCode) 1117 { 1118 case KEY_LEFT: 1119 if((aFocusPosition.getX() >= 1)) 1120 { 1121 aFocusPosition.setX( aFocusPosition.getX() - 1 ); 1122 Invalidate(mRepaintRect); 1123 bFocusPosChanged=sal_True; 1124 } 1125 break; 1126 case KEY_RIGHT: 1127 if( aFocusPosition.getX() < (nLines - 1) ) 1128 { 1129 aFocusPosition.setX( aFocusPosition.getX() + 1 ); 1130 Invalidate(mRepaintRect); 1131 bFocusPosChanged=sal_True; 1132 } 1133 break; 1134 case KEY_UP: 1135 if((aFocusPosition.getY() >= 1)) 1136 { 1137 aFocusPosition.setY( aFocusPosition.getY() - 1 ); 1138 Invalidate(mRepaintRect); 1139 bFocusPosChanged=sal_True; 1140 } 1141 break; 1142 case KEY_DOWN: 1143 if( aFocusPosition.getY() < ( nLines - 1 ) ) 1144 { 1145 aFocusPosition.setY( aFocusPosition.getY() + 1 ); 1146 Invalidate(mRepaintRect); 1147 bFocusPosChanged=sal_True; 1148 } 1149 break; 1150 case KEY_SPACE: 1151 ChangePixel( sal_uInt16(aFocusPosition.getX() + aFocusPosition.getY() * nLines) ); 1152 Invalidate( implCalFocusRect(aFocusPosition) ); 1153 break; 1154 default: 1155 Control::KeyInput( rKEvt ); 1156 return; 1157 } 1158 if(m_xAccess.is()) 1159 { 1160 long nIndex = GetFoucsPosIndex(); 1161 switch(nCode) 1162 { 1163 case KEY_LEFT: 1164 case KEY_RIGHT: 1165 case KEY_UP: 1166 case KEY_DOWN: 1167 if (bFocusPosChanged) 1168 { 1169 m_pAccess->NotifyChild(nIndex,sal_False,sal_False); 1170 } 1171 break; 1172 case KEY_SPACE: 1173 m_pAccess->NotifyChild(nIndex,sal_False,sal_True); 1174 break; 1175 default: 1176 break; 1177 } 1178 } 1179 } 1180 else 1181 { 1182 Control::KeyInput( rKEvt ); 1183 } 1184 } 1185 1186 //Draw focus when get focus 1187 void SvxPixelCtl::GetFocus() 1188 { 1189 Invalidate(implCalFocusRect(aFocusPosition)); 1190 1191 if(m_pAccess) 1192 { 1193 m_pAccess->NotifyChild(GetFoucsPosIndex(),sal_True,sal_False); 1194 } 1195 1196 Control::GetFocus(); 1197 } 1198 1199 //Hide focus when lose focus 1200 void SvxPixelCtl::LoseFocus() 1201 { 1202 HideFocus(); 1203 if (m_pAccess) 1204 { 1205 m_pAccess->LoseFocus(); 1206 } 1207 Control::LoseFocus(); 1208 } 1209 1210 /************************************************************************* 1211 |* 1212 |* 1213 |* 1214 \************************************************************************/ 1215 1216 void SvxPixelCtl::SetXBitmap( const BitmapEx& rBitmapEx ) 1217 { 1218 BitmapColor aBack; 1219 BitmapColor aFront; 1220 1221 if(isHistorical8x8(rBitmapEx, aBack, aFront)) 1222 { 1223 Bitmap aBitmap(rBitmapEx.GetBitmap()); 1224 BitmapReadAccess* pRead = aBitmap.AcquireReadAccess(); 1225 1226 aBackgroundColor = aBack; 1227 aPixelColor = aFront; 1228 1229 for(sal_uInt16 i(0); i < nSquares; i++) 1230 { 1231 const BitmapColor aColor(pRead->GetColor(i/8, i%8)); 1232 1233 if(aColor == aBack) 1234 { 1235 *( pPixel + i ) = 0; 1236 } 1237 else 1238 { 1239 *( pPixel + i ) = 1; 1240 } 1241 } 1242 1243 aBitmap.ReleaseAccess(pRead); 1244 } 1245 } 1246 1247 /************************************************************************* 1248 |* 1249 |* Gibt ein bestimmtes Pixel zurueck 1250 |* 1251 \************************************************************************/ 1252 1253 sal_uInt16 SvxPixelCtl::GetBitmapPixel( const sal_uInt16 nPixel ) 1254 { 1255 return( *( pPixel + nPixel ) ); 1256 } 1257 1258 /************************************************************************* 1259 |* 1260 |* Bewirkt den Ursprungszustand des Controls 1261 |* 1262 \************************************************************************/ 1263 1264 void SvxPixelCtl::Reset() 1265 { 1266 // clear pixel area 1267 rtl_zeroMemory(pPixel, nSquares * sizeof(sal_uInt16)); 1268 Invalidate(); 1269 } 1270 1271 /************************************************************************* 1272 |* 1273 |* Ctor: BitmapCtl fuer SvxPixelCtl 1274 |* 1275 \************************************************************************/ 1276 1277 SvxBitmapCtl::SvxBitmapCtl( Window* /*pParent*/, const Size& rSize ) 1278 { 1279 aSize = rSize; 1280 // aVD.SetOutputSizePixel( aSize ); 1281 } 1282 1283 /************************************************************************* 1284 |* 1285 |* Dtor 1286 |* 1287 \************************************************************************/ 1288 1289 SvxBitmapCtl::~SvxBitmapCtl() 1290 { 1291 } 1292 1293 /************************************************************************* 1294 |* 1295 |* BitmapCtl: Gibt die Bitmap zurueck 1296 |* 1297 \************************************************************************/ 1298 1299 BitmapEx SvxBitmapCtl::GetBitmapEx() 1300 { 1301 const Bitmap aRetval(createHistorical8x8FromArray(pBmpArray, aPixelColor, aBackgroundColor)); 1302 1303 return BitmapEx(aRetval); 1304 } 1305 1306 /************************************************************************* 1307 |* 1308 |* Fuellt die Listbox mit Farben und Strings 1309 |* 1310 \************************************************************************/ 1311 1312 void ColorLB::Fill( const XColorListSharedPtr aColorTab ) 1313 { 1314 long nCount = aColorTab->Count(); 1315 XColorEntry* pEntry; 1316 SetUpdateMode( sal_False ); 1317 1318 for( long i = 0; i < nCount; i++ ) 1319 { 1320 pEntry = aColorTab->GetColor( i ); 1321 InsertEntry( pEntry->GetColor(), pEntry->GetName() ); 1322 } 1323 1324 AdaptDropDownLineCountToMaximum(); 1325 SetUpdateMode( sal_True ); 1326 } 1327 1328 /************************************************************************/ 1329 1330 void ColorLB::Append( const XColorEntry& rEntry ) 1331 { 1332 InsertEntry( rEntry.GetColor(), rEntry.GetName() ); 1333 AdaptDropDownLineCountToMaximum(); 1334 } 1335 1336 /************************************************************************/ 1337 1338 void ColorLB::Modify( const XColorEntry& rEntry, sal_uInt16 nPos ) 1339 { 1340 RemoveEntry( nPos ); 1341 InsertEntry( rEntry.GetColor(), rEntry.GetName(), nPos ); 1342 } 1343 1344 /************************************************************************* 1345 |* 1346 |* Fuellt die Listbox mit Farben und Strings 1347 |* 1348 \************************************************************************/ 1349 1350 void FillAttrLB::Fill( const XColorListSharedPtr aColorTab ) 1351 { 1352 long nCount = aColorTab->Count(); 1353 XColorEntry* pEntry; 1354 SetUpdateMode( sal_False ); 1355 1356 for( long i = 0; i < nCount; i++ ) 1357 { 1358 pEntry = aColorTab->GetColor( i ); 1359 InsertEntry( pEntry->GetColor(), pEntry->GetName() ); 1360 } 1361 1362 AdaptDropDownLineCountToMaximum(); 1363 SetUpdateMode( sal_True ); 1364 } 1365 1366 /************************************************************************* 1367 |* 1368 |* Fuellt die Listbox (vorlaeufig) mit Strings 1369 |* 1370 \************************************************************************/ 1371 1372 HatchingLB::HatchingLB( Window* pParent, ResId Id) 1373 : ListBox( pParent, Id ) 1374 { 1375 SetEdgeBlending(true); 1376 } 1377 1378 HatchingLB::HatchingLB( Window* pParent, WinBits aWB) 1379 : ListBox( pParent, aWB ) 1380 { 1381 SetEdgeBlending(true); 1382 } 1383 1384 void HatchingLB::Fill( const XHatchListSharedPtr aList ) 1385 { 1386 XHatchEntry* pEntry; 1387 long nCount = aList.get() ? aList->Count() : 0; 1388 1389 SetUpdateMode( sal_False ); 1390 1391 for( long i = 0; i < nCount; i++ ) 1392 { 1393 pEntry = aList->GetHatch( i ); 1394 const Bitmap aBitmap = aList->GetUiBitmap( i ); 1395 if( !aBitmap.IsEmpty() ) 1396 InsertEntry( pEntry->GetName(), aBitmap ); 1397 else 1398 InsertEntry( pEntry->GetName() ); 1399 } 1400 1401 AdaptDropDownLineCountToMaximum(); 1402 SetUpdateMode( sal_True ); 1403 } 1404 1405 /************************************************************************/ 1406 1407 void HatchingLB::Append( const XHatchEntry& rEntry, const Bitmap& rBitmap ) 1408 { 1409 if(!rBitmap.IsEmpty()) 1410 { 1411 InsertEntry( rEntry.GetName(), rBitmap ); 1412 } 1413 else 1414 { 1415 InsertEntry( rEntry.GetName() ); 1416 } 1417 1418 AdaptDropDownLineCountToMaximum(); 1419 } 1420 1421 /************************************************************************/ 1422 1423 void HatchingLB::Modify( const XHatchEntry& rEntry, sal_uInt16 nPos, const Bitmap& rBitmap ) 1424 { 1425 RemoveEntry( nPos ); 1426 1427 if( !rBitmap.IsEmpty() ) 1428 { 1429 InsertEntry( rEntry.GetName(), rBitmap, nPos ); 1430 } 1431 else 1432 { 1433 InsertEntry( rEntry.GetName(), nPos ); 1434 } 1435 } 1436 1437 /************************************************************************/ 1438 1439 void HatchingLB::SelectEntryByList( const XHatchListSharedPtr aList, const String& rStr, const XHatch& rHatch, sal_uInt16 nDist ) 1440 { 1441 long nCount = aList.get() ? aList->Count() : 0; 1442 XHatchEntry* pEntry; 1443 sal_Bool bFound = sal_False; 1444 String aStr; 1445 1446 long i; 1447 for( i = 0; i < nCount && !bFound; i++ ) 1448 { 1449 pEntry = aList->GetHatch( i ); 1450 1451 aStr = pEntry->GetName(); 1452 1453 if( rStr == aStr && rHatch == pEntry->GetHatch() ) 1454 bFound = sal_True; 1455 } 1456 if( bFound ) 1457 SelectEntryPos( (sal_uInt16) ( i - 1 + nDist ) ); 1458 } 1459 1460 /************************************************************************* 1461 |* 1462 |* Fuellt die Listbox (vorlaeufig) mit Strings 1463 |* 1464 \************************************************************************/ 1465 1466 void FillAttrLB::Fill( const XHatchListSharedPtr aList ) 1467 { 1468 long nCount = aList.get() ? aList->Count() : 0; 1469 XHatchEntry* pEntry; 1470 ListBox::SetUpdateMode( sal_False ); 1471 1472 for( long i = 0; i < nCount; i++ ) 1473 { 1474 pEntry = aList->GetHatch( i ); 1475 const Bitmap aBitmap = aList->GetUiBitmap( i ); 1476 if( !aBitmap.IsEmpty() ) 1477 ListBox::InsertEntry( pEntry->GetName(), aBitmap ); 1478 else 1479 InsertEntry( pEntry->GetName() ); 1480 } 1481 1482 AdaptDropDownLineCountToMaximum(); 1483 ListBox::SetUpdateMode( sal_True ); 1484 } 1485 1486 /************************************************************************* 1487 |* 1488 |* Fuellt die Listbox (vorlaeufig) mit Strings 1489 |* 1490 \************************************************************************/ 1491 1492 GradientLB::GradientLB( Window* pParent, ResId Id) 1493 : ListBox( pParent, Id ) 1494 { 1495 SetEdgeBlending(true); 1496 } 1497 1498 GradientLB::GradientLB( Window* pParent, WinBits aWB) 1499 : ListBox( pParent, aWB ) 1500 { 1501 SetEdgeBlending(true); 1502 } 1503 1504 void GradientLB::Fill( const XGradientListSharedPtr aList ) 1505 { 1506 XGradientEntry* pEntry; 1507 long nCount = aList.get() ? aList->Count() : 0; 1508 1509 SetUpdateMode( sal_False ); 1510 1511 for( long i = 0; i < nCount; i++ ) 1512 { 1513 pEntry = aList->GetGradient( i ); 1514 const Bitmap aBitmap = aList->GetUiBitmap( i ); 1515 if( !aBitmap.IsEmpty() ) 1516 InsertEntry( pEntry->GetName(), aBitmap ); 1517 else 1518 InsertEntry( pEntry->GetName() ); 1519 } 1520 1521 AdaptDropDownLineCountToMaximum(); 1522 SetUpdateMode( sal_True ); 1523 } 1524 1525 /************************************************************************/ 1526 1527 void GradientLB::Append( const XGradientEntry& rEntry, const Bitmap& rBitmap ) 1528 { 1529 if(!rBitmap.IsEmpty()) 1530 { 1531 InsertEntry( rEntry.GetName(), rBitmap ); 1532 } 1533 else 1534 { 1535 InsertEntry( rEntry.GetName() ); 1536 } 1537 1538 AdaptDropDownLineCountToMaximum(); 1539 } 1540 1541 /************************************************************************/ 1542 1543 void GradientLB::Modify( const XGradientEntry& rEntry, sal_uInt16 nPos, const Bitmap& rBitmap ) 1544 { 1545 RemoveEntry( nPos ); 1546 1547 if(!rBitmap.IsEmpty()) 1548 { 1549 InsertEntry( rEntry.GetName(), rBitmap, nPos ); 1550 } 1551 else 1552 { 1553 InsertEntry( rEntry.GetName(), nPos ); 1554 } 1555 } 1556 1557 /************************************************************************/ 1558 1559 void GradientLB::SelectEntryByList( const XGradientListSharedPtr aList, const String& rStr, const XGradient& rGradient, sal_uInt16 nDist ) 1560 { 1561 long nCount = aList.get() ? aList->Count() : 0; 1562 XGradientEntry* pEntry; 1563 sal_Bool bFound = sal_False; 1564 String aStr; 1565 1566 long i; 1567 for( i = 0; i < nCount && !bFound; i++ ) 1568 { 1569 pEntry = aList->GetGradient( i ); 1570 1571 aStr = pEntry->GetName(); 1572 1573 if( rStr == aStr && rGradient == pEntry->GetGradient() ) 1574 bFound = sal_True; 1575 } 1576 if( bFound ) 1577 SelectEntryPos( (sal_uInt16) ( i - 1 + nDist ) ); 1578 } 1579 1580 /************************************************************************* 1581 |* 1582 |* Fuellt die Listbox (vorlaeufig) mit Strings 1583 |* 1584 \************************************************************************/ 1585 1586 void FillAttrLB::Fill( const XGradientListSharedPtr aList ) 1587 { 1588 long nCount = aList.get() ? aList->Count() : 0; 1589 XGradientEntry* pEntry; 1590 ListBox::SetUpdateMode( sal_False ); 1591 1592 for( long i = 0; i < nCount; i++ ) 1593 { 1594 pEntry = aList->GetGradient( i ); 1595 const Bitmap aBitmap = aList->GetUiBitmap( i ); 1596 if( !aBitmap.IsEmpty() ) 1597 ListBox::InsertEntry( pEntry->GetName(), aBitmap ); 1598 else 1599 InsertEntry( pEntry->GetName() ); 1600 } 1601 1602 AdaptDropDownLineCountToMaximum(); 1603 ListBox::SetUpdateMode( sal_True ); 1604 } 1605 1606 /************************************************************************* 1607 |* 1608 |* Konstruktor von BitmapLB 1609 |* 1610 \************************************************************************/ 1611 1612 BitmapLB::BitmapLB(Window* pParent, ResId Id) 1613 : ListBox(pParent, Id), 1614 maBitmapEx() 1615 { 1616 SetEdgeBlending(true); 1617 } 1618 1619 /************************************************************************/ 1620 1621 namespace 1622 { 1623 void formatBitmapExToSize(BitmapEx& rBitmapEx, const Size& rSize) 1624 { 1625 if(!rBitmapEx.IsEmpty() && rSize.Width() > 0 && rSize.Height() > 0) 1626 { 1627 VirtualDevice aVirtualDevice; 1628 aVirtualDevice.SetOutputSizePixel(rSize); 1629 1630 if(rBitmapEx.IsTransparent()) 1631 { 1632 const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); 1633 1634 if(rStyleSettings.GetPreviewUsesCheckeredBackground()) 1635 { 1636 const Point aNull(0, 0); 1637 static const sal_uInt32 nLen(8); 1638 static const Color aW(COL_WHITE); 1639 static const Color aG(0xef, 0xef, 0xef); 1640 1641 aVirtualDevice.DrawCheckered(aNull, rSize, nLen, aW, aG); 1642 } 1643 else 1644 { 1645 aVirtualDevice.SetBackground(rStyleSettings.GetFieldColor()); 1646 aVirtualDevice.Erase(); 1647 } 1648 } 1649 1650 if(rBitmapEx.GetSizePixel().Width() >= rSize.Width() && rBitmapEx.GetSizePixel().Height() >= rSize.Height()) 1651 { 1652 static sal_uInt32 nScaleFlag(BMP_SCALE_FASTESTINTERPOLATE); 1653 1654 rBitmapEx.Scale(rSize, nScaleFlag); 1655 aVirtualDevice.DrawBitmapEx(Point(0, 0), rBitmapEx); 1656 } 1657 else 1658 { 1659 const Size aBitmapSize(rBitmapEx.GetSizePixel()); 1660 1661 for(sal_Int32 y(0); y < rSize.Height(); y += aBitmapSize.Height()) 1662 { 1663 for(sal_Int32 x(0); x < rSize.Width(); x += aBitmapSize.Width()) 1664 { 1665 aVirtualDevice.DrawBitmapEx( 1666 Point(x, y), 1667 rBitmapEx); 1668 } 1669 } 1670 } 1671 1672 rBitmapEx = aVirtualDevice.GetBitmap(Point(0, 0), rSize); 1673 } 1674 } 1675 } // end of anonymous namespace 1676 1677 /************************************************************************/ 1678 1679 void BitmapLB::Fill(const XBitmapListSharedPtr aList) 1680 { 1681 XBitmapEntry* pEntry; 1682 const long nCount(aList.get() ? aList->Count() : 0); 1683 const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); 1684 const Size aSize(rStyleSettings.GetListBoxPreviewDefaultPixelSize()); 1685 1686 SetUpdateMode(false); 1687 1688 for(long i(0); i < nCount; i++) 1689 { 1690 pEntry = aList->GetBitmap(i); 1691 maBitmapEx = pEntry->GetGraphicObject().GetGraphic().GetBitmapEx(); 1692 formatBitmapExToSize(maBitmapEx, aSize); 1693 InsertEntry(pEntry->GetName(), maBitmapEx); 1694 } 1695 1696 AdaptDropDownLineCountToMaximum(); 1697 SetUpdateMode(true); 1698 } 1699 1700 /************************************************************************/ 1701 1702 void BitmapLB::Append(const Size& rSize, const XBitmapEntry& rEntry) 1703 { 1704 maBitmapEx = rEntry.GetGraphicObject().GetGraphic().GetBitmapEx(); 1705 1706 if(!maBitmapEx.IsEmpty()) 1707 { 1708 formatBitmapExToSize(maBitmapEx, rSize); 1709 InsertEntry(rEntry.GetName(), maBitmapEx); 1710 } 1711 else 1712 { 1713 InsertEntry(rEntry.GetName()); 1714 } 1715 1716 AdaptDropDownLineCountToMaximum(); 1717 } 1718 1719 /************************************************************************/ 1720 1721 void BitmapLB::Modify(const Size& rSize, const XBitmapEntry& rEntry, sal_uInt16 nPos) 1722 { 1723 RemoveEntry(nPos); 1724 maBitmapEx = rEntry.GetGraphicObject().GetGraphic().GetBitmapEx(); 1725 1726 if(!maBitmapEx.IsEmpty()) 1727 { 1728 formatBitmapExToSize(maBitmapEx, rSize); 1729 InsertEntry(rEntry.GetName(), maBitmapEx, nPos); 1730 } 1731 else 1732 { 1733 InsertEntry(rEntry.GetName()); 1734 } 1735 } 1736 1737 /************************************************************************/ 1738 1739 void BitmapLB::SelectEntryByList(const XBitmapListSharedPtr aList, const String& rStr) 1740 { 1741 const long nCount(aList.get() ? aList->Count() : 0); 1742 XBitmapEntry* pEntry; 1743 bool bFound(false); 1744 long i(0); 1745 1746 for(i = 0; i < nCount && !bFound; i++) 1747 { 1748 pEntry = aList->GetBitmap(i); 1749 const String aStr(pEntry->GetName()); 1750 1751 if(rStr == aStr) 1752 { 1753 bFound = true; 1754 } 1755 } 1756 1757 if(bFound) 1758 { 1759 SelectEntryPos((sal_uInt16)(i - 1)); 1760 } 1761 } 1762 1763 /************************************************************************* 1764 |* 1765 |* Konstruktor von FillAttrLB 1766 |* 1767 \************************************************************************/ 1768 1769 FillAttrLB::FillAttrLB( Window* pParent, ResId Id ) 1770 : ColorListBox(pParent, Id), 1771 maBitmapEx() 1772 { 1773 } 1774 1775 /************************************************************************/ 1776 1777 FillAttrLB::FillAttrLB(Window* pParent, WinBits aWB) 1778 : ColorListBox(pParent, aWB) 1779 { 1780 } 1781 1782 /************************************************************************/ 1783 1784 void FillAttrLB::Fill(const XBitmapListSharedPtr aList) 1785 { 1786 const long nCount(aList.get() ? aList->Count() : 0); 1787 XBitmapEntry* pEntry; 1788 const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); 1789 const Size aSize(rStyleSettings.GetListBoxPreviewDefaultPixelSize()); 1790 1791 ListBox::SetUpdateMode(false); 1792 1793 for(long i(0); i < nCount; i++) 1794 { 1795 pEntry = aList->GetBitmap( i ); 1796 maBitmapEx = pEntry->GetGraphicObject().GetGraphic().GetBitmapEx(); 1797 formatBitmapExToSize(maBitmapEx, aSize); 1798 ListBox::InsertEntry(pEntry->GetName(), maBitmapEx); 1799 } 1800 1801 AdaptDropDownLineCountToMaximum(); 1802 ListBox::SetUpdateMode(true); 1803 } 1804 1805 /************************************************************************/ 1806 1807 void FillAttrLB::SelectEntryByList( const XBitmapListSharedPtr aList, const String& rStr) 1808 { 1809 const long nCount(aList.get() ? aList->Count() : 0); 1810 XBitmapEntry* pEntry; 1811 bool bFound(false); 1812 long i(0); 1813 1814 for(i = 0; i < nCount && !bFound; i++) 1815 { 1816 pEntry = aList->GetBitmap(i); 1817 const String aStr(pEntry->GetName()); 1818 1819 if(rStr == aStr) 1820 { 1821 bFound = true; 1822 } 1823 } 1824 1825 if(bFound) 1826 { 1827 SelectEntryPos((sal_uInt16)(i - 1)); 1828 } 1829 } 1830 1831 /************************************************************************* 1832 |* 1833 |* Fuellt die Listbox (vorlaeufig) mit Strings 1834 |* 1835 \************************************************************************/ 1836 1837 void FillTypeLB::Fill() 1838 { 1839 SetUpdateMode( sal_False ); 1840 1841 InsertEntry( String( SVX_RES( RID_SVXSTR_INVISIBLE ) ) ); 1842 InsertEntry( String( SVX_RES( RID_SVXSTR_COLOR ) ) ); 1843 InsertEntry( String( SVX_RES( RID_SVXSTR_GRADIENT ) ) ); 1844 InsertEntry( String( SVX_RES( RID_SVXSTR_HATCH ) ) ); 1845 InsertEntry( String( SVX_RES( RID_SVXSTR_BITMAP ) ) ); 1846 1847 AdaptDropDownLineCountToMaximum(); 1848 SetUpdateMode( sal_True ); 1849 } 1850 1851 /************************************************************************* 1852 |* 1853 |* Fuellt die Listbox (vorlaeufig) mit Strings 1854 |* 1855 \************************************************************************/ 1856 LineLB::LineLB(Window* pParent, ResId Id) 1857 : ListBox(pParent, Id), 1858 mbAddStandardFields(true) 1859 { 1860 // No EdgeBlending for LineStyle/Dash SetEdgeBlending(true); 1861 } 1862 1863 LineLB::LineLB(Window* pParent, WinBits aWB) 1864 : ListBox(pParent, aWB), 1865 mbAddStandardFields(true) 1866 { 1867 // No EdgeBlending for LineStyle/Dash SetEdgeBlending(true); 1868 } 1869 1870 LineLB::~LineLB() 1871 { 1872 } 1873 1874 void LineLB::setAddStandardFields(bool bNew) 1875 { 1876 if(getAddStandardFields() != bNew) 1877 { 1878 mbAddStandardFields = bNew; 1879 } 1880 } 1881 1882 void LineLB::Fill( const XDashListSharedPtr aList ) 1883 { 1884 Clear(); 1885 1886 if(getAddStandardFields() && aList.get()) 1887 { 1888 // entry for 'none' 1889 InsertEntry(aList->GetStringForUiNoLine()); 1890 1891 // entry for solid line 1892 InsertEntry(aList->GetStringForUiSolidLine(), aList->GetBitmapForUISolidLine()); 1893 } 1894 1895 // entries for dashed lines 1896 long nCount = aList.get() ? aList->Count() : 0; 1897 XDashEntry* pEntry; 1898 SetUpdateMode( sal_False ); 1899 1900 for( long i = 0; i < nCount; i++ ) 1901 { 1902 pEntry = aList->GetDash( i ); 1903 const Bitmap aBitmap = aList->GetUiBitmap( i ); 1904 if( !aBitmap.IsEmpty() ) 1905 { 1906 InsertEntry( pEntry->GetName(), aBitmap ); 1907 //delete pBitmap; 1908 } 1909 else 1910 InsertEntry( pEntry->GetName() ); 1911 } 1912 1913 AdaptDropDownLineCountToMaximum(); 1914 SetUpdateMode( sal_True ); 1915 } 1916 1917 /************************************************************************/ 1918 1919 void LineLB::Append( const XDashEntry& rEntry, const Bitmap& rBitmap ) 1920 { 1921 if(!rBitmap.IsEmpty()) 1922 { 1923 InsertEntry( rEntry.GetName(), rBitmap ); 1924 } 1925 else 1926 { 1927 InsertEntry( rEntry.GetName() ); 1928 } 1929 1930 AdaptDropDownLineCountToMaximum(); 1931 } 1932 1933 /************************************************************************/ 1934 1935 void LineLB::Modify( const XDashEntry& rEntry, sal_uInt16 nPos, const Bitmap& rBitmap ) 1936 { 1937 RemoveEntry( nPos ); 1938 1939 if(!rBitmap.IsEmpty()) 1940 { 1941 InsertEntry( rEntry.GetName(), rBitmap, nPos ); 1942 } 1943 else 1944 { 1945 InsertEntry( rEntry.GetName(), nPos ); 1946 } 1947 } 1948 1949 /************************************************************************/ 1950 1951 void LineLB::SelectEntryByList( const XDashListSharedPtr aList, const String& rStr, const XDash& rDash, sal_uInt16 nDist ) 1952 { 1953 long nCount = aList.get() ? aList->Count() : 0; 1954 XDashEntry* pEntry; 1955 sal_Bool bFound = sal_False; 1956 String aStr; 1957 XDash aDash; 1958 1959 long i; 1960 for( i = 0; i < nCount && !bFound; i++ ) 1961 { 1962 pEntry = aList->GetDash( i ); 1963 1964 aStr = pEntry->GetName(); 1965 aDash = pEntry->GetDash(); 1966 1967 if( rStr == aStr && rDash == aDash ) 1968 bFound = sal_True; 1969 } 1970 if( bFound ) 1971 SelectEntryPos( (sal_uInt16) ( i - 1 + nDist ) ); 1972 } 1973 1974 /************************************************************************* 1975 |* 1976 |* Fuellt die Listbox (vorlaeufig) mit Strings 1977 |* 1978 \************************************************************************/ 1979 LineEndLB::LineEndLB( Window* pParent, ResId Id ) 1980 : ListBox( pParent, Id ) 1981 { 1982 // No EdgeBlending for LineEnds SetEdgeBlending(true); 1983 } 1984 1985 LineEndLB::LineEndLB( Window* pParent, WinBits aWB ) 1986 : ListBox( pParent, aWB ) 1987 { 1988 // No EdgeBlending for LineEnds SetEdgeBlending(true); 1989 } 1990 1991 LineEndLB::~LineEndLB(void) 1992 { 1993 } 1994 1995 1996 void LineEndLB::Fill( const XLineEndListSharedPtr aList, bool bStart ) 1997 { 1998 long nCount = aList.get() ? aList->Count() : 0; 1999 XLineEndEntry* pEntry; 2000 VirtualDevice aVD; 2001 SetUpdateMode( sal_False ); 2002 2003 for( long i = 0; i < nCount; i++ ) 2004 { 2005 pEntry = aList->GetLineEnd( i ); 2006 const Bitmap aBitmap = aList->GetUiBitmap( i ); 2007 if( !aBitmap.IsEmpty() ) 2008 { 2009 Size aBmpSize( aBitmap.GetSizePixel() ); 2010 aVD.SetOutputSizePixel( aBmpSize, sal_False ); 2011 aVD.DrawBitmap( Point(), aBitmap ); 2012 InsertEntry( pEntry->GetName(), 2013 aVD.GetBitmap( bStart ? Point() : Point( aBmpSize.Width() / 2, 0 ), 2014 Size( aBmpSize.Width() / 2, aBmpSize.Height() ) ) ); 2015 //delete pBitmap; 2016 } 2017 else 2018 InsertEntry( pEntry->GetName() ); 2019 } 2020 2021 AdaptDropDownLineCountToMaximum(); 2022 SetUpdateMode( sal_True ); 2023 } 2024 2025 /************************************************************************/ 2026 2027 void LineEndLB::Append( const XLineEndEntry& rEntry, const Bitmap& rBitmap, bool bStart ) 2028 { 2029 if(!rBitmap.IsEmpty()) 2030 { 2031 VirtualDevice aVD; 2032 const Size aBmpSize(rBitmap.GetSizePixel()); 2033 2034 aVD.SetOutputSizePixel(aBmpSize, false); 2035 aVD.DrawBitmap(Point(), rBitmap); 2036 InsertEntry( 2037 rEntry.GetName(), 2038 aVD.GetBitmap(bStart ? Point() : Point(aBmpSize.Width() / 2, 0 ), Size(aBmpSize.Width() / 2, aBmpSize.Height()))); 2039 } 2040 else 2041 { 2042 InsertEntry(rEntry.GetName()); 2043 } 2044 2045 AdaptDropDownLineCountToMaximum(); 2046 } 2047 2048 /************************************************************************/ 2049 2050 void LineEndLB::Modify( const XLineEndEntry& rEntry, sal_uInt16 nPos, const Bitmap& rBitmap, bool bStart ) 2051 { 2052 RemoveEntry( nPos ); 2053 2054 if(!rBitmap.IsEmpty()) 2055 { 2056 VirtualDevice aVD; 2057 const Size aBmpSize(rBitmap.GetSizePixel()); 2058 2059 aVD.SetOutputSizePixel(aBmpSize, false); 2060 aVD.DrawBitmap(Point(), rBitmap); 2061 InsertEntry( 2062 rEntry.GetName(), 2063 aVD.GetBitmap(bStart ? Point() : Point( aBmpSize.Width() / 2, 0 ), Size( aBmpSize.Width() / 2, aBmpSize.Height())), 2064 nPos); 2065 } 2066 else 2067 { 2068 InsertEntry(rEntry.GetName(), nPos); 2069 } 2070 } 2071 2072 ////////////////////////////////////////////////////////////////////////////// 2073 2074 void SvxPreviewBase::InitSettings(bool bForeground, bool bBackground) 2075 { 2076 const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); 2077 2078 if(bForeground) 2079 { 2080 svtools::ColorConfig aColorConfig; 2081 Color aTextColor(aColorConfig.GetColorValue(svtools::FONTCOLOR).nColor); 2082 2083 if(IsControlForeground()) 2084 { 2085 aTextColor = GetControlForeground(); 2086 } 2087 2088 getBufferDevice().SetTextColor(aTextColor); 2089 } 2090 2091 if(bBackground) 2092 { 2093 if(IsControlBackground()) 2094 { 2095 getBufferDevice().SetBackground(GetControlBackground()); 2096 } 2097 else 2098 { 2099 getBufferDevice().SetBackground(rStyleSettings.GetWindowColor()); 2100 } 2101 } 2102 2103 // do not paint background self, it gets painted buffered 2104 SetControlBackground(); 2105 SetBackground(); 2106 2107 Invalidate(); 2108 } 2109 2110 SvxPreviewBase::SvxPreviewBase( Window* pParent, const ResId& rResId ) 2111 : Control( pParent, rResId ), 2112 mpModel( new SdrModel() ), 2113 mpBufferDevice( new VirtualDevice(*this) ) 2114 { 2115 // Draw the control's border as a flat thin black line. 2116 SetBorderStyle(WINDOW_BORDER_MONO); 2117 SetDrawMode( GetSettings().GetStyleSettings().GetHighContrastMode() ? OUTPUT_DRAWMODE_CONTRAST : OUTPUT_DRAWMODE_COLOR ); 2118 SetMapMode(MAP_100TH_MM); 2119 2120 // init model 2121 mpModel->GetItemPool().FreezeIdRanges(); 2122 } 2123 2124 SvxPreviewBase::~SvxPreviewBase() 2125 { 2126 delete mpModel; 2127 delete mpBufferDevice; 2128 } 2129 2130 void SvxPreviewBase::LocalPrePaint() 2131 { 2132 // init BufferDevice 2133 if(mpBufferDevice->GetOutputSizePixel() != GetOutputSizePixel()) 2134 { 2135 mpBufferDevice->SetDrawMode(GetDrawMode()); 2136 mpBufferDevice->SetSettings(GetSettings()); 2137 mpBufferDevice->SetAntialiasing(GetAntialiasing()); 2138 mpBufferDevice->SetOutputSizePixel(GetOutputSizePixel()); 2139 mpBufferDevice->SetMapMode(GetMapMode()); 2140 } 2141 2142 const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); 2143 2144 if(rStyleSettings.GetPreviewUsesCheckeredBackground()) 2145 { 2146 const Point aNull(0, 0); 2147 static const sal_uInt32 nLen(8); 2148 static const Color aW(COL_WHITE); 2149 static const Color aG(0xef, 0xef, 0xef); 2150 const bool bWasEnabled(mpBufferDevice->IsMapModeEnabled()); 2151 2152 mpBufferDevice->EnableMapMode(false); 2153 mpBufferDevice->DrawCheckered(aNull, mpBufferDevice->GetOutputSizePixel(), nLen, aW, aG); 2154 mpBufferDevice->EnableMapMode(bWasEnabled); 2155 } 2156 else 2157 { 2158 mpBufferDevice->Erase(); 2159 } 2160 } 2161 2162 void SvxPreviewBase::LocalPostPaint() 2163 { 2164 // copy to front (in pixel mode) 2165 const bool bWasEnabledSrc(mpBufferDevice->IsMapModeEnabled()); 2166 const bool bWasEnabledDst(IsMapModeEnabled()); 2167 const Point aEmptyPoint; 2168 2169 mpBufferDevice->EnableMapMode(false); 2170 EnableMapMode(false); 2171 2172 DrawOutDev( 2173 aEmptyPoint, GetOutputSizePixel(), 2174 aEmptyPoint, GetOutputSizePixel(), 2175 *mpBufferDevice); 2176 2177 mpBufferDevice->EnableMapMode(bWasEnabledSrc); 2178 EnableMapMode(bWasEnabledDst); 2179 } 2180 2181 void SvxPreviewBase::StateChanged(StateChangedType nType) 2182 { 2183 Control::StateChanged(nType); 2184 2185 if(STATE_CHANGE_CONTROLFOREGROUND == nType) 2186 { 2187 InitSettings(true, false); 2188 } 2189 else if(STATE_CHANGE_CONTROLBACKGROUND == nType) 2190 { 2191 InitSettings(false, true); 2192 } 2193 } 2194 2195 void SvxPreviewBase::DataChanged(const DataChangedEvent& rDCEvt) 2196 { 2197 SetDrawMode(GetSettings().GetStyleSettings().GetHighContrastMode() ? OUTPUT_DRAWMODE_CONTRAST : OUTPUT_DRAWMODE_COLOR); 2198 2199 if((DATACHANGED_SETTINGS == rDCEvt.GetType()) && (rDCEvt.GetFlags() & SETTINGS_STYLE)) 2200 { 2201 InitSettings(true, true); 2202 } 2203 else 2204 { 2205 Control::DataChanged(rDCEvt); 2206 } 2207 } 2208 2209 /************************************************************************* 2210 |* 2211 |* SvxXLinePreview::SvxXLinePreview() 2212 |* 2213 *************************************************************************/ 2214 2215 SvxXLinePreview::SvxXLinePreview( Window* pParent, const ResId& rResId ) 2216 : SvxPreviewBase( pParent, rResId ), 2217 mpLineObjA( 0L ), 2218 mpLineObjB( 0L ), 2219 mpLineObjC( 0L ), 2220 mpGraphic( 0L ), 2221 mbWithSymbol( sal_False ) 2222 { 2223 const Size aOutputSize(GetOutputSize()); 2224 InitSettings( sal_True, sal_True ); 2225 2226 const sal_Int32 nDistance(500L); 2227 const sal_Int32 nAvailableLength(aOutputSize.Width() - (4 * nDistance)); 2228 2229 // create DrawObectA 2230 const sal_Int32 aYPosA(aOutputSize.Height() / 2); 2231 const basegfx::B2DPoint aPointA1( nDistance, aYPosA); 2232 const basegfx::B2DPoint aPointA2( aPointA1.getX() + ((nAvailableLength * 14) / 20), aYPosA ); 2233 basegfx::B2DPolygon aPolygonA; 2234 aPolygonA.append(aPointA1); 2235 aPolygonA.append(aPointA2); 2236 mpLineObjA = new SdrPathObj(OBJ_LINE, basegfx::B2DPolyPolygon(aPolygonA)); 2237 mpLineObjA->SetModel(&getModel()); 2238 2239 // create DrawObectB 2240 const sal_Int32 aYPosB1((aOutputSize.Height() * 3) / 4); 2241 const sal_Int32 aYPosB2((aOutputSize.Height() * 1) / 4); 2242 const basegfx::B2DPoint aPointB1( aPointA2.getX() + nDistance, aYPosB1); 2243 const basegfx::B2DPoint aPointB2( aPointB1.getX() + ((nAvailableLength * 2) / 20), aYPosB2 ); 2244 const basegfx::B2DPoint aPointB3( aPointB2.getX() + ((nAvailableLength * 2) / 20), aYPosB1 ); 2245 basegfx::B2DPolygon aPolygonB; 2246 aPolygonB.append(aPointB1); 2247 aPolygonB.append(aPointB2); 2248 aPolygonB.append(aPointB3); 2249 mpLineObjB = new SdrPathObj(OBJ_PLIN, basegfx::B2DPolyPolygon(aPolygonB)); 2250 mpLineObjB->SetModel(&getModel()); 2251 2252 // create DrawObectC 2253 const basegfx::B2DPoint aPointC1( aPointB3.getX() + nDistance, aYPosB1); 2254 const basegfx::B2DPoint aPointC2( aPointC1.getX() + ((nAvailableLength * 1) / 20), aYPosB2 ); 2255 const basegfx::B2DPoint aPointC3( aPointC2.getX() + ((nAvailableLength * 1) / 20), aYPosB1 ); 2256 basegfx::B2DPolygon aPolygonC; 2257 aPolygonC.append(aPointC1); 2258 aPolygonC.append(aPointC2); 2259 aPolygonC.append(aPointC3); 2260 mpLineObjC = new SdrPathObj(OBJ_PLIN, basegfx::B2DPolyPolygon(aPolygonC)); 2261 mpLineObjC->SetModel(&getModel()); 2262 } 2263 2264 SvxXLinePreview::~SvxXLinePreview() 2265 { 2266 SdrObject::Free( mpLineObjA ); 2267 SdrObject::Free( mpLineObjB ); 2268 SdrObject::Free( mpLineObjC ); 2269 } 2270 2271 // ----------------------------------------------------------------------- 2272 2273 void SvxXLinePreview::SetSymbol(Graphic* p,const Size& s) 2274 { 2275 mpGraphic = p; 2276 maSymbolSize = s; 2277 } 2278 2279 // ----------------------------------------------------------------------- 2280 2281 void SvxXLinePreview::ResizeSymbol(const Size& s) 2282 { 2283 if ( s != maSymbolSize ) 2284 { 2285 maSymbolSize = s; 2286 Invalidate(); 2287 } 2288 } 2289 2290 // ----------------------------------------------------------------------- 2291 2292 void SvxXLinePreview::SetLineAttributes(const SfxItemSet& rItemSet) 2293 { 2294 // Set ItemSet at objects 2295 mpLineObjA->SetMergedItemSet(rItemSet); 2296 2297 // At line joints, do not use arrows 2298 SfxItemSet aTempSet(rItemSet); 2299 aTempSet.ClearItem(XATTR_LINESTART); 2300 aTempSet.ClearItem(XATTR_LINEEND); 2301 2302 mpLineObjB->SetMergedItemSet(aTempSet); 2303 mpLineObjC->SetMergedItemSet(aTempSet); 2304 } 2305 2306 // ----------------------------------------------------------------------- 2307 2308 void SvxXLinePreview::Paint( const Rectangle& ) 2309 { 2310 LocalPrePaint(); 2311 2312 // paint objects to buffer device 2313 sdr::contact::SdrObjectVector aObjectVector; 2314 aObjectVector.push_back(mpLineObjA); 2315 aObjectVector.push_back(mpLineObjB); 2316 aObjectVector.push_back(mpLineObjC); 2317 2318 sdr::contact::ObjectContactOfObjListPainter aPainter(getBufferDevice(), aObjectVector, 0); 2319 sdr::contact::DisplayInfo aDisplayInfo; 2320 2321 // do processing 2322 aPainter.ProcessDisplay(aDisplayInfo); 2323 2324 if ( mbWithSymbol && mpGraphic ) 2325 { 2326 const Size aOutputSize(GetOutputSize()); 2327 Point aPos = Point( aOutputSize.Width() / 3, aOutputSize.Height() / 2 ); 2328 aPos.X() -= maSymbolSize.Width() / 2; 2329 aPos.Y() -= maSymbolSize.Height() / 2; 2330 mpGraphic->Draw( &getBufferDevice(), aPos, maSymbolSize ); 2331 } 2332 2333 LocalPostPaint(); 2334 } 2335 2336 /************************************************************************* 2337 |* 2338 |* SvxXRectPreview::SvxXRectPreview() 2339 |* 2340 *************************************************************************/ 2341 2342 SvxXRectPreview::SvxXRectPreview( Window* pParent, const ResId& rResId ) 2343 : SvxPreviewBase( pParent, rResId ), 2344 mpRectangleObject(0) 2345 { 2346 InitSettings(true, true); 2347 2348 // create RectangleObject 2349 const Rectangle aObjectSize(Point(), GetOutputSize()); 2350 mpRectangleObject = new SdrRectObj(aObjectSize); 2351 mpRectangleObject->SetModel(&getModel()); 2352 } 2353 2354 SvxXRectPreview::~SvxXRectPreview() 2355 { 2356 SdrObject::Free(mpRectangleObject); 2357 } 2358 2359 void SvxXRectPreview::SetAttributes(const SfxItemSet& rItemSet) 2360 { 2361 mpRectangleObject->SetMergedItemSet(rItemSet, true); 2362 mpRectangleObject->SetMergedItem(XLineStyleItem(XLINE_NONE)); 2363 } 2364 2365 void SvxXRectPreview::Paint( const Rectangle& ) 2366 { 2367 LocalPrePaint(); 2368 2369 sdr::contact::SdrObjectVector aObjectVector; 2370 2371 aObjectVector.push_back(mpRectangleObject); 2372 2373 sdr::contact::ObjectContactOfObjListPainter aPainter(getBufferDevice(), aObjectVector, 0); 2374 sdr::contact::DisplayInfo aDisplayInfo; 2375 2376 aPainter.ProcessDisplay(aDisplayInfo); 2377 2378 LocalPostPaint(); 2379 } 2380 2381 /************************************************************************* 2382 |* 2383 |* SvxXShadowPreview::SvxXShadowPreview() 2384 |* 2385 *************************************************************************/ 2386 2387 SvxXShadowPreview::SvxXShadowPreview( Window* pParent, const ResId& rResId ) 2388 : SvxPreviewBase( pParent, rResId ), 2389 mpRectangleObject(0), 2390 mpRectangleShadow(0) 2391 { 2392 InitSettings(true, true); 2393 2394 // prepare size 2395 Size aSize = GetOutputSize(); 2396 aSize.Width() = aSize.Width() / 3; 2397 aSize.Height() = aSize.Height() / 3; 2398 2399 // create RectangleObject 2400 const Rectangle aObjectSize( Point( aSize.Width(), aSize.Height() ), aSize ); 2401 mpRectangleObject = new SdrRectObj(aObjectSize); 2402 mpRectangleObject->SetModel(&getModel()); 2403 2404 // create ShadowObject 2405 const Rectangle aShadowSize( Point( aSize.Width(), aSize.Height() ), aSize ); 2406 mpRectangleShadow = new SdrRectObj(aShadowSize); 2407 mpRectangleShadow->SetModel(&getModel()); 2408 } 2409 2410 SvxXShadowPreview::~SvxXShadowPreview() 2411 { 2412 SdrObject::Free(mpRectangleObject); 2413 SdrObject::Free(mpRectangleShadow); 2414 } 2415 2416 void SvxXShadowPreview::SetRectangleAttributes(const SfxItemSet& rItemSet) 2417 { 2418 mpRectangleObject->SetMergedItemSet(rItemSet, true); 2419 mpRectangleObject->SetMergedItem(XLineStyleItem(XLINE_NONE)); 2420 } 2421 2422 void SvxXShadowPreview::SetShadowAttributes(const SfxItemSet& rItemSet) 2423 { 2424 mpRectangleShadow->SetMergedItemSet(rItemSet, true); 2425 mpRectangleShadow->SetMergedItem(XLineStyleItem(XLINE_NONE)); 2426 } 2427 2428 void SvxXShadowPreview::SetShadowPosition(const Point& rPos) 2429 { 2430 Rectangle aObjectPosition(mpRectangleObject->GetSnapRect()); 2431 aObjectPosition.Move(rPos.X(), rPos.Y()); 2432 mpRectangleShadow->SetSnapRect(aObjectPosition); 2433 } 2434 2435 void SvxXShadowPreview::Paint( const Rectangle& ) 2436 { 2437 LocalPrePaint(); 2438 2439 sdr::contact::SdrObjectVector aObjectVector; 2440 2441 aObjectVector.push_back(mpRectangleShadow); 2442 aObjectVector.push_back(mpRectangleObject); 2443 2444 sdr::contact::ObjectContactOfObjListPainter aPainter(getBufferDevice(), aObjectVector, 0); 2445 sdr::contact::DisplayInfo aDisplayInfo; 2446 2447 aPainter.ProcessDisplay(aDisplayInfo); 2448 2449 LocalPostPaint(); 2450 } 2451 2452 // ----------------------------------------------------------------------- 2453 // eof 2454