sd/source/ui/func/smarttag.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: smarttag.cxx,v $
  10  * $Revision: 1.3 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sd.hxx"
  33
  34 #include "ViewShell.hxx"
  35 #include "smarttag.hxx"
  36 #include "Window.hxx"
  37 #include "View.hxx"
  38
  39 namespace sd
  40 {
  41
  42 // ====================================================================
  43
  44 SmartTag::SmartTag( ::sd::View& rView )
  45 : mrView( rView )
  46 , mbSelected( false )
  47 {
  48     SmartTagReference xThis( this );
  49     mrView.getSmartTags().add( xThis );
  50 }
  51
  52 // --------------------------------------------------------------------
  53
  54 SmartTag::~SmartTag()
  55 {
  56 }
  57
  58 // --------------------------------------------------------------------
  59
  60 bool SmartTag::MouseButtonDown( const MouseEvent&, SmartHdl&  )
  61 {
  62     return false;
  63 }
  64
  65 /** returns true if the SmartTag consumes this event. */
  66 bool SmartTag::KeyInput( const KeyEvent& /*rKEvt*/ )
  67 {
  68     return false;
  69 }
  70
  71 /** returns true if the SmartTag consumes this event. */
  72 bool SmartTag::RequestHelp( const HelpEvent& /*rHEvt*/ )
  73 {
  74     return false;
  75 }
  76
  77 /** returns true if the SmartTag consumes this event. */
  78 bool SmartTag::Command( const CommandEvent& /*rCEvt*/ )
  79 {
  80     return false;
  81 }
  82
  83 // --------------------------------------------------------------------
  84
  85 void SmartTag::addCustomHandles( SdrHdlList& /*rHandlerList*/ )
  86 {
  87 }
  88
  89 // --------------------------------------------------------------------
  90
  91 void SmartTag::select()
  92 {
  93     mbSelected = true;
  94 }
  95
  96 // --------------------------------------------------------------------
  97
  98 void SmartTag::deselect()
  99 {
 100     mbSelected = false;
 101 }
 102
 103 // --------------------------------------------------------------------
 104
 105 bool SmartTag::isSelected() const
 106 {
 107     return mbSelected;
 108 }
 109
 110 // --------------------------------------------------------------------
 111
 112 void SmartTag::disposing()
 113 {
 114     SmartTagReference xThis( this );
 115     mrView.getSmartTags().remove( xThis );
 116 }
 117
 118 // --------------------------------------------------------------------
 119
 120 bool SmartTag::getContext( SdrViewContext& /*rContext*/ )
 121 {
 122     return false;
 123 }
 124
 125 // --------------------------------------------------------------------
 126
 127 ULONG SmartTag::GetMarkablePointCount() const
 128 {
 129     return 0;
 130 }
 131
 132 // --------------------------------------------------------------------
 133
 134 ULONG SmartTag::GetMarkedPointCount() const
 135 {
 136     return 0;
 137 }
 138
 139 // --------------------------------------------------------------------
 140
 141 BOOL SmartTag::MarkPoint(SdrHdl& /*rHdl*/, BOOL /*bUnmark*/ )
 142 {
 143     return FALSE;
 144 }
 145
 146 // --------------------------------------------------------------------
 147
 148 BOOL SmartTag::MarkPoints(const Rectangle* /*pRect*/, BOOL /*bUnmark*/ )
 149 {
 150     return FALSE;
 151 }
 152
 153 // --------------------------------------------------------------------
 154
 155 void SmartTag::CheckPossibilities()
 156 {
 157 }
 158
 159 // ====================================================================
 160
 161 SmartTagSet::SmartTagSet( View& rView )
 162 : mrView( rView )
 163 {
 164 }
 165
 166 // --------------------------------------------------------------------
 167
 168 SmartTagSet::~SmartTagSet()
 169 {
 170 }
 171
 172 // --------------------------------------------------------------------
 173
 174 void SmartTagSet::add( const SmartTagReference& xTag )
 175 {
 176     maSet.insert( xTag );
 177     mrView.InvalidateAllWin();
 178 }
 179
 180 // --------------------------------------------------------------------
 181
 182 void SmartTagSet::remove( const SmartTagReference& xTag )
 183 {
 184     std::set< SmartTagReference >::iterator aIter( maSet.find( xTag ) );
 185     if( aIter != maSet.end() )
 186         maSet.erase( aIter );
 187     mrView.InvalidateAllWin();
 188 }
 189
 190 // --------------------------------------------------------------------
 191
 192 void SmartTagSet::Dispose()
 193 {
 194     std::set< SmartTagReference > aSet;
 195     aSet.swap( maSet );
 196     for( std::set< SmartTagReference >::iterator aIter( aSet.begin() ); aIter != aSet.end(); )
 197         (*aIter++)->Dispose();
 198     mrView.InvalidateAllWin();
 199 }
 200
 201 // --------------------------------------------------------------------
 202
 203 void SmartTagSet::select( const SmartTagReference& xTag )
 204 {
 205     if( mxSelectedTag != xTag )
 206     {
 207         if( mxSelectedTag.is() )
 208             mxSelectedTag->deselect();
 209
 210         mxSelectedTag = xTag;
 211         mxSelectedTag->select();
 212         mrView.SetPossibilitiesDirty();
 213         if( mrView.GetMarkedObjectCount() > 0 )
 214             mrView.UnmarkAllObj();
 215         else
 216             mrView.updateHandles();
 217     }
 218 }
 219
 220 // --------------------------------------------------------------------
 221
 222 void SmartTagSet::deselect()
 223 {
 224     if( mxSelectedTag.is() )
 225     {
 226         mxSelectedTag->deselect();
 227         mxSelectedTag.clear();
 228         mrView.SetPossibilitiesDirty();
 229         mrView.updateHandles();
 230     }
 231 }
 232
 233 // --------------------------------------------------------------------
 234
 235 bool SmartTagSet::MouseButtonDown( const MouseEvent& rMEvt )
 236 {
 237     Point aMDPos( mrView.GetViewShell()->GetActiveWindow()->PixelToLogic( rMEvt.GetPosPixel() ) );
 238     SdrHdl* pHdl = mrView.PickHandle(aMDPos);
 239
 240     // check if a smart tag is selected and no handle is hit
 241     if( mxSelectedTag.is() && !pHdl )
 242     {
 243         // deselect smart tag
 244         deselect();
 245         return false;
 246     }
 247
 248     // if a smart tag handle is hit, foreward event to its smart tag
 249     SmartHdl* pSmartHdl = dynamic_cast< SmartHdl* >( pHdl );
 250     if(pSmartHdl && pSmartHdl->getTag().is() )
 251     {
 252         SmartTagReference xTag( pSmartHdl->getTag() );
 253         return xTag->MouseButtonDown( rMEvt, *pSmartHdl );
 254     }
 255
 256     return false;
 257 }
 258
 259 // --------------------------------------------------------------------
 260
 261 bool SmartTagSet::KeyInput( const KeyEvent& rKEvt )
 262 {
 263     if( mxSelectedTag.is() )
 264         return mxSelectedTag->KeyInput( rKEvt );
 265     else if( rKEvt.GetKeyCode().GetCode() == KEY_SPACE )
 266     {
 267         SmartHdl* pSmartHdl = dynamic_cast< SmartHdl* >( mrView.GetHdlList().GetFocusHdl() );
 268         if( pSmartHdl )
 269         {
 270             const_cast< SdrHdlList& >( mrView.GetHdlList() ).ResetFocusHdl();
 271             SmartTagReference xTag( pSmartHdl->getTag() );
 272             select( xTag );
 273             return true;
 274         }
 275     }
 276
 277
 278     return false;
 279 }
 280
 281 // --------------------------------------------------------------------
 282
 283 bool SmartTagSet::RequestHelp( const HelpEvent& rHEvt )
 284 {
 285     Point aMDPos( mrView.GetViewShell()->GetActiveWindow()->PixelToLogic( rHEvt.GetMousePosPixel() ) );
 286     SdrHdl* pHdl = mrView.PickHandle(aMDPos);
 287
 288     if( pHdl )
 289     {
 290         // if a smart tag handle is hit, foreward event to its smart tag
 291         SmartHdl* pSmartHdl = dynamic_cast< SmartHdl* >( pHdl );
 292         if(pSmartHdl && pSmartHdl->getTag().is() )
 293         {
 294             SmartTagReference xTag( pSmartHdl->getTag() );
 295             return xTag->RequestHelp( rHEvt );
 296         }
 297     }
 298
 299     return false;
 300 }
 301
 302 // --------------------------------------------------------------------
 303
 304 /** returns true if the SmartTag consumes this event. */
 305 bool SmartTagSet::Command( const CommandEvent& rCEvt )
 306 {
 307     if( rCEvt.IsMouseEvent() )
 308     {
 309         Point aMDPos( mrView.GetViewShell()->GetActiveWindow()->PixelToLogic( rCEvt.GetMousePosPixel() ) );
 310         SdrHdl* pHdl = mrView.PickHandle(aMDPos);
 311
 312         if( pHdl )
 313         {
 314             // if a smart tag handle is hit, foreward event to its smart tag
 315             SmartHdl* pSmartHdl = dynamic_cast< SmartHdl* >( pHdl );
 316             if(pSmartHdl && pSmartHdl->getTag().is() )
 317             {
 318                 SmartTagReference xTag( pSmartHdl->getTag() );
 319                 return xTag->Command( rCEvt );
 320             }
 321         }
 322     }
 323     else
 324     {
 325         if( mxSelectedTag.is() )
 326             return mxSelectedTag->Command( rCEvt );
 327
 328     }
 329
 330     return false;
 331 }
 332
 333 // --------------------------------------------------------------------
 334
 335 void SmartTagSet::addCustomHandles( SdrHdlList& rHandlerList )
 336 {
 337     if( !maSet.empty() )
 338     {
 339         for( std::set< SmartTagReference >::iterator aIter( maSet.begin() ); aIter != maSet.end(); )
 340             (*aIter++)->addCustomHandles( rHandlerList );
 341     }
 342 }
 343
 344 // --------------------------------------------------------------------
 345
 346 /** returns true if the currently selected smart tag has
 347     a special context, returned in rContext. */
 348 bool SmartTagSet::getContext( SdrViewContext& rContext ) const
 349 {
 350     if( mxSelectedTag.is() )
 351         return mxSelectedTag->getContext( rContext );
 352     else
 353         return false;
 354 }
 355
 356 // --------------------------------------------------------------------
 357 // support point editing
 358 // --------------------------------------------------------------------
 359
 360 BOOL SmartTagSet::HasMarkablePoints() const
 361 {
 362     return GetMarkablePointCount() != 0 ? TRUE : FALSE;
 363 }
 364
 365 // --------------------------------------------------------------------
 366
 367 ULONG SmartTagSet::GetMarkablePointCount() const
 368 {
 369     if( mxSelectedTag.is() )
 370         return mxSelectedTag->GetMarkablePointCount();
 371     return 0;
 372 }
 373
 374 // --------------------------------------------------------------------
 375
 376 BOOL SmartTagSet::HasMarkedPoints() const
 377 {
 378     return GetMarkedPointCount() != 0 ? TRUE : FALSE;
 379 }
 380
 381 // --------------------------------------------------------------------
 382
 383 ULONG SmartTagSet::GetMarkedPointCount() const
 384 {
 385     if( mxSelectedTag.is() )
 386         return mxSelectedTag->GetMarkedPointCount();
 387     else
 388         return 0;
 389 }
 390
 391 // --------------------------------------------------------------------
 392
 393 BOOL SmartTagSet::IsPointMarkable(const SdrHdl& rHdl) const
 394 {
 395     const SmartHdl* pSmartHdl = dynamic_cast< const SmartHdl* >( &rHdl );
 396
 397     return pSmartHdl && pSmartHdl->isMarkable();
 398 }
 399
 400 // --------------------------------------------------------------------
 401
 402 BOOL SmartTagSet::MarkPoint(SdrHdl& rHdl, BOOL bUnmark )
 403 {
 404     if( mxSelectedTag.is() )
 405         return mxSelectedTag->MarkPoint( rHdl, bUnmark );
 406
 407     return FALSE;
 408 }
 409
 410 // --------------------------------------------------------------------
 411
 412 BOOL SmartTagSet::MarkPoints(const Rectangle* pRect, BOOL bUnmark)
 413 {
 414     if( mxSelectedTag.is() )
 415         return mxSelectedTag->MarkPoints( pRect, bUnmark );
 416     return FALSE;
 417 }
 418
 419 // --------------------------------------------------------------------
 420
 421 void SmartTagSet::CheckPossibilities()
 422 {
 423     if( mxSelectedTag.is() )
 424         mxSelectedTag->CheckPossibilities();
 425 }
 426
 427 // ====================================================================
 428
 429 SmartHdl::SmartHdl( const SmartTagReference& xTag, SdrObject* pObject, const Point& rPnt, SdrHdlKind eNewKind /*=HDL_MOVE*/ )
 430 : SdrHdl( rPnt, eNewKind )
 431 , mxTag( xTag )
 432 {
 433     SetObj( pObject );
 434 }
 435
 436 // --------------------------------------------------------------------
 437
 438 SmartHdl::SmartHdl( const SmartTagReference& xTag, const Point& rPnt, SdrHdlKind eNewKind /*=HDL_MOVE*/ )
 439 : SdrHdl( rPnt, eNewKind )
 440 , mxTag( xTag )
 441 {
 442 }
 443
 444 // --------------------------------------------------------------------
 445
 446 bool SmartHdl::isMarkable() const
 447 {
 448     return false;
 449 }
 450
 451 // ====================================================================
 452
 453 /*
 454 SmartProxyHdl::SmartProxyHdl( const SmartTagReference& xTag, SdrHdl* pProxyHdl )
 455 : SmartHdl( xTag, pProxyHdl->GetPos(), pProxyHdl->GetKind() )
 456 , mpProxyHdl( pProxyHdl )
 457 {
 458 }
 459
 460 // --------------------------------------------------------------------
 461
 462 SmartProxyHdl::~SmartProxyHdl()
 463 {
 464     delete mpProxyHdl;
 465 }
 466 */
 467 } // end of namespace sd
 468