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 <basic/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*, sal_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*, sal_Bool bWrite )
  83 {
  84     if( bWrite )
  85     {
  86         StarBASIC::Error( SbERR_PROP_READONLY );
  87         return;
  88     }
  89
  90     Size aSize = aGraphic.GetPrefSize();
  91     aSize = GetpApp()->GetAppWindow()->LogicToPixel( aSize, aGraphic.GetPrefMapMode() );
  92     aSize = GetpApp()->GetAppWindow()->PixelToLogic( aSize, MapMode( MAP_TWIP ) );
  93
  94     pVar->PutInteger( (sal_Int16)aSize.Width() );
  95 }
  96
  97 void SbStdPicture::PropHeight( SbxVariable* pVar, SbxArray*, sal_Bool bWrite )
  98 {
  99     if( bWrite )
 100     {
 101         StarBASIC::Error( SbERR_PROP_READONLY );
 102         return;
 103     }
 104
 105     Size aSize = aGraphic.GetPrefSize();
 106     aSize = GetpApp()->GetAppWindow()->LogicToPixel( aSize, aGraphic.GetPrefMapMode() );
 107     aSize = GetpApp()->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 = PTR_CAST( 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         sal_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*, sal_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*, sal_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*, sal_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*, sal_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*, sal_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*, sal_Bool bWrite )
 217 {
 218     if( bWrite )
 219     {
 220         SetFontName( pVar->GetOUString() );
 221     }
 222     else
 223     {
 224         pVar->PutString( GetFontName() );
 225     }
 226 }
 227
 228
 229 TYPEINIT1( SbStdFont, SbxObject );
 230
 231 SbStdFont::SbStdFont() :
 232     SbxObject( OUString("Font") )
 233 {
 234     // Properties
 235     SbxVariable* p = Make( OUString("Bold"), SbxCLASS_PROPERTY, SbxVARIANT );
 236     p->SetFlags( SBX_READWRITE | SBX_DONTSTORE );
 237     p->SetUserData( ATTR_IMP_BOLD );
 238     p = Make( OUString("Italic"), SbxCLASS_PROPERTY, SbxVARIANT );
 239     p->SetFlags( SBX_READWRITE | SBX_DONTSTORE );
 240     p->SetUserData( ATTR_IMP_ITALIC );
 241     p = Make( OUString("StrikeThrough"), SbxCLASS_PROPERTY, SbxVARIANT );
 242     p->SetFlags( SBX_READWRITE | SBX_DONTSTORE );
 243     p->SetUserData( ATTR_IMP_STRIKETHROUGH );
 244     p = Make( OUString("Underline"), SbxCLASS_PROPERTY, SbxVARIANT );
 245     p->SetFlags( SBX_READWRITE | SBX_DONTSTORE );
 246     p->SetUserData( ATTR_IMP_UNDERLINE );
 247     p = Make( OUString("Size"), SbxCLASS_PROPERTY, SbxVARIANT );
 248     p->SetFlags( SBX_READWRITE | SBX_DONTSTORE );
 249     p->SetUserData( ATTR_IMP_SIZE );
 250
 251     // handle name property yourself
 252     p = Find( OUString("Name"), SbxCLASS_PROPERTY );
 253     DBG_ASSERT( p, "No Name Property" );
 254     p->SetUserData( ATTR_IMP_NAME );
 255 }
 256
 257 SbStdFont::~SbStdFont()
 258 {
 259 }
 260
 261
 262 SbxVariable* SbStdFont::Find( const OUString& rName, SbxClassType t )
 263 {
 264     return SbxObject::Find( rName, t );
 265 }
 266
 267
 268
 269 void SbStdFont::SFX_NOTIFY( SfxBroadcaster& rBC, const TypeId& rBCType,
 270                             const SfxHint& rHint, const TypeId& rHintType )
 271 {
 272     const SbxHint* pHint = PTR_CAST( SbxHint, &rHint );
 273
 274     if( pHint )
 275     {
 276         if( pHint->GetId() == SBX_HINT_INFOWANTED )
 277         {
 278             SbxObject::SFX_NOTIFY( rBC, rBCType, rHint, rHintType );
 279             return;
 280         }
 281
 282         SbxVariable* pVar   = pHint->GetVar();
 283         SbxArray*    pPar_  = pVar->GetParameters();
 284         sal_uInt16       nWhich = (sal_uInt16)pVar->GetUserData();
 285         sal_Bool         bWrite = pHint->GetId() == SBX_HINT_DATACHANGED;
 286
 287         // Propteries
 288         switch( nWhich )
 289         {
 290             case ATTR_IMP_BOLD:         PropBold( pVar, pPar_, bWrite ); return;
 291             case ATTR_IMP_ITALIC:       PropItalic( pVar, pPar_, bWrite ); return;
 292             case ATTR_IMP_STRIKETHROUGH:PropStrikeThrough( pVar, pPar_, bWrite ); return;
 293             case ATTR_IMP_UNDERLINE:    PropUnderline( pVar, pPar_, bWrite ); return;
 294             case ATTR_IMP_SIZE:         PropSize( pVar, pPar_, bWrite ); return;
 295             case ATTR_IMP_NAME:         PropName( pVar, pPar_, bWrite ); return;
 296         }
 297
 298         SbxObject::SFX_NOTIFY( rBC, rBCType, rHint, rHintType );
 299     }
 300 }
 301
 302
 303 //-----------------------------------------------------------------------------
 304
 305
 306 void SbStdClipboard::MethClear( SbxVariable*, SbxArray* pPar_, sal_Bool )
 307 {
 308     if( pPar_ && (pPar_->Count() > 1) )
 309     {
 310         StarBASIC::Error( SbERR_BAD_NUMBER_OF_ARGS );
 311         return;
 312     }
 313
 314 }
 315
 316 void SbStdClipboard::MethGetData( SbxVariable* pVar, SbxArray* pPar_, sal_Bool )
 317 {
 318     (void)pVar;
 319
 320     if( !pPar_ || (pPar_->Count() != 2) )
 321     {
 322         StarBASIC::Error( SbERR_BAD_NUMBER_OF_ARGS );
 323         return;
 324     }
 325
 326     sal_uInt16 nFormat = pPar_->Get(1)->GetInteger();
 327     if( !nFormat  || nFormat > 3 )
 328     {
 329         StarBASIC::Error( SbERR_BAD_ARGUMENT );
 330         return;
 331     }
 332
 333 }
 334
 335 void SbStdClipboard::MethGetFormat( SbxVariable* pVar, SbxArray* pPar_, sal_Bool )
 336 {
 337     if( !pPar_ || (pPar_->Count() != 2) )
 338     {
 339         StarBASIC::Error( SbERR_BAD_NUMBER_OF_ARGS );
 340         return;
 341     }
 342
 343     sal_uInt16 nFormat = pPar_->Get(1)->GetInteger();
 344     if( !nFormat  || nFormat > 3 )
 345     {
 346         StarBASIC::Error( SbERR_BAD_ARGUMENT );
 347         return;
 348     }
 349
 350     pVar->PutBool( sal_False );
 351 }
 352
 353 void SbStdClipboard::MethGetText( SbxVariable* pVar, SbxArray* pPar_, sal_Bool )
 354 {
 355     if( pPar_ && (pPar_->Count() > 1) )
 356     {
 357         StarBASIC::Error( SbERR_BAD_NUMBER_OF_ARGS );
 358         return;
 359     }
 360
 361     pVar->PutString( OUString() );
 362 }
 363
 364 void SbStdClipboard::MethSetData( SbxVariable* pVar, SbxArray* pPar_, sal_Bool )
 365 {
 366     (void)pVar;
 367
 368     if( !pPar_ || (pPar_->Count() != 3) )
 369     {
 370         StarBASIC::Error( SbERR_BAD_NUMBER_OF_ARGS );
 371         return;
 372     }
 373
 374     sal_uInt16 nFormat = pPar_->Get(2)->GetInteger();
 375     if( !nFormat  || nFormat > 3 )
 376     {
 377         StarBASIC::Error( SbERR_BAD_ARGUMENT );
 378         return;
 379     }
 380
 381 }
 382
 383 void SbStdClipboard::MethSetText( SbxVariable* pVar, SbxArray* pPar_, sal_Bool )
 384 {
 385     (void)pVar;
 386
 387     if( !pPar_ || (pPar_->Count() != 2) )
 388     {
 389         StarBASIC::Error( SbERR_BAD_NUMBER_OF_ARGS );
 390         return;
 391     }
 392
 393 }
 394
 395
 396 TYPEINIT1( SbStdClipboard, SbxObject );
 397
 398 SbStdClipboard::SbStdClipboard() :
 399     SbxObject( OUString("Clipboard") )
 400 {
 401     SbxVariable* p = Find( OUString("Name"), SbxCLASS_PROPERTY );
 402     DBG_ASSERT( p, "No Name Property" );
 403     p->SetUserData( ATTR_IMP_NAME );
 404
 405     // register methods
 406     p = Make( OUString("Clear"), SbxCLASS_METHOD, SbxEMPTY );
 407     p->SetFlag( SBX_DONTSTORE );
 408     p->SetUserData( METH_CLEAR );
 409     p = Make( OUString("GetData"), SbxCLASS_METHOD, SbxEMPTY );
 410     p->SetFlag( SBX_DONTSTORE );
 411     p->SetUserData( METH_GETDATA );
 412     p = Make( OUString("GetFormat"), SbxCLASS_METHOD, SbxEMPTY );
 413     p->SetFlag( SBX_DONTSTORE );
 414     p->SetUserData( METH_GETFORMAT );
 415     p = Make( OUString("GetText"), SbxCLASS_METHOD, SbxEMPTY );
 416     p->SetFlag( SBX_DONTSTORE );
 417     p->SetUserData( METH_GETTEXT );
 418     p = Make( OUString("SetData"), SbxCLASS_METHOD, SbxEMPTY );
 419     p->SetFlag( SBX_DONTSTORE );
 420     p->SetUserData( METH_SETDATA );
 421     p = Make( OUString("SetText"), SbxCLASS_METHOD, SbxEMPTY );
 422     p->SetFlag( SBX_DONTSTORE );
 423     p->SetUserData( METH_SETTEXT );
 424 }
 425
 426 SbStdClipboard::~SbStdClipboard()
 427 {
 428 }
 429
 430
 431 SbxVariable* SbStdClipboard::Find( const OUString& rName, SbxClassType t )
 432 {
 433     return SbxObject::Find( rName, t );
 434 }
 435
 436
 437
 438 void SbStdClipboard::SFX_NOTIFY( SfxBroadcaster& rBC, const TypeId& rBCType,
 439                                  const SfxHint& rHint, const TypeId& rHintType )
 440 {
 441     const SbxHint* pHint = PTR_CAST( SbxHint, &rHint );
 442
 443     if( pHint )
 444     {
 445         if( pHint->GetId() == SBX_HINT_INFOWANTED )
 446         {
 447             SbxObject::SFX_NOTIFY( rBC, rBCType, rHint, rHintType );
 448             return;
 449         }
 450
 451         SbxVariable* pVar   = pHint->GetVar();
 452         SbxArray*    pPar_  = pVar->GetParameters();
 453         sal_uInt16       nWhich = (sal_uInt16)pVar->GetUserData();
 454         sal_Bool         bWrite = pHint->GetId() == SBX_HINT_DATACHANGED;
 455
 456         // Methods
 457         switch( nWhich )
 458         {
 459             case METH_CLEAR:            MethClear( pVar, pPar_, bWrite ); return;
 460             case METH_GETDATA:          MethGetData( pVar, pPar_, bWrite ); return;
 461             case METH_GETFORMAT:        MethGetFormat( pVar, pPar_, bWrite ); return;
 462             case METH_GETTEXT:          MethGetText( pVar, pPar_, bWrite ); return;
 463             case METH_SETDATA:          MethSetData( pVar, pPar_, bWrite ); return;
 464             case METH_SETTEXT:          MethSetText( pVar, pPar_, bWrite ); return;
 465         }
 466
 467         SbxObject::SFX_NOTIFY( rBC, rBCType, rHint, rHintType );
 468     }
 469 }
 470
 471
 472 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */