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 <basic/sberrors.hxx>
  21 #include <basic/sbstar.hxx>
  22 #include <vcl/outdev.hxx>
  23 #include <sbstdobj.hxx>
  24
  25 #define ATTR_IMP_TYPE           1
  26 #define ATTR_IMP_WIDTH          2
  27 #define ATTR_IMP_HEIGHT         3
  28 #define ATTR_IMP_BOLD           4
  29 #define ATTR_IMP_ITALIC         5
  30 #define ATTR_IMP_STRIKETHROUGH  6
  31 #define ATTR_IMP_UNDERLINE      7
  32 #define ATTR_IMP_SIZE           9
  33 #define ATTR_IMP_NAME           10
  34
  35 #define METH_CLEAR              20
  36 #define METH_GETDATA            21
  37 #define METH_GETFORMAT          22
  38 #define METH_GETTEXT            23
  39 #define METH_SETDATA            24
  40 #define METH_SETTEXT            25
  41
  42
  43 SbStdFactory::SbStdFactory()
  44 {
  45 }
  46
  47 SbxObjectRef SbStdFactory::CreateObject( const OUString& rClassName )
  48 {
  49     if( rClassName.equalsIgnoreAsciiCase("Picture") )
  50         return new SbStdPicture;
  51     else if( rClassName.equalsIgnoreAsciiCase("Font") )
  52         return new SbStdFont;
  53     else
  54         return nullptr;
  55 }
  56
  57
  58 void SbStdPicture::PropType( SbxVariable* pVar, bool bWrite )
  59 {
  60     if( bWrite )
  61     {
  62         StarBASIC::Error( ERRCODE_BASIC_PROP_READONLY );
  63         return;
  64     }
  65
  66     GraphicType eType = aGraphic.GetType();
  67     sal_Int16 nType = 0;
  68
  69     if( eType == GraphicType::Bitmap )
  70         nType = 1;
  71     else if( eType != GraphicType::NONE )
  72         nType = 2;
  73
  74     pVar->PutInteger( nType );
  75 }
  76
  77
  78 void SbStdPicture::PropWidth( SbxVariable* pVar, bool bWrite )
  79 {
  80     if( bWrite )
  81     {
  82         StarBASIC::Error( ERRCODE_BASIC_PROP_READONLY );
  83         return;
  84     }
  85
  86     Size aSize = OutputDevice::LogicToLogic(aGraphic.GetPrefSize(), aGraphic.GetPrefMapMode(), MapMode(MapUnit::MapTwip));
  87     pVar->PutInteger( static_cast<sal_Int16>(aSize.Width()) );
  88 }
  89
  90 void SbStdPicture::PropHeight( SbxVariable* pVar, bool bWrite )
  91 {
  92     if( bWrite )
  93     {
  94         StarBASIC::Error( ERRCODE_BASIC_PROP_READONLY );
  95         return;
  96     }
  97
  98     Size aSize = OutputDevice::LogicToLogic(aGraphic.GetPrefSize(), aGraphic.GetPrefMapMode(), MapMode(MapUnit::MapTwip));
  99     pVar->PutInteger( static_cast<sal_Int16>(aSize.Height()) );
 100 }
 101
 102
 103 SbStdPicture::SbStdPicture() :
 104     SbxObject( "Picture" )
 105 {
 106     // Properties
 107     SbxVariable* p = Make( "Type", SbxClassType::Property, SbxVARIANT );
 108     p->SetFlags( SbxFlagBits::Read | SbxFlagBits::DontStore );
 109     p->SetUserData( ATTR_IMP_TYPE );
 110     p = Make( "Width", SbxClassType::Property, SbxVARIANT );
 111     p->SetFlags( SbxFlagBits::Read | SbxFlagBits::DontStore );
 112     p->SetUserData( ATTR_IMP_WIDTH );
 113     p = Make( "Height", SbxClassType::Property, SbxVARIANT );
 114     p->SetFlags( SbxFlagBits::Read | SbxFlagBits::DontStore );
 115     p->SetUserData( ATTR_IMP_HEIGHT );
 116 }
 117
 118 SbStdPicture::~SbStdPicture()
 119 {
 120 }
 121
 122
 123 void SbStdPicture::Notify( SfxBroadcaster& rBC, const SfxHint& rHint )
 124
 125 {
 126     const SbxHint* pHint = dynamic_cast<const SbxHint*>(&rHint);
 127
 128     if( !pHint )
 129         return;
 130
 131     if( pHint->GetId() == SfxHintId::BasicInfoWanted )
 132     {
 133         SbxObject::Notify( rBC, rHint );
 134         return;
 135     }
 136
 137     SbxVariable* pVar   = pHint->GetVar();
 138     const sal_uInt32 nWhich = pVar->GetUserData();
 139     bool         bWrite = pHint->GetId() == SfxHintId::BasicDataChanged;
 140
 141     // Properties
 142     switch( nWhich )
 143     {
 144         case ATTR_IMP_TYPE:     PropType( pVar, bWrite ); return;
 145         case ATTR_IMP_WIDTH:    PropWidth( pVar, bWrite ); return;
 146         case ATTR_IMP_HEIGHT:   PropHeight( pVar, bWrite ); return;
 147     }
 148
 149     SbxObject::Notify( rBC, rHint );
 150 }
 151
 152
 153 void SbStdFont::PropBold( SbxVariable* pVar, bool bWrite )
 154 {
 155     if( bWrite )
 156         SetBold( pVar->GetBool() );
 157     else
 158         pVar->PutBool( IsBold() );
 159 }
 160
 161 void SbStdFont::PropItalic( SbxVariable* pVar, bool bWrite )
 162 {
 163     if( bWrite )
 164         SetItalic( pVar->GetBool() );
 165     else
 166         pVar->PutBool( IsItalic() );
 167 }
 168
 169 void SbStdFont::PropStrikeThrough( SbxVariable* pVar, bool bWrite )
 170 {
 171     if( bWrite )
 172         SetStrikeThrough( pVar->GetBool() );
 173     else
 174         pVar->PutBool( IsStrikeThrough() );
 175 }
 176
 177 void SbStdFont::PropUnderline( SbxVariable* pVar, bool bWrite )
 178 {
 179     if( bWrite )
 180         SetUnderline( pVar->GetBool() );
 181     else
 182         pVar->PutBool( IsUnderline() );
 183 }
 184
 185 void SbStdFont::PropSize( SbxVariable* pVar, bool bWrite )
 186 {
 187     if( bWrite )
 188         SetSize( static_cast<sal_uInt16>(pVar->GetInteger()) );
 189     else
 190         pVar->PutInteger( static_cast<sal_Int16>(GetSize()) );
 191 }
 192
 193 void SbStdFont::PropName( SbxVariable* pVar, bool bWrite )
 194 {
 195     if( bWrite )
 196     {
 197         aName = pVar->GetOUString();
 198     }
 199     else
 200     {
 201         pVar->PutString( aName );
 202     }
 203 }
 204
 205
 206 SbStdFont::SbStdFont()
 207     : SbxObject( "Font" )
 208     , bBold(false)
 209     , bItalic(false)
 210     , bStrikeThrough(false)
 211     , bUnderline(false)
 212     , nSize(0)
 213 {
 214     // Properties
 215     SbxVariable* p = Make( "Bold", SbxClassType::Property, SbxVARIANT );
 216     p->SetFlags( SbxFlagBits::ReadWrite | SbxFlagBits::DontStore );
 217     p->SetUserData( ATTR_IMP_BOLD );
 218     p = Make( "Italic", SbxClassType::Property, SbxVARIANT );
 219     p->SetFlags( SbxFlagBits::ReadWrite | SbxFlagBits::DontStore );
 220     p->SetUserData( ATTR_IMP_ITALIC );
 221     p = Make( "StrikeThrough", SbxClassType::Property, SbxVARIANT );
 222     p->SetFlags( SbxFlagBits::ReadWrite | SbxFlagBits::DontStore );
 223     p->SetUserData( ATTR_IMP_STRIKETHROUGH );
 224     p = Make( "Underline", SbxClassType::Property, SbxVARIANT );
 225     p->SetFlags( SbxFlagBits::ReadWrite | SbxFlagBits::DontStore );
 226     p->SetUserData( ATTR_IMP_UNDERLINE );
 227     p = Make( "Size", SbxClassType::Property, SbxVARIANT );
 228     p->SetFlags( SbxFlagBits::ReadWrite | SbxFlagBits::DontStore );
 229     p->SetUserData( ATTR_IMP_SIZE );
 230
 231     // handle name property yourself
 232     p = Find( "Name", SbxClassType::Property );
 233     assert(p && "No Name Property");
 234     p->SetUserData( ATTR_IMP_NAME );
 235 }
 236
 237 SbStdFont::~SbStdFont()
 238 {
 239 }
 240
 241 void SbStdFont::Notify( SfxBroadcaster& rBC, const SfxHint& rHint )
 242 {
 243     const SbxHint* pHint = dynamic_cast<const SbxHint*>(&rHint);
 244
 245     if( !pHint )
 246         return;
 247
 248     if( pHint->GetId() == SfxHintId::BasicInfoWanted )
 249     {
 250         SbxObject::Notify( rBC, rHint );
 251         return;
 252     }
 253
 254     SbxVariable* pVar   = pHint->GetVar();
 255     const sal_uInt32 nWhich = pVar->GetUserData();
 256     bool         bWrite = pHint->GetId() == SfxHintId::BasicDataChanged;
 257
 258     // Properties
 259     switch( nWhich )
 260     {
 261         case ATTR_IMP_BOLD:         PropBold( pVar, bWrite ); return;
 262         case ATTR_IMP_ITALIC:       PropItalic( pVar, bWrite ); return;
 263         case ATTR_IMP_STRIKETHROUGH:PropStrikeThrough(  pVar, bWrite ); return;
 264         case ATTR_IMP_UNDERLINE:    PropUnderline( pVar, bWrite ); return;
 265         case ATTR_IMP_SIZE:         PropSize( pVar, bWrite ); return;
 266         case ATTR_IMP_NAME:         PropName( pVar, bWrite ); return;
 267     }
 268
 269     SbxObject::Notify( rBC, rHint );
 270 }
 271
 272
 273 void SbStdClipboard::MethClear( SbxArray const * pPar_ )
 274 {
 275     if (pPar_ && (pPar_->Count() > 1))
 276     {
 277         StarBASIC::Error( ERRCODE_BASIC_BAD_NUMBER_OF_ARGS );
 278         return;
 279     }
 280
 281 }
 282
 283 void SbStdClipboard::MethGetData( SbxArray* pPar_ )
 284 {
 285     if (!pPar_ || (pPar_->Count() != 2))
 286     {
 287         StarBASIC::Error( ERRCODE_BASIC_BAD_NUMBER_OF_ARGS );
 288         return;
 289     }
 290
 291     sal_Int16 nFormat = pPar_->Get(1)->GetInteger();
 292     if( nFormat <= 0 || nFormat > 3 )
 293     {
 294         StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
 295         return;
 296     }
 297
 298 }
 299
 300 void SbStdClipboard::MethGetFormat( SbxVariable* pVar, SbxArray* pPar_ )
 301 {
 302     if (!pPar_ || (pPar_->Count() != 2))
 303     {
 304         StarBASIC::Error( ERRCODE_BASIC_BAD_NUMBER_OF_ARGS );
 305         return;
 306     }
 307
 308     sal_Int16 nFormat = pPar_->Get(1)->GetInteger();
 309     if( nFormat <= 0 || nFormat > 3 )
 310     {
 311         StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
 312         return;
 313     }
 314
 315     pVar->PutBool( false );
 316 }
 317
 318 void SbStdClipboard::MethGetText( SbxVariable* pVar, SbxArray const * pPar_ )
 319 {
 320     if (pPar_ && (pPar_->Count() > 1))
 321     {
 322         StarBASIC::Error( ERRCODE_BASIC_BAD_NUMBER_OF_ARGS );
 323         return;
 324     }
 325
 326     pVar->PutString( OUString() );
 327 }
 328
 329 void SbStdClipboard::MethSetData( SbxArray* pPar_ )
 330 {
 331     if (!pPar_ || (pPar_->Count() != 3))
 332     {
 333         StarBASIC::Error( ERRCODE_BASIC_BAD_NUMBER_OF_ARGS );
 334         return;
 335     }
 336
 337     sal_Int16 nFormat = pPar_->Get(2)->GetInteger();
 338     if( nFormat <= 0 || nFormat > 3 )
 339     {
 340         StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
 341         return;
 342     }
 343
 344 }
 345
 346 void SbStdClipboard::MethSetText( SbxArray const * pPar_ )
 347 {
 348     if (!pPar_ || (pPar_->Count() != 2))
 349     {
 350         StarBASIC::Error( ERRCODE_BASIC_BAD_NUMBER_OF_ARGS );
 351         return;
 352     }
 353
 354 }
 355
 356
 357 SbStdClipboard::SbStdClipboard() :
 358     SbxObject( "Clipboard" )
 359 {
 360     SbxVariable* p = Find( "Name", SbxClassType::Property );
 361     assert(p && "No Name Property");
 362     p->SetUserData( ATTR_IMP_NAME );
 363
 364     // register methods
 365     p = Make( "Clear", SbxClassType::Method, SbxEMPTY );
 366     p->SetFlag( SbxFlagBits::DontStore );
 367     p->SetUserData( METH_CLEAR );
 368     p = Make( "GetData", SbxClassType::Method, SbxEMPTY );
 369     p->SetFlag( SbxFlagBits::DontStore );
 370     p->SetUserData( METH_GETDATA );
 371     p = Make( "GetFormat", SbxClassType::Method, SbxEMPTY );
 372     p->SetFlag( SbxFlagBits::DontStore );
 373     p->SetUserData( METH_GETFORMAT );
 374     p = Make( "GetText", SbxClassType::Method, SbxEMPTY );
 375     p->SetFlag( SbxFlagBits::DontStore );
 376     p->SetUserData( METH_GETTEXT );
 377     p = Make( "SetData", SbxClassType::Method, SbxEMPTY );
 378     p->SetFlag( SbxFlagBits::DontStore );
 379     p->SetUserData( METH_SETDATA );
 380     p = Make( "SetText", SbxClassType::Method, SbxEMPTY );
 381     p->SetFlag( SbxFlagBits::DontStore );
 382     p->SetUserData( METH_SETTEXT );
 383 }
 384
 385 SbStdClipboard::~SbStdClipboard()
 386 {
 387 }
 388
 389 void SbStdClipboard::Notify( SfxBroadcaster& rBC, const SfxHint& rHint )
 390 {
 391     const SbxHint* pHint = dynamic_cast<const SbxHint*>(&rHint);
 392
 393     if( !pHint )
 394         return;
 395
 396     if( pHint->GetId() == SfxHintId::BasicInfoWanted )
 397     {
 398         SbxObject::Notify( rBC, rHint );
 399         return;
 400     }
 401
 402     SbxVariable* pVar   = pHint->GetVar();
 403     SbxArray*    pPar_  = pVar->GetParameters();
 404     const sal_uInt32 nWhich = pVar->GetUserData();
 405
 406     // Methods
 407     switch( nWhich )
 408     {
 409         case METH_CLEAR:            MethClear( pPar_ ); return;
 410         case METH_GETDATA:          MethGetData( pPar_ ); return;
 411         case METH_GETFORMAT:        MethGetFormat( pVar, pPar_ ); return;
 412         case METH_GETTEXT:          MethGetText( pVar, pPar_ ); return;
 413         case METH_SETDATA:          MethSetData( pPar_ ); return;
 414         case METH_SETTEXT:          MethSetText( pPar_ ); return;
 415     }
 416
 417     SbxObject::Notify( rBC, rHint );
 418 }
 419
 420
 421 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */