Debian Codegraph @

basic/source/runtime/stdobj1.cxx

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