basic/source/sample/object.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: object.cxx,v $
  10  * $Revision: 1.8 $
  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_basic.hxx"
  33 #include <tools/errcode.hxx>
  34 #include <basic/sbxobj.hxx>
  35 #include <basic/sbx.hxx>
  36 #ifndef __SBX_SBXVARIABLE_HXX //autogen
  37 #include <basic/sbxvar.hxx>
  38 #endif
  39 #ifndef _MSGBOX_HXX //autogen
  40 #include <vcl/msgbox.hxx>
  41 #endif
  42
  43 #include "object.hxx"
  44 #include "collelem.hxx"
  45
  46 // Das Sample-Objekt hat folgende Elemente:
  47 // 1) Properties:
  48 //    Name      der Name
  49 //    Value     ein double-Wert, beide bereits als Default drin
  50 // 2) Methoden:
  51 //    Create    Erzeugen eines neuen Unterelements
  52 //    Display   Ausgabe eines Textes
  53 //    Square    Argument * Argument
  54 //    Event     Aufruf eines Basic-Eventhandlers
  55 // 3) Unterobjekte:
  56 //    Per Create() kann ein neues Unterelement eingerichtet werden,
  57 //    das indiziert werden kann, falls mehrere Objekte gleichen Namens
  58 //    existieren.
  59 // Diese Implementation ist ein Beispiel fuer eine tabellengesteuerte
  60 // Version, die sehr viele Elemente enthalten kann. Die Elemente werden
  61 // je nach Bedarf aus der Tabelle in das Objekt uebernommen.
  62 // Die Collection findet sich in COLLECTN.*, die in der Collection
  63 // enthaltenen Objekte in COLLELEM.*
  64
  65 // Das Sample-Objekt wird in ..\app\mybasic.cxx wie folgt in StarBASIC
  66 // eingebaut:
  67
  68 // MyBasic::MyBasic() : StarBASIC()
  69 // {
  70 //              AddFactory( new SampleObjectFac() );
  71 // }
  72
  73 // Das nArgs-Feld eines Tabelleneintrags ist wie folgt verschluesselt:
  74
  75 #define _ARGSMASK   0x00FF  // Bis zu 255 Argumente
  76 #define _RWMASK     0x0F00  // Maske fuer R/W-Bits
  77 #define _TYPEMASK   0xF000  // Maske fuer den Typ des Eintrags
  78
  79 #define _READ       0x0100  // kann gelesen werden
  80 #define _BWRITE     0x0200  // kann as Lvalue verwendet werden
  81 #define _LVALUE     _BWRITE  // kann as Lvalue verwendet werden
  82 #define _READWRITE  0x0300  // beides
  83 #define _OPT            0x0400  // TRUE: optionaler Parameter
  84 #define _METHOD     0x1000  // Masken-Bit fuer eine Methode
  85 #define _PROPERTY   0x2000  // Masken-Bit fuer eine Property
  86 #define _COLL       0x4000  // Masken-Bit fuer eine Collection
  87                             // Kombination von oberen Bits:
  88 #define _FUNCTION   0x1100  // Maske fuer Function
  89 #define _LFUNCTION  0x1300  // Maske fuer Function, die auch als Lvalue geht
  90 #define _ROPROP     0x2100  // Maske Read Only-Property
  91 #define _WOPROP     0x2200  // Maske Write Only-Property
  92 #define _RWPROP     0x2300  // Maske Read/Write-Property
  93 #define _COLLPROP   0x4100  // Maske Read-Collection-Element
  94
  95 #define COLLNAME    "Elements"  // Name der Collection, hier mal hart verdrahtet
  96
  97 SampleObject::Methods SampleObject::aMethods[] = {
  98 // Eine Sample-Methode (der Returnwert ist SbxNULL)
  99 { "Display", SbxEMPTY, &SampleObject::Display, 1 | _FUNCTION },
 100     // Ein Named Parameter
 101     { "message", SbxSTRING, NULL, 0 },
 102 // Eine Sample-Funktion
 103 { "Square", SbxDOUBLE, &SampleObject::Square, 1 | _FUNCTION },
 104     // Ein Named Parameter
 105     { "value", SbxDOUBLE, NULL, 0 },
 106 //  Basic-Callback
 107 { "Event", SbxEMPTY, &SampleObject::Event, 1 | _FUNCTION },
 108     // Ein Named Parameter
 109     { "event", SbxSTRING, NULL, 0 },
 110 //  Element erzeugen
 111 { "Create", SbxEMPTY, &SampleObject::Create, 1 | _FUNCTION },
 112     // Ein Named Parameter
 113     { "name", SbxSTRING, NULL, 0 },
 114
 115 { NULL, SbxNULL, NULL, -1 }};  // Tabellenende
 116
 117 SampleObject::SampleObject( const String& rClass ) : SbxObject( rClass )
 118 {
 119     SetName( String( RTL_CONSTASCII_USTRINGPARAM("Sample") ) );
 120     PutDouble( 1.0 );   // Startwert fuer Value
 121 }
 122
 123 // Suche nach einem Element:
 124 // Hier wird linear durch die Methodentabelle gegangen, bis eine
 125 // passende Methode gefunden wurde.
 126 // Wenn die Methode/Property nicht gefunden wurde, nur NULL ohne
 127 // Fehlercode zurueckliefern, da so auch eine ganze Chain von
 128 // Objekten nach der Methode/Property befragt werden kann.
 129
 130 SbxVariable* SampleObject::Find( const String& rName, SbxClassType t )
 131 {
 132     // Ist das Element bereits vorhanden?
 133     SbxVariable* pRes = SbxObject::Find( rName, t );
 134     if( !pRes && t != SbxCLASS_OBJECT )
 135     {
 136         // sonst suchen
 137         Methods* p = aMethods;
 138         short nIndex = 0;
 139         BOOL bFound = FALSE;
 140         while( p->nArgs != -1 )
 141         {
 142             if( rName.EqualsIgnoreCaseAscii( p->pName ) )
 143             {
 144                 bFound = TRUE; break;
 145             }
 146             nIndex += ( p->nArgs & _ARGSMASK ) + 1;
 147             p = aMethods + nIndex;
 148         }
 149         if( bFound )
 150         {
 151             // Args-Felder isolieren:
 152             short nAccess = ( p->nArgs & _RWMASK ) >> 8;
 153             short nType   = ( p->nArgs & _TYPEMASK );
 154             String aName_ = String::CreateFromAscii( p->pName );
 155             SbxClassType eCT = SbxCLASS_OBJECT;
 156             if( nType & _PROPERTY )
 157                 eCT = SbxCLASS_PROPERTY;
 158             else if( nType & _METHOD )
 159                 eCT = SbxCLASS_METHOD;
 160             pRes = Make( aName_, eCT, p->eType );
 161             // Wir setzen den Array-Index + 1, da ja noch andere
 162             // Standard-Properties existieren, die auch aktiviert
 163             // werden muessen.
 164             pRes->SetUserData( nIndex + 1 );
 165             pRes->SetFlags( nAccess );
 166         }
 167     }
 168     return pRes;
 169 }
 170
 171 // Aktivierung eines Elements oder Anfordern eines Infoblocks
 172
 173 void SampleObject::SFX_NOTIFY( SfxBroadcaster& rBC, const TypeId& rBCT,
 174                              const SfxHint& rHint, const TypeId& rHT )
 175 {
 176     const SbxHint* pHint = PTR_CAST(SbxHint,&rHint);
 177     if( pHint )
 178     {
 179         SbxVariable* pVar = pHint->GetVar();
 180         SbxArray* pPar_ = pVar->GetParameters();
 181         USHORT nIndex = (USHORT) pVar->GetUserData();
 182         // kein Index: weiterreichen!
 183         if( nIndex )
 184         {
 185             ULONG t = pHint->GetId();
 186             if( t == SBX_HINT_INFOWANTED )
 187                 pVar->SetInfo( GetInfo( (short) pVar->GetUserData() ) );
 188             else
 189             {
 190                 BOOL bWrite = FALSE;
 191                 if( t == SBX_HINT_DATACHANGED )
 192                     bWrite = TRUE;
 193                 if( t == SBX_HINT_DATAWANTED || bWrite )
 194                 {
 195                     // Parameter-Test fuer Methoden:
 196                     USHORT nPar = aMethods[ --nIndex ].nArgs & 0x00FF;
 197                     // Element 0 ist der Returnwert
 198                     if( ( !pPar_ && nPar )
 199                      || ( pPar_->Count() != nPar+1 ) )
 200                         SetError( SbxERR_WRONG_ARGS );
 201                     // Alles klar, man kann den Call ausfuehren
 202                     else
 203                     {
 204                         (this->*(aMethods[ nIndex ].pFunc))( pVar, pPar_, bWrite );
 205                     }
 206                 }
 207             }
 208         }
 209         SbxObject::SFX_NOTIFY( rBC, rBCT, rHint, rHT );
 210     }
 211 }
 212
 213 // Zusammenbau der Infostruktur fuer einzelne Elemente
 214
 215 SbxInfo* SampleObject::GetInfo( short nIdx )
 216 {
 217     Methods* p = &aMethods[ nIdx ];
 218     // Wenn mal eine Hilfedatei zur Verfuegung steht:
 219     // SbxInfo* pInfo_ = new SbxInfo( Hilfedateiname, p->nHelpId );
 220     SbxInfo* pInfo_ = new SbxInfo;
 221     short nPar = p->nArgs & _ARGSMASK;
 222     for( short i = 0; i < nPar; i++ )
 223     {
 224         p++;
 225         String aName_ = String::CreateFromAscii( p->pName );
 226         USHORT nFlags_ = ( p->nArgs >> 8 ) & 0x03;
 227         if( p->nArgs & _OPT )
 228             nFlags_ |= SBX_OPTIONAL;
 229         pInfo_->AddParam( aName_, p->eType, nFlags_ );
 230     }
 231     return pInfo_;
 232 }
 233
 234 ////////////////////////////////////////////////////////////////////////////
 235
 236 // Properties und Methoden legen beim Get (bPut = FALSE) den Returnwert
 237 // im Element 0 des Argv ab; beim Put (bPut = TRUE) wird der Wert aus
 238 // Element 0 gespeichert.
 239
 240 // Die Methoden:
 241
 242 void SampleObject::Display( SbxVariable*, SbxArray* pPar_, BOOL )
 243 {
 244     // GetString() loest u.U. auch einen Error aus!
 245     String s( pPar_->Get( 1 )->GetString() );
 246     if( !IsError() )
 247         InfoBox( NULL, s ).Execute();
 248 }
 249
 250 void SampleObject::Square( SbxVariable* pVar, SbxArray* pPar_, BOOL )
 251 {
 252     double n = pPar_->Get( 1 )->GetDouble();
 253     pVar->PutDouble( n * n );
 254 }
 255
 256 // Callback nach BASIC:
 257
 258 void SampleObject::Event( SbxVariable*, SbxArray* pPar_, BOOL )
 259 {
 260     Call( pPar_->Get( 1 )->GetString(), NULL );
 261 }
 262
 263 // Neues Element anlegen
 264
 265 void SampleObject::Create( SbxVariable* pVar, SbxArray* pPar_, BOOL )
 266 {
 267     pVar->PutObject(
 268         MakeObject( pPar_->Get( 1 )->GetString(), String( RTL_CONSTASCII_USTRINGPARAM("SampleElement") ) ) );
 269 }
 270
 271 // Die Factory legt unsere beiden Objekte an.
 272
 273 SbxObject* SampleObjectFac::CreateObject( const String& rClass )
 274 {
 275     if( rClass.EqualsIgnoreCaseAscii( "SampleObject" ) )
 276         return new SampleObject( rClass );
 277     if( rClass.EqualsIgnoreCaseAscii( "SampleElement" ) )
 278         return new SampleElement( rClass );
 279     return NULL;
 280 }
 281