basic/source/runtime/stdobj1.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <vcl/wrkwin.hxx>
  21 #include <vcl/svapp.hxx>
  22 #include <svtools/transfer.hxx>
  23 #include "runtime.hxx"
  24 #include "sbstdobj.hxx"
  25
  26 #define ATTR_IMP_TYPE           1
  27 #define ATTR_IMP_WIDTH          2
  28 #define ATTR_IMP_HEIGHT         3
  29 #define ATTR_IMP_BOLD           4
  30 #define ATTR_IMP_ITALIC         5
  31 #define ATTR_IMP_STRIKETHROUGH  6
  32 #define ATTR_IMP_UNDERLINE      7
  33 #define ATTR_IMP_SIZE           9
  34 #define ATTR_IMP_NAME           10
  35
  36 #define METH_CLEAR              20
  37 #define METH_GETDATA            21
  38 #define METH_GETFORMAT          22
  39 #define METH_GETTEXT            23
  40 #define METH_SETDATA            24
  41 #define METH_SETTEXT            25
  42
  43
  44 SbStdFactory::SbStdFactory()
  45 {
  46 }
  47
  48 SbxObject* SbStdFactory::CreateObject( const OUString& rClassName )
  49 {
  50     if( rClassName.equalsIgnoreAsciiCase("Picture") )
  51         return new SbStdPicture;
  52     else if( rClassName.equalsIgnoreAsciiCase("Font") )
  53         return new SbStdFont;
  54     else
  55         return NULL;
  56 }
  57
  58
  59
  60
  61
  62 void SbStdPicture::PropType( SbxVariable* pVar, SbxArray*, bool bWrite )
  63 {
  64     if( bWrite )
  65     {
  66         StarBASIC::Error( SbERR_PROP_READONLY );
  67         return;
  68     }
  69
  70     GraphicType eType = aGraphic.GetType();
  71     sal_Int16 nType = 0;
  72
  73     if( eType == GRAPHIC_BITMAP )
  74         nType = 1;
  75     else if( eType != GRAPHIC_NONE )
  76         nType = 2;
  77
  78     pVar->PutInteger( nType );
  79 }
  80
  81
  82 void SbStdPicture::PropWidth( SbxVariable* pVar, SbxArray*, bool bWrite )
  83 {
  84     if( bWrite )
  85     {
  86         StarBASIC::Error( SbERR_PROP_READONLY );
  87         return;
  88     }
  89
  90     Size aSize = aGraphic.GetPrefSize();
  91     aSize = Application::GetAppWindow()->LogicToPixel( aSize, aGraphic.GetPrefMapMode() );
  92     aSize = Application::GetAppWindow()->PixelToLogic( aSize, MapMode( MAP_TWIP ) );
  93
  94     pVar->PutInteger( (sal_Int16)aSize.Width() );
  95 }
  96
  97 void SbStdPicture::PropHeight( SbxVariable* pVar, SbxArray*, bool bWrite )
  98 {
  99     if( bWrite )
 100     {
 101         StarBASIC::Error( SbERR_PROP_READONLY );
 102         return;
 103     }
 104
 105     Size aSize = aGraphic.GetPrefSize();
 106     aSize = Application::GetAppWindow()->LogicToPixel( aSize, aGraphic.GetPrefMapMode() );
 107     aSize = Application::GetAppWindow()->PixelToLogic( aSize, MapMode( MAP_TWIP ) );
 108
 109     pVar->PutInteger( (sal_Int16)aSize.Height() );
 110 }
 111
 112
 113 TYPEINIT1( SbStdPicture, SbxObject );
 114
 115 SbStdPicture::SbStdPicture() :
 116     SbxObject( OUString("Picture"))
 117 {
 118     // Properties
 119     SbxVariable* p = Make( OUString("Type"), SbxCLASS_PROPERTY, SbxVARIANT );
 120     p->SetFlags( SBX_READ | SBX_DONTSTORE );
 121     p->SetUserData( ATTR_IMP_TYPE );
 122     p = Make( OUString("Width"), SbxCLASS_PROPERTY, SbxVARIANT );
 123     p->SetFlags( SBX_READ | SBX_DONTSTORE );
 124     p->SetUserData( ATTR_IMP_WIDTH );
 125     p = Make( OUString("Height"), SbxCLASS_PROPERTY, SbxVARIANT );
 126     p->SetFlags( SBX_READ | SBX_DONTSTORE );
 127     p->SetUserData( ATTR_IMP_HEIGHT );
 128 }
 129
 130 SbStdPicture::~SbStdPicture()
 131 {
 132 }
 133
 134
 135 SbxVariable* SbStdPicture::Find( const OUString& rName, SbxClassType t )
 136 {
 137     // entered already?
 138     return SbxObject::Find( rName, t );
 139 }
 140
 141
 142
 143 void SbStdPicture::SFX_NOTIFY( SfxBroadcaster& rBC, const TypeId& rBCType,
 144                                const SfxHint& rHint, const TypeId& rHintType )
 145
 146 {
 147     const SbxHint* pHint = dynamic_cast<const SbxHint*>(&rHint);
 148
 149     if( pHint )
 150     {
 151         if( pHint->GetId() == SBX_HINT_INFOWANTED )
 152         {
 153             SbxObject::SFX_NOTIFY( rBC, rBCType, rHint, rHintType );
 154             return;
 155         }
 156
 157         SbxVariable* pVar   = pHint->GetVar();
 158         SbxArray*    pPar_  = pVar->GetParameters();
 159         sal_uInt16       nWhich = (sal_uInt16)pVar->GetUserData();
 160         bool         bWrite = pHint->GetId() == SBX_HINT_DATACHANGED;
 161
 162         // Propteries
 163         switch( nWhich )
 164         {
 165             case ATTR_IMP_TYPE:     PropType( pVar, pPar_, bWrite ); return;
 166             case ATTR_IMP_WIDTH:    PropWidth( pVar, pPar_, bWrite ); return;
 167             case ATTR_IMP_HEIGHT:   PropHeight( pVar, pPar_, bWrite ); return;
 168         }
 169
 170         SbxObject::SFX_NOTIFY( rBC, rBCType, rHint, rHintType );
 171     }
 172 }
 173
 174
 175
 176 void SbStdFont::PropBold( SbxVariable* pVar, SbxArray*, bool bWrite )
 177 {
 178     if( bWrite )
 179         SetBold( pVar->GetBool() );
 180     else
 181         pVar->PutBool( IsBold() );
 182 }
 183
 184 void SbStdFont::PropItalic( SbxVariable* pVar, SbxArray*, bool bWrite )
 185 {
 186     if( bWrite )
 187         SetItalic( pVar->GetBool() );
 188     else
 189         pVar->PutBool( IsItalic() );
 190 }
 191
 192 void SbStdFont::PropStrikeThrough( SbxVariable* pVar, SbxArray*, bool bWrite )
 193 {
 194     if( bWrite )
 195         SetStrikeThrough( pVar->GetBool() );
 196     else
 197         pVar->PutBool( IsStrikeThrough() );
 198 }
 199
 200 void SbStdFont::PropUnderline( SbxVariable* pVar, SbxArray*, bool bWrite )
 201 {
 202     if( bWrite )
 203         SetUnderline( pVar->GetBool() );
 204     else
 205         pVar->PutBool( IsUnderline() );
 206 }
 207
 208 void SbStdFont::PropSize( SbxVariable* pVar, SbxArray*, bool bWrite )
 209 {
 210     if( bWrite )
 211         SetSize( (sal_uInt16)pVar->GetInteger() );
 212     else
 213         pVar->PutInteger( (sal_Int16)GetSize() );
 214 }
 215
 216 void SbStdFont::PropName( SbxVariable* pVar, SbxArray*, bool bWrite )
 217 {
 218     if( bWrite )
 219     {
 220         SetFontName( pVar->GetOUString() );
 221     }
 222     else
 223     {
 224         pVar->PutString( GetFontName() );
 225     }
 226 }
 227
 228 TYPEINIT1( SbStdFont, SbxObject );
 229
 230 SbStdFont::SbStdFont()
 231     : SbxObject( OUString("Font") )
 232     , bBold(false)
 233     , bItalic(false)
 234     , bStrikeThrough(false)
 235     , bUnderline(false)
 236     , nSize(0)
 237 {
 238     // Properties
 239     SbxVariable* p = Make( OUString("Bold"), SbxCLASS_PROPERTY, SbxVARIANT );
 240     p->SetFlags( SBX_READWRITE | SBX_DONTSTORE );
 241     p->SetUserData( ATTR_IMP_BOLD );
 242     p = Make( OUString("Italic"), SbxCLASS_PROPERTY, SbxVARIANT );
 243     p->SetFlags( SBX_READWRITE | SBX_DONTSTORE );
 244     p->SetUserData( ATTR_IMP_ITALIC );
 245     p = Make( OUString("StrikeThrough"), SbxCLASS_PROPERTY, SbxVARIANT );
 246     p->SetFlags( SBX_READWRITE | SBX_DONTSTORE );
 247     p->SetUserData( ATTR_IMP_STRIKETHROUGH );
 248     p = Make( OUString("Underline"), SbxCLASS_PROPERTY, SbxVARIANT );
 249     p->SetFlags( SBX_READWRITE | SBX_DONTSTORE );
 250     p->SetUserData( ATTR_IMP_UNDERLINE );
 251     p = Make( OUString("Size"), SbxCLASS_PROPERTY, SbxVARIANT );
 252     p->SetFlags( SBX_READWRITE | SBX_DONTSTORE );
 253     p->SetUserData( ATTR_IMP_SIZE );
 254
 255     // handle name property yourself
 256     p = Find( OUString("Name"), SbxCLASS_PROPERTY );
 257     assert(p && "No Name Property");
 258     p->SetUserData( ATTR_IMP_NAME );
 259 }
 260
 261 SbStdFont::~SbStdFont()
 262 {
 263 }
 264
 265 SbxVariable* SbStdFont::Find( const OUString& rName, SbxClassType t )
 266 {
 267     return SbxObject::Find( rName, t );
 268 }
 269
 270 void SbStdFont::SFX_NOTIFY( SfxBroadcaster& rBC, const TypeId& rBCType,
 271                             const SfxHint& rHint, const TypeId& rHintType )
 272 {
 273     const SbxHint* pHint = dynamic_cast<const SbxHint*>(&rHint);
 274
 275     if( pHint )
 276     {
 277         if( pHint->GetId() == SBX_HINT_INFOWANTED )
 278         {
 279             SbxObject::SFX_NOTIFY( rBC, rBCType, rHint, rHintType );
 280             return;
 281         }
 282
 283         SbxVariable* pVar   = pHint->GetVar();
 284         SbxArray*    pPar_  = pVar->GetParameters();
 285         sal_uInt16       nWhich = (sal_uInt16)pVar->GetUserData();
 286         bool         bWrite = pHint->GetId() == SBX_HINT_DATACHANGED;
 287
 288         // Propteries
 289         switch( nWhich )
 290         {
 291             case ATTR_IMP_BOLD:         PropBold( pVar, pPar_, bWrite ); return;
 292             case ATTR_IMP_ITALIC:       PropItalic( pVar, pPar_, bWrite ); return;
 293             case ATTR_IMP_STRIKETHROUGH:PropStrikeThrough( pVar, pPar_, bWrite ); return;
 294             case ATTR_IMP_UNDERLINE:    PropUnderline( pVar, pPar_, bWrite ); return;
 295             case ATTR_IMP_SIZE:         PropSize( pVar, pPar_, bWrite ); return;
 296             case ATTR_IMP_NAME:         PropName( pVar, pPar_, bWrite ); return;
 297         }
 298
 299         SbxObject::SFX_NOTIFY( rBC, rBCType, rHint, rHintType );
 300     }
 301 }
 302
 303
 304
 305
 306
 307 void SbStdClipboard::MethClear( SbxVariable*, SbxArray* pPar_, bool )
 308 {
 309     if( pPar_ && (pPar_->Count() > 1) )
 310     {
 311         StarBASIC::Error( SbERR_BAD_NUMBER_OF_ARGS );
 312         return;
 313     }
 314
 315 }
 316
 317 void SbStdClipboard::MethGetData( SbxVariable* pVar, SbxArray* pPar_, bool )
 318 {
 319     (void)pVar;
 320
 321     if( !pPar_ || (pPar_->Count() != 2) )
 322     {
 323         StarBASIC::Error( SbERR_BAD_NUMBER_OF_ARGS );
 324         return;
 325     }
 326
 327     sal_uInt16 nFormat = pPar_->Get(1)->GetInteger();
 328     if( !nFormat  || nFormat > 3 )
 329     {
 330         StarBASIC::Error( SbERR_BAD_ARGUMENT );
 331         return;
 332     }
 333
 334 }
 335
 336 void SbStdClipboard::MethGetFormat( SbxVariable* pVar, SbxArray* pPar_, bool )
 337 {
 338     if( !pPar_ || (pPar_->Count() != 2) )
 339     {
 340         StarBASIC::Error( SbERR_BAD_NUMBER_OF_ARGS );
 341         return;
 342     }
 343
 344     sal_uInt16 nFormat = pPar_->Get(1)->GetInteger();
 345     if( !nFormat  || nFormat > 3 )
 346     {
 347         StarBASIC::Error( SbERR_BAD_ARGUMENT );
 348         return;
 349     }
 350
 351     pVar->PutBool( false );
 352 }
 353
 354 void SbStdClipboard::MethGetText( SbxVariable* pVar, SbxArray* pPar_, bool )
 355 {
 356     if( pPar_ && (pPar_->Count() > 1) )
 357     {
 358         StarBASIC::Error( SbERR_BAD_NUMBER_OF_ARGS );
 359         return;
 360     }
 361
 362     pVar->PutString( OUString() );
 363 }
 364
 365 void SbStdClipboard::MethSetData( SbxVariable* pVar, SbxArray* pPar_, bool )
 366 {
 367     (void)pVar;
 368
 369     if( !pPar_ || (pPar_->Count() != 3) )
 370     {
 371         StarBASIC::Error( SbERR_BAD_NUMBER_OF_ARGS );
 372         return;
 373     }
 374
 375     sal_uInt16 nFormat = pPar_->Get(2)->GetInteger();
 376     if( !nFormat  || nFormat > 3 )
 377     {
 378         StarBASIC::Error( SbERR_BAD_ARGUMENT );
 379         return;
 380     }
 381
 382 }
 383
 384 void SbStdClipboard::MethSetText( SbxVariable* pVar, SbxArray* pPar_, bool )
 385 {
 386     (void)pVar;
 387
 388     if( !pPar_ || (pPar_->Count() != 2) )
 389     {
 390         StarBASIC::Error( SbERR_BAD_NUMBER_OF_ARGS );
 391         return;
 392     }
 393
 394 }
 395
 396
 397 TYPEINIT1( SbStdClipboard, SbxObject );
 398
 399 SbStdClipboard::SbStdClipboard() :
 400     SbxObject( OUString("Clipboard") )
 401 {
 402     SbxVariable* p = Find( OUString("Name"), SbxCLASS_PROPERTY );
 403     assert(p && "No Name Property");
 404     p->SetUserData( ATTR_IMP_NAME );
 405
 406     // register methods
 407     p = Make( OUString("Clear"), SbxCLASS_METHOD, SbxEMPTY );
 408     p->SetFlag( SBX_DONTSTORE );
 409     p->SetUserData( METH_CLEAR );
 410     p = Make( OUString("GetData"), SbxCLASS_METHOD, SbxEMPTY );
 411     p->SetFlag( SBX_DONTSTORE );
 412     p->SetUserData( METH_GETDATA );
 413     p = Make( OUString("GetFormat"), SbxCLASS_METHOD, SbxEMPTY );
 414     p->SetFlag( SBX_DONTSTORE );
 415     p->SetUserData( METH_GETFORMAT );
 416     p = Make( OUString("GetText"), SbxCLASS_METHOD, SbxEMPTY );
 417     p->SetFlag( SBX_DONTSTORE );
 418     p->SetUserData( METH_GETTEXT );
 419     p = Make( OUString("SetData"), SbxCLASS_METHOD, SbxEMPTY );
 420     p->SetFlag( SBX_DONTSTORE );
 421     p->SetUserData( METH_SETDATA );
 422     p = Make( OUString("SetText"), SbxCLASS_METHOD, SbxEMPTY );
 423     p->SetFlag( SBX_DONTSTORE );
 424     p->SetUserData( METH_SETTEXT );
 425 }
 426
 427 SbStdClipboard::~SbStdClipboard()
 428 {
 429 }
 430
 431
 432 SbxVariable* SbStdClipboard::Find( const OUString& rName, SbxClassType t )
 433 {
 434     return SbxObject::Find( rName, t );
 435 }
 436
 437
 438
 439 void SbStdClipboard::SFX_NOTIFY( SfxBroadcaster& rBC, const TypeId& rBCType,
 440                                  const SfxHint& rHint, const TypeId& rHintType )
 441 {
 442     const SbxHint* pHint = dynamic_cast<const SbxHint*>(&rHint);
 443
 444     if( pHint )
 445     {
 446         if( pHint->GetId() == SBX_HINT_INFOWANTED )
 447         {
 448             SbxObject::SFX_NOTIFY( rBC, rBCType, rHint, rHintType );
 449             return;
 450         }
 451
 452         SbxVariable* pVar   = pHint->GetVar();
 453         SbxArray*    pPar_  = pVar->GetParameters();
 454         sal_uInt16       nWhich = (sal_uInt16)pVar->GetUserData();
 455         bool         bWrite = pHint->GetId() == SBX_HINT_DATACHANGED;
 456
 457         // Methods
 458         switch( nWhich )
 459         {
 460             case METH_CLEAR:            MethClear( pVar, pPar_, bWrite ); return;
 461             case METH_GETDATA:          MethGetData( pVar, pPar_, bWrite ); return;
 462             case METH_GETFORMAT:        MethGetFormat( pVar, pPar_, bWrite ); return;
 463             case METH_GETTEXT:          MethGetText( pVar, pPar_, bWrite ); return;
 464             case METH_SETDATA:          MethSetData( pVar, pPar_, bWrite ); return;
 465             case METH_SETTEXT:          MethSetText( pVar, pPar_, bWrite ); return;
 466         }
 467
 468         SbxObject::SFX_NOTIFY( rBC, rBCType, rHint, rHintType );
 469     }
 470 }
 471
 472
 473 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */