LCOV - code coverage report
Current view: top level - basic/source/runtime - stdobj1.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 30 225 13.3 %
Date: 2014-11-03 Functions: 7 55 12.7 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10