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 // --------------------------------------------------------------------
  72
  73 void SmartTag::addCustomHandles( SdrHdlList& /*rHandlerList*/ )
  74 {
  75 }
  76
  77 // --------------------------------------------------------------------
  78
  79 void SmartTag::select()
  80 {
  81     mbSelected = true;
  82 }
  83
  84 // --------------------------------------------------------------------
  85
  86 void SmartTag::deselect()
  87 {
  88     mbSelected = false;
  89 }
  90
  91 // --------------------------------------------------------------------
  92
  93 bool SmartTag::isSelected() const
  94 {
  95     return mbSelected;
  96 }
  97
  98 // --------------------------------------------------------------------
  99
 100 void SmartTag::disposing()
 101 {
 102     SmartTagReference xThis( this );
 103     mrView.getSmartTags().remove( xThis );
 104 }
 105
 106 // --------------------------------------------------------------------
 107
 108 bool SmartTag::getContext( SdrViewContext& /*rContext*/ )
 109 {
 110     return false;
 111 }
 112
 113 // --------------------------------------------------------------------
 114
 115 ULONG SmartTag::GetMarkablePointCount() const
 116 {
 117     return 0;
 118 }
 119
 120 // --------------------------------------------------------------------
 121
 122 ULONG SmartTag::GetMarkedPointCount() const
 123 {
 124     return 0;
 125 }
 126
 127 // --------------------------------------------------------------------
 128
 129 BOOL SmartTag::MarkPoint(SdrHdl& /*rHdl*/, BOOL /*bUnmark*/ )
 130 {
 131     return FALSE;
 132 }
 133
 134 // --------------------------------------------------------------------
 135
 136 BOOL SmartTag::MarkPoints(const Rectangle* /*pRect*/, BOOL /*bUnmark*/ )
 137 {
 138     return FALSE;
 139 }
 140
 141 // --------------------------------------------------------------------
 142
 143 void SmartTag::CheckPossibilities()
 144 {
 145 }
 146
 147 // ====================================================================
 148
 149 SmartTagSet::SmartTagSet( View& rView )
 150 : mrView( rView )
 151 {
 152 }
 153
 154 // --------------------------------------------------------------------
 155
 156 SmartTagSet::~SmartTagSet()
 157 {
 158 }
 159
 160 // --------------------------------------------------------------------
 161
 162 void SmartTagSet::add( const SmartTagReference& xTag )
 163 {
 164     maSet.insert( xTag );
 165 }
 166
 167 // --------------------------------------------------------------------
 168
 169 void SmartTagSet::remove( const SmartTagReference& xTag )
 170 {
 171     std::set< SmartTagReference >::iterator aIter( maSet.find( xTag ) );
 172     if( aIter != maSet.end() )
 173         maSet.erase( aIter );
 174 }
 175
 176 // --------------------------------------------------------------------
 177
 178 void SmartTagSet::Dispose()
 179 {
 180     std::set< SmartTagReference > aSet;
 181     aSet.swap( maSet );
 182     for( std::set< SmartTagReference >::iterator aIter( aSet.begin() ); aIter != aSet.end(); )
 183         (*aIter++)->Dispose();
 184 }
 185
 186 // --------------------------------------------------------------------
 187
 188 void SmartTagSet::select( const SmartTagReference& xTag )
 189 {
 190     if( mxSelectedTag != xTag )
 191     {
 192         if( mxSelectedTag.is() )
 193             mxSelectedTag->deselect();
 194
 195         mxSelectedTag = xTag;
 196         mxSelectedTag->select();
 197         mrView.SetPossibilitiesDirty();
 198         if( mrView.GetMarkedObjectCount() > 0 )
 199             mrView.UnmarkAllObj();
 200         else
 201             mrView.updateHandles();
 202     }
 203 }
 204
 205 // --------------------------------------------------------------------
 206
 207 void SmartTagSet::deselect()
 208 {
 209     if( mxSelectedTag.is() )
 210     {
 211         mxSelectedTag->deselect();
 212         mxSelectedTag.clear();
 213         mrView.SetPossibilitiesDirty();
 214         mrView.updateHandles();
 215     }
 216 }
 217
 218 // --------------------------------------------------------------------
 219
 220 bool SmartTagSet::MouseButtonDown( const MouseEvent& rMEvt )
 221 {
 222     Point aMDPos( mrView.GetViewShell()->GetActiveWindow()->PixelToLogic( rMEvt.GetPosPixel() ) );
 223     SdrHdl* pHdl = mrView.PickHandle(aMDPos);
 224
 225     // check if a smart tag is selected and no handle is hit
 226     if( mxSelectedTag.is() && !pHdl )
 227     {
 228         // deselect smart tag
 229         deselect();
 230         return false;
 231     }
 232
 233     // if a smart tag handle is hit, foreward event to its smart tag
 234     SmartHdl* pSmartHdl = dynamic_cast< SmartHdl* >( pHdl );
 235     if(pSmartHdl && pSmartHdl->getTag().is() )
 236     {
 237         SmartTagReference xTag( pSmartHdl->getTag() );
 238         return xTag->MouseButtonDown( rMEvt, *pSmartHdl );
 239     }
 240
 241     return false;
 242 }
 243
 244 // --------------------------------------------------------------------
 245
 246 bool SmartTagSet::KeyInput( const KeyEvent& rKEvt )
 247 {
 248     if( mxSelectedTag.is() )
 249         return mxSelectedTag->KeyInput( rKEvt );
 250     else
 251         return false;
 252 }
 253
 254 // --------------------------------------------------------------------
 255
 256 void SmartTagSet::addCustomHandles( SdrHdlList& rHandlerList )
 257 {
 258     if( !maSet.empty() )
 259     {
 260         for( std::set< SmartTagReference >::iterator aIter( maSet.begin() ); aIter != maSet.end(); )
 261             (*aIter++)->addCustomHandles( rHandlerList );
 262     }
 263 }
 264
 265 // --------------------------------------------------------------------
 266
 267 /** returns true if the currently selected smart tag has
 268     a special context, returned in rContext. */
 269 bool SmartTagSet::getContext( SdrViewContext& rContext ) const
 270 {
 271     if( mxSelectedTag.is() )
 272         return mxSelectedTag->getContext( rContext );
 273     else
 274         return false;
 275 }
 276
 277 // --------------------------------------------------------------------
 278 // support point editing
 279 // --------------------------------------------------------------------
 280
 281 BOOL SmartTagSet::HasMarkablePoints() const
 282 {
 283     return GetMarkablePointCount() != 0 ? TRUE : FALSE;
 284 }
 285
 286 // --------------------------------------------------------------------
 287
 288 ULONG SmartTagSet::GetMarkablePointCount() const
 289 {
 290     if( mxSelectedTag.is() )
 291         return mxSelectedTag->GetMarkablePointCount();
 292     return 0;
 293 }
 294
 295 // --------------------------------------------------------------------
 296
 297 BOOL SmartTagSet::HasMarkedPoints() const
 298 {
 299     return GetMarkedPointCount() != 0 ? TRUE : FALSE;
 300 }
 301
 302 // --------------------------------------------------------------------
 303
 304 ULONG SmartTagSet::GetMarkedPointCount() const
 305 {
 306     if( mxSelectedTag.is() )
 307         return mxSelectedTag->GetMarkedPointCount();
 308     else
 309         return 0;
 310 }
 311
 312 // --------------------------------------------------------------------
 313
 314 BOOL SmartTagSet::IsPointMarkable(const SdrHdl& rHdl) const
 315 {
 316     const SmartHdl* pSmartHdl = dynamic_cast< const SmartHdl* >( &rHdl );
 317
 318     return pSmartHdl && pSmartHdl->isMarkable();
 319 }
 320
 321 // --------------------------------------------------------------------
 322
 323 BOOL SmartTagSet::MarkPoint(SdrHdl& rHdl, BOOL bUnmark )
 324 {
 325     if( mxSelectedTag.is() )
 326         return mxSelectedTag->MarkPoint( rHdl, bUnmark );
 327
 328     return FALSE;
 329 }
 330
 331 // --------------------------------------------------------------------
 332
 333 BOOL SmartTagSet::MarkPoints(const Rectangle* pRect, BOOL bUnmark)
 334 {
 335     if( mxSelectedTag.is() )
 336         return mxSelectedTag->MarkPoints( pRect, bUnmark );
 337     return FALSE;
 338 }
 339
 340 // --------------------------------------------------------------------
 341
 342 void SmartTagSet::CheckPossibilities()
 343 {
 344     if( mxSelectedTag.is() )
 345         mxSelectedTag->CheckPossibilities();
 346 }
 347
 348 // ====================================================================
 349
 350 SmartHdl::SmartHdl( const SmartTagReference& xTag, SdrObject* pObject, const Point& rPnt, SdrHdlKind eNewKind /*=HDL_MOVE*/ )
 351 : SdrHdl( rPnt, eNewKind )
 352 , mxTag( xTag )
 353 {
 354     SetObj( pObject );
 355 }
 356
 357 // --------------------------------------------------------------------
 358
 359 SmartHdl::SmartHdl( const SmartTagReference& xTag, const Point& rPnt, SdrHdlKind eNewKind /*=HDL_MOVE*/ )
 360 : SdrHdl( rPnt, eNewKind )
 361 , mxTag( xTag )
 362 {
 363 }
 364
 365 // --------------------------------------------------------------------
 366
 367 bool SmartHdl::isMarkable() const
 368 {
 369     return false;
 370 }
 371
 372 // ====================================================================
 373
 374 /*
 375 SmartProxyHdl::SmartProxyHdl( const SmartTagReference& xTag, SdrHdl* pProxyHdl )
 376 : SmartHdl( xTag, pProxyHdl->GetPos(), pProxyHdl->GetKind() )
 377 , mpProxyHdl( pProxyHdl )
 378 {
 379 }
 380
 381 // --------------------------------------------------------------------
 382
 383 SmartProxyHdl::~SmartProxyHdl()
 384 {
 385     delete mpProxyHdl;
 386 }
 387 */
 388 } // end of namespace sd
 389