?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
CWS-TOOLING: integrate CWS os146
[LibreOffice.git] / rsc / source / parser / rscicpx.cxx
blob45e8d5aac301b4ba0f66aadb211782e828961b1f
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2000, 2010 Oracle and/or its affiliates.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * This file is part of OpenOffice.org.
10 *
11 * OpenOffice.org is free software: you can redistribute it and/or modify
12 * it under the terms of the GNU Lesser General Public License version 3
13 * only, as published by the Free Software Foundation.
14 *
15 * OpenOffice.org is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU Lesser General Public License version 3 for more details
19 * (a copy is included in the LICENSE file that accompanied this code).
20 *
21 * You should have received a copy of the GNU Lesser General Public License
22 * version 3 along with OpenOffice.org. If not, see
23 * <http://www.openoffice.org/license.html>
24 * for a copy of the LGPLv3 License.
25 *
26 ************************************************************************/
27
28 // MARKER(update_precomp.py): autogen include statement, do not remove
29 #include "precompiled_rsc.hxx"
30
31 /****************** I N C L U D E S **************************************/
32 // C and C++ Includes.
33 #include <stdlib.h>
34 #include <stdio.h>
35
36 #include <tools/rc.h>
37
38 #include <vclrsc.hxx>
39 #include <rscmgr.hxx>
40 #include <rscclass.hxx>
41 #include <rsccont.hxx>
42 #include <rscdb.hxx>
43 #include <rsc/rscsfx.hxx>
44
45 #include "rsclex.hxx"
46 #include <yyrscyacc.hxx>
47
48 /*************************************************************************
49 |* RscTypCont::InsWinBit()
50 *************************************************************************/
51 void RscTypCont::InsWinBit( RscTop * pClass, const ByteString & rName,
52 Atom nVal )
53 {
54 RscClient * pClient;
55
56 // Clientvariablen einfuegen
57 aBaseLst.Insert(
58 pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE,
59 &aWinBits, nVal ),
60 LIST_APPEND );
61 Atom nId = aNmTb.Put( rName.GetBuffer(), VARNAME );
62 pClass->SetVariable( nId, pClient, NULL,
63 VAR_NODATAINST, 0, nWinBitVarId );
64 }
65
66 #define INS_WINBIT( pClass, WinBit ) \
67 InsWinBit( pClass, #WinBit, n##WinBit##Id );
68
69 /*************************************************************************
70 |* RscTypCont::InitClassMgr()
71 *************************************************************************/
72 RscTop * RscTypCont::InitClassMgr()
73 {
74 RscTop * pClassMgr;
75 RscBaseCont * pClass;
76 Atom nId;
77
78 aBaseLst.Insert( pClass =
79 new RscBaseCont( InvalidAtom, RSC_NOTYPE, NULL, sal_False ),
80 LIST_APPEND );
81
82 nId = pHS->getID( "Resource" );
83 pClassMgr = new RscMgr( nId, RSC_RESOURCE, pClass );
84 aNmTb.Put( nId, CLASSNAME, pClassMgr );
85 pClassMgr->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType );
86
87 // Variablen anlegen
88 {
89 RscContWriteSrc * pCont;
90
91 // Variablen anlegen
92 aBaseLst.Insert(
93 pCont = new RscContExtraData( pHS->getID( "ContExtradata" ),
94 RSC_NOTYPE ),
95 LIST_APPEND );
96 pCont->SetTypeClass( &aShort, &aString );
97 nRsc_EXTRADATA = nId = aNmTb.Put( "ExtraData", VARNAME );
98 pClassMgr->SetVariable( nId, pCont );
99 };
100 nId = aNmTb.Put( "Comment", VARNAME );
101 pClassMgr->SetVariable( nId, &aString, NULL, VAR_NORC );
102
103 pClass->SetTypeClass( pClassMgr );
104
105 return pClassMgr;
106 }
107
108 /*************************************************************************
109 |* RscTypCont::InitClassString()
110 *************************************************************************/
111 RscTop * RscTypCont::InitClassString( RscTop * pSuper ){
112 Atom nId;
113 RscTop * pClassString;
114
115 nId = pHS->getID( "String" );
116 pClassString = new RscClass( nId, RSC_STRING, pSuper );
117 aNmTb.Put( nId, CLASSNAME, pClassString );
118 pClassString->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType );
119
120 // Variablen anlegen
121 nId = aNmTb.Put( "Text", VARNAME );
122 pClassString->SetVariable( nId, &aLangString );
123 return( pClassString );
124 }
125
126 /*************************************************************************
127 |* RscTypCont::InitClassBitmap()
128 *************************************************************************/
129 RscTop * RscTypCont::InitClassBitmap( RscTop * pSuper ){
130 Atom nId;
131 RscTop * pClassBitmap;
132
133 nId = pHS->getID( "Bitmap" );
134 pClassBitmap = new RscSysDepend( nId, RSC_BITMAP, pSuper );
135 pClassBitmap->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType );
136 aNmTb.Put( nId, CLASSNAME, pClassBitmap );
137
138 // Die Klasse RscSysDepend behandelt die Variablen
139 // "FILE" gesondert
140 nId = aNmTb.Put( "File", VARNAME );
141 pClassBitmap->SetVariable( nId, &aLangString, NULL, VAR_NORC );
142
143 return( pClassBitmap );
144 }
145
146 /*************************************************************************
147 |* RscTypCont::InitClassColor()
148 *************************************************************************/
149 RscTop * RscTypCont::InitClassColor( RscTop * pSuper, RscEnum * pColor ){
150 Atom nId;
151 RscTop * pClassColor;
152
153 // Klasse anlegen
154 nId = pHS->getID( "Color" );
155 pClassColor = new RscClass( nId, RSC_COLOR, pSuper );
156 pClassColor->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType );
157 aNmTb.Put( nId, CLASSNAME, pClassColor );
158
159 // Variablen anlegen
160 nId = aNmTb.Put( "Red", VARNAME );
161 pClassColor->SetVariable( nId, &aUShort );
162 nId = aNmTb.Put( "Green", VARNAME );
163 pClassColor->SetVariable( nId, &aUShort );
164 nId = aNmTb.Put( "Blue", VARNAME );
165 pClassColor->SetVariable( nId, &aUShort );
166 nId = aNmTb.Put( "Predefine", VARNAME );
167 pClassColor->SetVariable( nId, pColor );
168
169 return( pClassColor );
170 }
171
172 /*************************************************************************
173 |* RscTypCont::InitClassImage()
174 *************************************************************************/
175 RscTop * RscTypCont::InitClassImage( RscTop * pSuper, RscTop * pClassBitmap,
176 RscTop * pClassColor )
177 {
178 Atom nId;
179 RscTop * pClassImage;
180
181 // Klasse anlegen
182 nId = pHS->getID( "Image" );
183 pClassImage = new RscClass( nId, RSC_IMAGE, pSuper );
184 pClassImage->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType );
185 aNmTb.Put( nId, CLASSNAME, pClassImage );
186
187 // Variablen anlegen
188 nId = aNmTb.Put( "ImageBitmap", VARNAME );
189 pClassImage->SetVariable( nId, pClassBitmap, NULL, 0, RSC_IMAGE_IMAGEBITMAP );
190 nId = aNmTb.Put( "MaskBitmap", VARNAME );
191 pClassImage->SetVariable( nId, pClassBitmap, NULL, 0, RSC_IMAGE_MASKBITMAP );
192 nId = aNmTb.Put( "MaskColor", VARNAME );
193 pClassImage->SetVariable( nId, pClassColor, NULL,
194 VAR_SVDYNAMIC, RSC_IMAGE_MASKCOLOR );
195
196 return( pClassImage );
197 }
198
199 /*************************************************************************
200 |* RscTypCont::InitClassImageList()
201 *************************************************************************/
202 RscTop * RscTypCont::InitClassImageList( RscTop * pSuper, RscTop * /*pClassBitmap*/,
203 RscTop * pClassColor, RscCont * pStrLst )
204 {
205 Atom nId;
206 RscTop * pClassImageList;
207
208 // Klasse anlegen
209 nId = pHS->getID( "ImageList" );
210 pClassImageList = new RscClass( nId, RSC_IMAGELIST, pSuper );
211 pClassImageList->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType );
212 aNmTb.Put( nId, CLASSNAME, pClassImageList );
213
214 nId = aNmTb.Put( "Prefix", VARNAME );
215 pClassImageList->SetVariable( nId, &aString );
216
217 nId = aNmTb.Put( "MaskColor", VARNAME );
218 pClassImageList->SetVariable( nId, pClassColor, NULL,
219 VAR_SVDYNAMIC, RSC_IMAGELIST_MASKCOLOR );
220
221 RscCont * pCont = new RscCont( pHS->getID( "sal_uInt16 *" ), RSC_NOTYPE );
222 pCont->SetTypeClass( &aIdUShort );
223 aBaseLst.Insert( pCont, LIST_APPEND );
224 nId = aNmTb.Put( "IdList", VARNAME );
225 pClassImageList->SetVariable( nId, pCont, NULL, 0,
226 RSC_IMAGELIST_IDLIST );
227
228 nId = aNmTb.Put( "FileList", VARNAME );
229 pClassImageList->SetVariable( nId, pStrLst );
230
231 nId = aNmTb.Put( "IdCount", VARNAME );
232 pClassImageList->SetVariable( nId, &aUShort, NULL, 0,
233 RSC_IMAGELIST_IDCOUNT );
234 return( pClassImageList );
235 }
236
237 /*************************************************************************
238 |* RscTypCont::InitClassWindow()
239 *************************************************************************/
240 RscTop * RscTypCont::InitClassWindow( RscTop * pSuper, RscEnum * pMapUnit,
241 RscArray * pLangGeo )
242 {
243 Atom nId;
244 RscTop * pClassWindow;
245
246 // Klasse anlegen
247 nId = pHS->getID( "Window" );
248 pClassWindow = new RscClass( nId, RSC_WINDOW, pSuper );
249 pClassWindow->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
250 aNmTb.Put( nId, CLASSNAME, pClassWindow );
251
252 // Variablen anlegen
253 {
254 RscFlag * pFlag;
255 RscClient * pClient;
256 Atom nVarId, nDisableId, nOutputSizeId;
257
258 aBaseLst.Insert( pFlag = new RscFlag( pHS->getID( "FlagWndExtra" ),
259 RSC_NOTYPE ),
260 LIST_APPEND );
261
262 // Konstanten in Tabelle stellen
263 nDisableId = pHS->getID( "RSWND_DISABLE" );
264 SETCONST( pFlag, nDisableId, RSWND_DISABLED );
265 nOutputSizeId = pHS->getID( "RSWND_OUTPUTSIZE" );
266 SETCONST( pFlag, nOutputSizeId, RSWND_CLIENTSIZE );
267
268 // Variable einfuegen
269 nVarId = aNmTb.Put( "_RscExtraFlags", VARNAME );
270 pClassWindow->SetVariable( nVarId, pFlag, NULL,
271 VAR_HIDDEN | VAR_NOENUM );
272
273 aBaseLst.Insert(
274 pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE,
275 pFlag, nDisableId ),
276 LIST_APPEND );
277 nId = aNmTb.Put( "Disable", VARNAME );
278 pClassWindow->SetVariable( nId, pClient, NULL,
279 VAR_NODATAINST, 0, nVarId );
280
281 aBaseLst.Insert(
282 pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE,
283 pFlag, nOutputSizeId ),
284 LIST_APPEND );
285 nId = aNmTb.Put( "OutputSize", VARNAME );
286 pClassWindow->SetVariable( nId, pClient, NULL,
287 VAR_NODATAINST, 0, nVarId );
288 }
289
290 pClassWindow->SetVariable( nWinBitVarId, &aWinBits, NULL,
291 VAR_HIDDEN | VAR_NOENUM );
292
293 INS_WINBIT(pClassWindow,Border)
294 INS_WINBIT(pClassWindow,Hide)
295 INS_WINBIT(pClassWindow,ClipChildren)
296 INS_WINBIT(pClassWindow,SVLook)
297 InsWinBit( pClassWindow, "DialogControl", nTabControlId );
298
299 nId = aNmTb.Put( "HelpID", VARNAME );
300 pClassWindow->SetVariable( nId, &aStringLiteral, NULL, 0, WINDOW_HELPID );
301
302
303 nRsc_XYMAPMODEId = nId = aNmTb.Put( "_XYMapMode", VARNAME );
304 pClassWindow->SetVariable( nId, pMapUnit, NULL, 0, WINDOW_XYMAPMODE );
305 nRsc_X = nId = aNmTb.Put( "_X", VARNAME );
306 pClassWindow->SetVariable( nId, &aLong, NULL, 0, WINDOW_X );
307 nRsc_Y = nId = aNmTb.Put( "_Y", VARNAME );
308 pClassWindow->SetVariable( nId, &aLong, NULL, 0, WINDOW_Y );
309
310 nRsc_WHMAPMODEId = nId = aNmTb.Put( "_WHMapMode", VARNAME );
311 pClassWindow->SetVariable( nId, pMapUnit, NULL, 0, WINDOW_WHMAPMODE );
312 nRsc_WIDTH = nId = aNmTb.Put( "_Width", VARNAME );
313 pClassWindow->SetVariable( nId, &aLong, NULL, 0, WINDOW_WIDTH );
314 nRsc_HEIGHT = nId = aNmTb.Put( "_Height", VARNAME );
315 pClassWindow->SetVariable( nId, &aLong, NULL, 0, WINDOW_HEIGHT );
316
317 nRsc_DELTALANG = nId = aNmTb.Put( "DeltaLang", VARNAME );
318 pClassWindow->SetVariable( nId, pLangGeo, NULL, VAR_NORC | VAR_NOENUM);
319 nId = aNmTb.Put( "Text", VARNAME );
320 pClassWindow->SetVariable( nId, &aLangString, NULL, 0, WINDOW_TEXT );
321 nId = aNmTb.Put( "HelpText", VARNAME );
322 pClassWindow->SetVariable( nId, &aLangString, NULL, 0, WINDOW_HELPTEXT );
323 nId = aNmTb.Put( "QuickHelpText", VARNAME );
324 pClassWindow->SetVariable( nId, &aLangString, NULL, 0, WINDOW_QUICKTEXT );
325 nId = aNmTb.Put( "ExtraLong", VARNAME );
326 pClassWindow->SetVariable( nId, &aLong, NULL, 0, WINDOW_EXTRALONG );
327 nId = aNmTb.Put( "UniqueId", VARNAME );
328 pClassWindow->SetVariable( nId, &aString, NULL, 0, WINDOW_UNIQUEID );
329
330 // BorderStyle
331 RscEnum* pBorderStyleEnum = new RscEnum( pHS->getID( "WindowBorderStyle" ), RSC_NOTYPE );
332 aBaseLst.Insert( pBorderStyleEnum, LIST_APPEND );
333
334 // Konstanten in Tabelle stellen
335 SETCONST( pBorderStyleEnum, pHS->getID( "WINDOW_BORDER_NORMAL" ), WINDOW_BORDER_NORMAL );
336 SETCONST( pBorderStyleEnum, pHS->getID( "WINDOW_BORDER_MONO" ), WINDOW_BORDER_MONO );
337 SETCONST( pBorderStyleEnum, pHS->getID( "WINDOW_BORDER_ACTIVE" ), WINDOW_BORDER_ACTIVE );
338 SETCONST( pBorderStyleEnum, pHS->getID( "WINDOW_BORDER_DOUBLEOUT" ), WINDOW_BORDER_DOUBLEOUT );
339 SETCONST( pBorderStyleEnum, pHS->getID( "WINDOW_BORDER_MENU" ), WINDOW_BORDER_MENU );
340 SETCONST( pBorderStyleEnum, pHS->getID( "WINDOW_BORDER_NOBORDER" ), WINDOW_BORDER_NOBORDER );
341
342 // Variable einfuegen
343 nId = aNmTb.Put( "BorderStyle", VARNAME );
344 pClassWindow->SetVariable( nId, pBorderStyleEnum, NULL,
345 0,
346 WINDOW_BORDER_STYLE );
347
348 return( pClassWindow );
349 }
350
351 /*************************************************************************
352 |* RscTypCont::InitClassSystemWindow()
353 *************************************************************************/
354 RscTop * RscTypCont::InitClassSystemWindow( RscTop * pSuper )
355 {
356 Atom nId;
357 RscTop * pClassSystemWindow;
358
359 // Klasse anlegen
360 nId = pHS->getID( "SystemWindow" );
361 pClassSystemWindow = new RscClass( nId, RSC_SYSWINDOW, pSuper );
362 pClassSystemWindow->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
363 aNmTb.Put( nId, CLASSNAME, pClassSystemWindow );
364
365 INS_WINBIT(pClassSystemWindow,Sizeable)
366 INS_WINBIT(pClassSystemWindow,Moveable)
367 InsWinBit( pClassSystemWindow, "Minable", nMinimizeId );
368 InsWinBit( pClassSystemWindow, "Maxable", nMaximizeId );
369 INS_WINBIT(pClassSystemWindow,Closeable)
370 INS_WINBIT(pClassSystemWindow,App)
371 INS_WINBIT(pClassSystemWindow,SysWin)
372
373 return pClassSystemWindow ;
374 }
375
376 /*************************************************************************
377 |* RscTypCont::InitClassWorkWindow()
378 *************************************************************************/
379 RscTop * RscTypCont::InitClassWorkWindow( RscTop * pSuper )
380 {
381 Atom nId;
382 RscTop * pClassWorkWindow;
383
384 // Klasse anlegen
385 nId = pHS->getID( "WorkWindow" );
386 pClassWorkWindow = new RscClass( nId, RSC_WORKWIN, pSuper );
387 pClassWorkWindow->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
388
389 aNmTb.Put( nId, CLASSNAME, pClassWorkWindow );
390
391 // Variablen anlegen
392 {
393 Atom nVarId;
394 RscEnum * pShow;
395
396 aBaseLst.Insert( pShow = new RscEnum( pHS->getID( "EnumShowState" ),
397 RSC_NOTYPE ),
398 LIST_APPEND );
399
400 SETCONST( pShow, "SHOW_NORMAL", WORKWIN_SHOWNORMAL );
401 SETCONST( pShow, "SHOW_MINIMIZED", WORKWIN_SHOWMINIMIZED );
402 SETCONST( pShow, "SHOW_MAXIMIZED", WORKWIN_SHOWMAXIMIZED );
403
404
405 // Variable einfuegen
406 nVarId = aNmTb.Put( "Show", VARNAME );
407 pClassWorkWindow->SetVariable( nVarId, pShow, NULL );
408 }
409
410 return pClassWorkWindow;
411 }
412
413 /*************************************************************************
414 |* RscTypCont::InitClassDialogBox()
415 *************************************************************************/
416 RscTop * RscTypCont::InitClassModalDialog( RscTop * pSuper )
417 {
418 Atom nId;
419 RscTop * pClassDialog;
420
421 // Klasse anlegen
422 nId = pHS->getID( "ModalDialog" );
423 pClassDialog = new RscClass( nId, RSC_MODALDIALOG, pSuper );
424 pClassDialog->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
425 aNmTb.Put( nId, CLASSNAME, pClassDialog );
426
427 InsWinBit( pClassDialog, "SysModal", nSysmodalId );
428
429 return pClassDialog;
430 }
431
432 /*************************************************************************
433 |* RscTypCont::InitClassModelessDialog()
434 *************************************************************************/
435 RscTop * RscTypCont::InitClassModelessDialog( RscTop * pSuper )
436 {
437 Atom nId;
438 RscTop * pClassDialog;
439
440 // Klasse anlegen
441 nId = pHS->getID( "ModelessDialog" );
442 pClassDialog = new RscClass( nId, RSC_MODELESSDIALOG, pSuper );
443 pClassDialog->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
444 aNmTb.Put( nId, CLASSNAME, pClassDialog );
445
446 return pClassDialog;
447 }
448
449 /*************************************************************************
450 |* RscTypCont::InitClassControl()
451 *************************************************************************/
452 RscTop * RscTypCont::InitClassControl( RscTop * pSuper )
453 {
454 Atom nId;
455 RscTop * pClassControl;
456
457 // Klasse anlegen
458 nId = pHS->getID( "Control" );
459 pClassControl = new RscClass( nId, RSC_CONTROL, pSuper );
460 pClassControl->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
461 aNmTb.Put( nId, CLASSNAME, pClassControl );
462
463 InsWinBit( pClassControl, "TabStop", nTabstopId );
464 INS_WINBIT(pClassControl,Group)
465
466 return pClassControl;
467 }
468
469 /*************************************************************************
470 |* RscTypCont::InitClassCheckBox()
471 *************************************************************************/
472 RscTop * RscTypCont::InitClassCheckBox( RscTop * pSuper )
473 {
474 Atom nId;
475 RscTop * pClassCheckBox;
476
477 // Klasse anlegen
478 nId = pHS->getID( "CheckBox" );
479 pClassCheckBox = new RscClass( nId, RSC_CHECKBOX, pSuper );
480 pClassCheckBox->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
481 aNmTb.Put( nId, CLASSNAME, pClassCheckBox );
482
483 // Variablen anlegen
484 INS_WINBIT( pClassCheckBox, WordBreak )
485 INS_WINBIT( pClassCheckBox, Top )
486 INS_WINBIT( pClassCheckBox, VCenter )
487 INS_WINBIT( pClassCheckBox, Bottom )
488
489 nId = aNmTb.Put( "Check", VARNAME );
490 pClassCheckBox->SetVariable( nId, &aBool );
491
492 return pClassCheckBox;
493 }
494
495 /*************************************************************************
496 |* RscTypCont::InitClassPushButton()
497 *************************************************************************/
498 RscTop * RscTypCont::InitClassPushButton( RscTop * pSuper )
499 {
500 Atom nId;
501 RscTop * pClassPushButton;
502
503 // Klasse anlegen
504 nId = pHS->getID( "PushButton" );
505 pClassPushButton = new RscClass( nId, RSC_PUSHBUTTON, pSuper );
506 pClassPushButton->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
507 aNmTb.Put( nId, CLASSNAME, pClassPushButton );
508
509 InsWinBit( pClassPushButton, "DefButton", nDefaultId );
510 INS_WINBIT( pClassPushButton, Top )
511 INS_WINBIT( pClassPushButton, VCenter )
512 INS_WINBIT( pClassPushButton, Bottom )
513
514 return pClassPushButton;
515 }
516
517 /*************************************************************************
518 |* RscTypCont::InitClassTriStateBox()
519 *************************************************************************/
520 RscTop * RscTypCont::InitClassTriStateBox( RscTop * pSuper,
521 RscEnum * pTriState )
522 {
523 Atom nId;
524 RscTop * pClassTriStateBox;
525
526 nId = pHS->getID( "TriStateBox" );
527 pClassTriStateBox = new RscClass( nId, RSC_TRISTATEBOX, pSuper );
528 pClassTriStateBox->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
529 aNmTb.Put( nId, CLASSNAME, pClassTriStateBox );
530
531 // Variablen anlegen
532 nId = aNmTb.Put( "State", VARNAME );
533 pClassTriStateBox->SetVariable( nId, pTriState );
534 nId = aNmTb.Put( "TriStateDisable", VARNAME );
535 pClassTriStateBox->SetVariable( nId, &aBool );
536
537 return( pClassTriStateBox );
538 }
539
540 /*************************************************************************
541 |* RscTypCont::InitClassMenuButton()
542 *************************************************************************/
543 RscTop * RscTypCont::InitClassMenuButton( RscTop * pSuper,
544 RscTop * pClassMenu )
545 {
546 Atom nId;
547 RscTop * pClassMenuButton;
548
549 nId = pHS->getID( "MenuButton" );
550 pClassMenuButton = new RscClass( nId, RSC_MENUBUTTON, pSuper );
551 pClassMenuButton->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
552 aNmTb.Put( nId, CLASSNAME, pClassMenuButton );
553
554 // Variablen anlegen
555 nId = aNmTb.Put( "ButtonMenu", VARNAME );
556 pClassMenuButton->SetVariable( nId, pClassMenu, NULL, 0,
557 RSCMENUBUTTON_MENU );
558
559 return( pClassMenuButton );
560 }
561
562
563 /*************************************************************************
564 |* RscTypCont::InitClassImageButton()
565 *************************************************************************/
566 RscTop * RscTypCont::InitClassImageButton( RscTop * pSuper,
567 RscTop * pClassImage,
568 RscEnum * pTriState )
569 {
570 Atom nId;
571 RscTop * pClassImageButton;
572
573 // Klasse anlegen
574 nId = pHS->getID( "ImageButton" );
575 pClassImageButton = new RscClass( nId, RSC_IMAGEBUTTON, pSuper );
576 pClassImageButton->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
577 aNmTb.Put( nId, CLASSNAME, pClassImageButton );
578
579 // Variablen anlegen
580 {
581 nId = aNmTb.Put( "ButtonImage", VARNAME );
582 pClassImageButton->SetVariable( nId, pClassImage, NULL, 0,
583 RSC_IMAGEBUTTON_IMAGE );
584 }
585 // Variablen anlegen
586 {
587 Atom nVarId;
588 RscEnum * pSymbol;
589
590 aBaseLst.Insert( pSymbol = new RscEnum( pHS->getID( "EnumSymbolButton" ),
591 RSC_NOTYPE ), LIST_APPEND );
592
593 SETCONST( pSymbol, "IMAGEBUTTON_DONTKNOW", SYMBOL_DONTKNOW );
594 SETCONST( pSymbol, "IMAGEBUTTON_IMAGE", SYMBOL_IMAGE );
595 SETCONST( pSymbol, "IMAGEBUTTON_ARROW_UP", SYMBOL_ARROW_UP );
596 SETCONST( pSymbol, "IMAGEBUTTON_ARROW_DOWN", SYMBOL_ARROW_DOWN );
597 SETCONST( pSymbol, "IMAGEBUTTON_ARROW_LEFT", SYMBOL_ARROW_LEFT );
598 SETCONST( pSymbol, "IMAGEBUTTON_ARROW_RIGHT", SYMBOL_ARROW_RIGHT );
599 SETCONST( pSymbol, "IMAGEBUTTON_SPIN_UP", SYMBOL_SPIN_UP );
600 SETCONST( pSymbol, "IMAGEBUTTON_SPIN_DOWN", SYMBOL_SPIN_DOWN );
601 SETCONST( pSymbol, "IMAGEBUTTON_SPIN_LEFT", SYMBOL_SPIN_LEFT );
602 SETCONST( pSymbol, "IMAGEBUTTON_SPIN_RIGHT", SYMBOL_SPIN_RIGHT );
603 SETCONST( pSymbol, "IMAGEBUTTON_FIRST", SYMBOL_FIRST );
604 SETCONST( pSymbol, "IMAGEBUTTON_LAST", SYMBOL_LAST );
605 SETCONST( pSymbol, "IMAGEBUTTON_PREV", SYMBOL_PREV );
606 SETCONST( pSymbol, "IMAGEBUTTON_NEXT", SYMBOL_NEXT );
607 SETCONST( pSymbol, "IMAGEBUTTON_PAGEUP", SYMBOL_PAGEUP );
608 SETCONST( pSymbol, "IMAGEBUTTON_PAGEDOWN", SYMBOL_PAGEDOWN );
609 SETCONST( pSymbol, "IMAGEBUTTON_PLAY", SYMBOL_PLAY );
610 SETCONST( pSymbol, "IMAGEBUTTON_REVERSEPLAY", SYMBOL_REVERSEPLAY );
611 SETCONST( pSymbol, "IMAGEBUTTON_STOP", SYMBOL_STOP );
612 SETCONST( pSymbol, "IMAGEBUTTON_PAUSE", SYMBOL_PAUSE );
613 SETCONST( pSymbol, "IMAGEBUTTON_WINDSTART", SYMBOL_WINDSTART );
614 SETCONST( pSymbol, "IMAGEBUTTON_WINDEND", SYMBOL_WINDEND );
615 SETCONST( pSymbol, "IMAGEBUTTON_WINDBACKWARD", SYMBOL_WINDBACKWARD );
616 SETCONST( pSymbol, "IMAGEBUTTON_WINDFORWARD", SYMBOL_WINDFORWARD );
617
618 // Variable einfuegen
619 nVarId = aNmTb.Put( "Symbol", VARNAME );
620 pClassImageButton->SetVariable( nVarId, pSymbol, NULL, 0,
621 RSC_IMAGEBUTTON_SYMBOL );
622 }
623 nId = aNmTb.Put( "State", VARNAME );
624 pClassImageButton->SetVariable( nId, pTriState, NULL, 0,
625 RSC_IMAGEBUTTON_STATE );
626
627 INS_WINBIT(pClassImageButton,Repeat)
628 INS_WINBIT(pClassImageButton,SmallStyle)
629 INS_WINBIT(pClassImageButton,RectStyle)
630
631 return pClassImageButton;
632 }
633
634 /*************************************************************************
635 |* RscTypCont::InitClassEdit()
636 *************************************************************************/
637 RscTop * RscTypCont::InitClassEdit( RscTop * pSuper )
638 {
639 Atom nId;
640 RscTop * pClassEdit;
641
642 // Klasse anlegen
643 nId = pHS->getID( "Edit" );
644 pClassEdit = new RscClass( nId, RSC_EDIT, pSuper );
645 pClassEdit->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
646 aNmTb.Put( nId, CLASSNAME, pClassEdit );
647
648 INS_WINBIT(pClassEdit,Left)
649 INS_WINBIT(pClassEdit,Center)
650 INS_WINBIT(pClassEdit,Right)
651 INS_WINBIT(pClassEdit,PassWord)
652 INS_WINBIT(pClassEdit,ReadOnly)
653
654 nId = aNmTb.Put( "MaxTextLength", VARNAME );
655 pClassEdit->SetVariable( nId, &aUShort );
656
657 return pClassEdit;
658 }
659
660 /*************************************************************************
661 |* RscTypCont::InitClassMultiLineedit()
662 *************************************************************************/
663 RscTop * RscTypCont::InitClassMultiLineEdit( RscTop * pSuper )
664 {
665 Atom nId;
666 RscTop * pClassMultiLineEdit;
667
668 // Klasse anlegen
669 nId = pHS->getID( "MultiLineEdit" );
670 pClassMultiLineEdit = new RscClass( nId, RSC_MULTILINEEDIT, pSuper );
671 pClassMultiLineEdit->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
672
673 aNmTb.Put( nId, CLASSNAME, pClassMultiLineEdit );
674
675 INS_WINBIT( pClassMultiLineEdit, HScroll );
676 INS_WINBIT( pClassMultiLineEdit, VScroll );
677 INS_WINBIT( pClassMultiLineEdit, IgnoreTab );
678 INS_WINBIT( pClassMultiLineEdit, AutoVScroll )
679
680 return pClassMultiLineEdit;
681 }
682
683 /*************************************************************************
684 |* RscTypCont::InitClassScrollBar()
685 *************************************************************************/
686 RscTop * RscTypCont::InitClassScrollBar( RscTop * pSuper )
687 {
688 Atom nId;
689 RscTop * pClassScrollBar;
690
691 // Klasse anlegen
692 nId = pHS->getID( "ScrollBar" );
693 pClassScrollBar = new RscClass( nId, RSC_SCROLLBAR, pSuper );
694 pClassScrollBar->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
695 aNmTb.Put( nId, CLASSNAME, pClassScrollBar );
696
697 // Variablen anlegen
698 nId = aNmTb.Put( "MinPos", VARNAME );
699 pClassScrollBar->SetVariable( nId, &aShort );
700 {
701 RSCINST aDfltI;
702
703 aDfltI = aShort.Create( NULL, RSCINST(), sal_False );
704 aDfltI.pClass->SetNumber( aDfltI, 100 );
705 // aDfltI.pClass->MakeDefault( aDfltI );
706
707 nId = aNmTb.Put( "MaxPos", VARNAME );
708 pClassScrollBar->SetVariable( nId, &aShort, &aDfltI );
709 }
710 nId = aNmTb.Put( "ThumbPos", VARNAME );
711 pClassScrollBar->SetVariable( nId, &aShort );
712 {
713 RSCINST aDfltI;
714
715 aDfltI = aShort.Create( NULL, RSCINST(), sal_False );
716 aDfltI.pClass->SetNumber( aDfltI, 1 );
717 // aDfltI.pClass->MakeDefault( aDfltI );
718
719 nId = aNmTb.Put( "PageSize", VARNAME);
720 pClassScrollBar->SetVariable( nId, &aShort, &aDfltI );
721 }
722 {
723 RSCINST aDfltI;
724
725 aDfltI = aShort.Create( NULL, RSCINST(), sal_False );
726 aDfltI.pClass->SetNumber( aDfltI, 1 );
727 // aDfltI.pClass->MakeDefault( aDfltI );
728 nId = aNmTb.Put( "LineSize", VARNAME );
729 pClassScrollBar->SetVariable( nId, &aShort, &aDfltI );
730 }
731 nId = aNmTb.Put( "VisibleSize", VARNAME );
732 pClassScrollBar->SetVariable( nId, &aShort );
733
734 INS_WINBIT( pClassScrollBar, HScroll );
735 INS_WINBIT( pClassScrollBar, VScroll );
736 INS_WINBIT( pClassScrollBar, Drag )
737
738 return pClassScrollBar;
739 }
740
741 /*************************************************************************
742 |* RscTypCont::InitClassListBox()
743 *************************************************************************/
744 RscTop * RscTypCont::InitClassListBox( RscTop * pSuper, RscArray * pStrLst )
745 {
746 Atom nId;
747 RscTop * pClassListBox;
748
749 // Klasse anlegen
750 nId = pHS->getID( "ListBox" );
751 pClassListBox = new RscClass( nId, RSC_LISTBOX, pSuper );
752 pClassListBox->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
753 aNmTb.Put( nId, CLASSNAME, pClassListBox );
754
755 // Variablen anlegen
756 INS_WINBIT(pClassListBox,Sort)
757 INS_WINBIT(pClassListBox,DropDown)
758 INS_WINBIT(pClassListBox,HScroll);
759 INS_WINBIT(pClassListBox,VScroll);
760 INS_WINBIT(pClassListBox,AutoSize)
761 INS_WINBIT(pClassListBox,AutoHScroll)
762 INS_WINBIT(pClassListBox,DDExtraWidth)
763
764 {
765 RSCINST aDflt = aUShort.Create( NULL, RSCINST(), sal_False );
766 aDflt.pClass->SetNumber( aDflt, (sal_uInt16)0xFFFF );
767 nId = aNmTb.Put( "CurPos", VARNAME );
768 pClassListBox->SetVariable( nId, &aUShort, &aDflt );
769 }
770 nId = aNmTb.Put( "StringList", VARNAME );
771 pClassListBox->SetVariable( nId, pStrLst );
772
773 return pClassListBox;
774 }
775
776 /*************************************************************************
777 |* RscTypCont::InitClassMultiListBox()
778 *************************************************************************/
779 RscTop * RscTypCont::InitClassMultiListBox( RscTop * pSuper )
780 {
781 Atom nId;
782 RscTop * pClassMultiListBox;
783
784 // Klasse anlegen
785 nId = pHS->getID( "MultiListBox" );
786 pClassMultiListBox = new RscClass( nId, RSC_MULTILISTBOX, pSuper );
787 pClassMultiListBox->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
788 aNmTb.Put( nId, CLASSNAME, pClassMultiListBox );
789
790 INS_WINBIT(pClassMultiListBox,SimpleMode)
791
792 return pClassMultiListBox;
793 }
794
795 /*************************************************************************
796 |* RscTypCont::InitClassComboBox()
797 *************************************************************************/
798 RscTop * RscTypCont::InitClassComboBox( RscTop * pSuper, RscArray * pStrLst )
799 {
800 Atom nId;
801 RscTop * pClassComboBox;
802
803 // Klasse anlegen
804 nId = pHS->getID( "ComboBox" );
805 pClassComboBox = new RscClass( nId, RSC_COMBOBOX, pSuper );
806 pClassComboBox->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
807 aNmTb.Put( nId, CLASSNAME, pClassComboBox );
808
809 // Variablen anlegen
810 INS_WINBIT(pClassComboBox,DropDown)
811 INS_WINBIT(pClassComboBox,Sort)
812 INS_WINBIT(pClassComboBox,HScroll);
813 INS_WINBIT(pClassComboBox,VScroll);
814 INS_WINBIT(pClassComboBox,AutoSize)
815 INS_WINBIT(pClassComboBox,AutoHScroll)
816 INS_WINBIT(pClassComboBox,DDExtraWidth)
817
818 nId = aNmTb.Put( "StringList", VARNAME );
819 pClassComboBox->SetVariable( nId, pStrLst );
820
821 return pClassComboBox;
822 }
823
824 /*************************************************************************
825 |* RscTypCont::InitClassFixedText()
826 *************************************************************************/
827 RscTop * RscTypCont::InitClassFixedText( RscTop * pSuper )
828 {
829 Atom nId;
830 RscTop * pClassFixedText;
831
832 // Klasse anlegen
833 nId = pHS->getID( "FixedText" );
834 pClassFixedText = new RscClass( nId, RSC_TEXT, pSuper );
835 pClassFixedText->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
836 aNmTb.Put( nId, CLASSNAME, pClassFixedText );
837
838 // Variablen anlegen
839 INS_WINBIT(pClassFixedText,Left)
840 INS_WINBIT(pClassFixedText,Center)
841 INS_WINBIT(pClassFixedText,Right)
842 INS_WINBIT(pClassFixedText,WordBreak)
843 INS_WINBIT(pClassFixedText,LeftLabel)
844 INS_WINBIT(pClassFixedText,NoLabel)
845 INS_WINBIT(pClassFixedText,Top)
846 INS_WINBIT(pClassFixedText,VCenter)
847 INS_WINBIT(pClassFixedText,Bottom)
848
849 return pClassFixedText;
850 }
851
852 /*************************************************************************
853 |* RscTypCont::InitClassFixedBitmap()
854 *************************************************************************/
855 RscTop * RscTypCont::InitClassFixedBitmap( RscTop * pSuper, RscTop * pClassBitmap )
856 {
857 Atom nId;
858 RscTop * pClassFixedBitmap;
859
860 // Klasse anlegen
861 nId = pHS->getID( "FixedBitmap" );
862 pClassFixedBitmap = new RscClass( nId, RSC_FIXEDBITMAP, pSuper );
863 pClassFixedBitmap->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
864 aNmTb.Put( nId, CLASSNAME, pClassFixedBitmap );
865
866 INS_WINBIT(pClassFixedBitmap,Scale)
867
868 // Variablen anlegen
869 nId = aNmTb.Put( "Fixed", VARNAME );
870 pClassFixedBitmap->SetVariable( nId, pClassBitmap, 0, 0, RSC_FIXEDBITMAP_BITMAP );
871
872 return pClassFixedBitmap;
873 }
874
875 /*************************************************************************
876 |* RscTypCont::InitClassFixedImage()
877 *************************************************************************/
878 RscTop * RscTypCont::InitClassFixedImage( RscTop * pSuper, RscTop * pClassImage )
879 {
880 Atom nId;
881 RscTop * pClassFixedImage;
882
883 // Klasse anlegen
884 nId = pHS->getID( "FixedImage" );
885 pClassFixedImage = new RscClass( nId, RSC_FIXEDIMAGE, pSuper );
886 pClassFixedImage->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
887 aNmTb.Put( nId, CLASSNAME, pClassFixedImage );
888
889 // Variablen anlegen
890 nId = aNmTb.Put( "Fixed", VARNAME );
891 pClassFixedImage->SetVariable( nId, pClassImage, 0, 0, RSC_FIXEDIMAGE_IMAGE );
892
893 return pClassFixedImage;
894 }
895
896 /*************************************************************************
897 |* RscTypCont::InitClassImageRadioButton()
898 *************************************************************************/
899 RscTop * RscTypCont::InitClassRadioButton( RscTop * pSuper )
900 {
901 Atom nId;
902 RscTop * pClassRadioButton;
903
904 // Klasse anlegen
905 nId = pHS->getID( "RadioButton" );
906 pClassRadioButton = new RscClass( nId, RSC_RADIOBUTTON, pSuper );
907 pClassRadioButton->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
908 aNmTb.Put( nId, CLASSNAME, pClassRadioButton );
909
910 // Variablen anlegen
911 INS_WINBIT( pClassRadioButton, WordBreak )
912 INS_WINBIT( pClassRadioButton, Top )
913 INS_WINBIT( pClassRadioButton, VCenter )
914 INS_WINBIT( pClassRadioButton, Bottom )
915
916 nId = aNmTb.Put( "Check", VARNAME );
917 pClassRadioButton->SetVariable( nId, &aBool );
918
919 return pClassRadioButton;
920 }
921
922 /*************************************************************************
923 |* RscTypCont::InitClassImageRadioButton()
924 *************************************************************************/
925 RscTop * RscTypCont::InitClassImageRadioButton( RscTop * pSuper, RscTop * pClassImage )
926 {
927 Atom nId;
928 RscTop * pClassImageRadioButton;
929
930 // Klasse anlegen
931 nId = pHS->getID( "ImageRadioButton" );
932 pClassImageRadioButton = new RscClass( nId, RSC_IMAGERADIOBUTTON, pSuper );
933 pClassImageRadioButton->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
934 aNmTb.Put( nId, CLASSNAME, pClassImageRadioButton );
935
936 // Variablen anlegen
937 INS_WINBIT(pClassImageRadioButton,TopImage)
938 nId = aNmTb.Put( "RadioButtonImage", VARNAME );
939 pClassImageRadioButton->SetVariable( nId, pClassImage, 0, 0, RSC_IMAGERADIOBUTTON_IMAGE );
940
941 return pClassImageRadioButton;
942 }
943
944 /*************************************************************************
945 |* RscTypCont::InitClassKeyCode()
946 *************************************************************************/
947 RscTop * RscTypCont::InitClassKeyCode( RscTop * pSuper, RscEnum * pKey )
948 {
949 Atom nId;
950 RscTop * pClassKeyCode;
951
952 // Klasse anlegen
953 nId = pHS->getID( "KeyCode" );
954 pClassKeyCode = new RscClass( nId, RSC_KEYCODE, pSuper );
955 aNmTb.Put( nId, CLASSNAME, pClassKeyCode );
956
957 // Variablen anlegen
958 nId = aNmTb.Put( "Code", VARNAME );
959 pClassKeyCode->SetVariable( nId, pKey );
960
961 {
962 RscFlag * pFlag;
963 RscClient * pClient;
964 Atom nVarId, nShiftId, nMod1Id, nMod2Id;
965
966 aBaseLst.Insert( pFlag = new RscFlag( pHS->getID( "FlagKeyModifier" ),
967 RSC_NOTYPE ),
968 LIST_APPEND );
969
970 // Konstanten in Tabelle stellen
971 nShiftId = pHS->getID( "KEY_SHIFT" );
972 SETCONST( pFlag, nShiftId, KEY_SHIFT );
973 nMod1Id = pHS->getID( "KEY_MOD1" );
974 SETCONST( pFlag, nMod1Id, KEY_MOD1 );
975 nMod2Id = pHS->getID( "KEY_MOD2" );
976 SETCONST( pFlag, nMod2Id, KEY_MOD2 );
977
978 // Variable einfuegen
979 nVarId = aNmTb.Put( "_ModifierFlags", VARNAME );
980 pClassKeyCode->SetVariable( nVarId, pFlag, NULL,
981 VAR_HIDDEN | VAR_NOENUM );
982
983 // Clientvariablen einfuegen
984 aBaseLst.Insert(
985 pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE,
986 pFlag, nShiftId ),
987 LIST_APPEND );
988 nId = aNmTb.Put( "Shift", VARNAME );
989 pClassKeyCode->SetVariable( nId, pClient, NULL,
990 VAR_NODATAINST, 0, nVarId );
991
992 aBaseLst.Insert(
993 pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE,
994 pFlag, nMod1Id ),
995 LIST_APPEND );
996 nId = aNmTb.Put( "Modifier1", VARNAME );
997 pClassKeyCode->SetVariable( nId, pClient, NULL,
998 VAR_NODATAINST, 0, nVarId );
999
1000
1001 aBaseLst.Insert(
1002 pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE,
1003 pFlag, nMod2Id ),
1004 LIST_APPEND );
1005 nId = aNmTb.Put( "Modifier2", VARNAME );
1006 pClassKeyCode->SetVariable( nId, pClient, NULL,
1007 VAR_NODATAINST, 0, nVarId );
1008 }
1009 {
1010 Atom nVarId;
1011 RscEnum * pKeyFunc;
1012
1013 aBaseLst.Insert( pKeyFunc = new RscEnum( pHS->getID( "EnumKeyFunc" ),
1014 RSC_NOTYPE ),
1015 LIST_APPEND );
1016
1017 SETCONST( pKeyFunc, "KEYFUNC_DONTKNOW", KEYFUNC_DONTKNOW );
1018 SETCONST( pKeyFunc, "KEYFUNC_NEW", KEYFUNC_NEW );
1019 SETCONST( pKeyFunc, "KEYFUNC_OPEN", KEYFUNC_OPEN );
1020 SETCONST( pKeyFunc, "KEYFUNC_SAVE", KEYFUNC_SAVE );
1021 SETCONST( pKeyFunc, "KEYFUNC_SAVEAS", KEYFUNC_SAVEAS );
1022 SETCONST( pKeyFunc, "KEYFUNC_PRINT", KEYFUNC_PRINT );
1023 SETCONST( pKeyFunc, "KEYFUNC_CLOSE", KEYFUNC_CLOSE );
1024 SETCONST( pKeyFunc, "KEYFUNC_QUIT", KEYFUNC_QUIT );
1025 SETCONST( pKeyFunc, "KEYFUNC_CUT", KEYFUNC_CUT );
1026 SETCONST( pKeyFunc, "KEYFUNC_COPY", KEYFUNC_COPY );
1027 SETCONST( pKeyFunc, "KEYFUNC_PASTE", KEYFUNC_PASTE );
1028 SETCONST( pKeyFunc, "KEYFUNC_UNDO", KEYFUNC_UNDO );
1029 SETCONST( pKeyFunc, "KEYFUNC_REDO", KEYFUNC_REDO );
1030 SETCONST( pKeyFunc, "KEYFUNC_DELETE", KEYFUNC_DELETE );
1031 SETCONST( pKeyFunc, "KEYFUNC_REPEAT", KEYFUNC_REPEAT );
1032 SETCONST( pKeyFunc, "KEYFUNC_FIND", KEYFUNC_FIND );
1033 SETCONST( pKeyFunc, "KEYFUNC_PROPERTIES", KEYFUNC_PROPERTIES );
1034 SETCONST( pKeyFunc, "KEYFUNC_FRONT", KEYFUNC_FRONT );
1035 SETCONST( pKeyFunc, "KEYFUNC_FINDBACKWARD", KEYFUNC_FINDBACKWARD );
1036 // Variable einfuegen
1037 nVarId = aNmTb.Put( "Function", VARNAME );
1038 pClassKeyCode->SetVariable( nVarId, pKeyFunc, NULL );
1039 }
1040
1041 return pClassKeyCode;
1042 }
1043
1044 /*************************************************************************
1045 |* RscTypCont::InitClassAccelItem()
1046 *************************************************************************/
1047 RscTop * RscTypCont::InitClassAccelItem( RscTop * pSuper,
1048 RscTop * pClassKeyCode )
1049 {
1050 Atom nId;
1051 RscTop * pClassAccelItem;
1052
1053 // Klasse anlegen
1054 nId = pHS->getID( "AcceleratorItem" );
1055 pClassAccelItem = new RscClass( nId, RSC_ACCELITEM, pSuper );
1056 aNmTb.Put( nId, CLASSNAME, pClassAccelItem );
1057
1058 // Variablen anlegen
1059 nId = aNmTb.Put( "Identifier", VARNAME );
1060 pClassAccelItem->SetVariable( nId, &aIdNoZeroUShort );
1061 nId = aNmTb.Put( "Disable", VARNAME );
1062 pClassAccelItem->SetVariable( nId, &aBool );
1063 nId = aNmTb.Put( "Key", VARNAME );
1064 pClassAccelItem->SetVariable( nId, pClassKeyCode, NULL, 0,
1065 ACCELITEM_KEY );
1066
1067 return pClassAccelItem;
1068 }
1069
1070 /*************************************************************************
1071 |* RscTypCont::InitClassAccelm()
1072 *************************************************************************/
1073 RscTop * RscTypCont::InitClassAccel( RscTop * pSuper, RscTop * pClassAccelItem )
1074 {
1075 Atom nId;
1076 RscTop * pClassAccel;
1077
1078 // Klasse anlegen
1079 nId = pHS->getID( "Accelerator" );
1080 pClassAccel = new RscClass( nId, RSC_ACCEL, pSuper );
1081 pClassAccel->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType );
1082 aNmTb.Put( nId, CLASSNAME, pClassAccel );
1083
1084 // Variablen anlegen
1085 nId = aNmTb.Put( "HelpText", VARNAME );
1086 pClassAccel->SetVariable( nId, &aLangString );
1087 {
1088 RscCont * pCont;
1089
1090 aBaseLst.Insert( pCont = new RscCont(
1091 pHS->getID( "ContAcceleratorKey" ),
1092 RSC_NOTYPE ),
1093 LIST_APPEND );
1094 pCont->SetTypeClass( pClassAccelItem );
1095 nId = aNmTb.Put( "ItemList", VARNAME );
1096 pClassAccel->SetVariable( nId, pCont );
1097 }
1098
1099 return pClassAccel;
1100 }
1101
1102 /*************************************************************************
1103 |* RscTypCont::InitClassMenuItem()
1104 *************************************************************************/
1105 RscTop * RscTypCont::InitClassMenuItem( RscTop * pSuper,
1106 RscTop * pClassBitmap,
1107 RscTop * pClassKeyCode )
1108 {
1109 Atom nId;
1110 RscTop * pClassMenuItem;
1111
1112 // Klasse anlegen
1113 nId = pHS->getID( "MenuItem" );
1114 pClassMenuItem = new RscClass( nId, RSC_MENUITEM, pSuper );
1115 aNmTb.Put( nId, CLASSNAME, pClassMenuItem );
1116
1117 // Variablen anlegen
1118 nId = aNmTb.Put( "Separator", VARNAME );
1119 pClassMenuItem->SetVariable( nId, &aBool, NULL, 0,
1120 RSC_MENUITEM_SEPARATOR );
1121 nId = aNmTb.Put( "Identifier", VARNAME );
1122 pClassMenuItem->SetVariable( nId, &aIdNoZeroUShort, NULL, 0,
1123 RSC_MENUITEM_ID );
1124 {
1125 RscFlag * pFlag;
1126 RscClient * pClient;
1127 Atom nVarId, nAutoCheckId, nRadioCheckId;
1128 Atom nCheckableId, nAboutId, nHelpId;
1129
1130 aBaseLst.Insert( pFlag = new RscFlag( pHS->getID( "FlagMenuState" ),
1131 RSC_NOTYPE ),
1132 LIST_APPEND );
1133
1134 // Konstanten in Tabelle stellen
1135 nCheckableId = pHS->getID( "MIB_CHECKABLE" );
1136 SETCONST( pFlag, nCheckableId, MIB_CHECKABLE );
1137 nAutoCheckId = pHS->getID( "MIB_AUTOCHECK" );
1138 SETCONST( pFlag, nAutoCheckId, MIB_AUTOCHECK );
1139 nRadioCheckId = pHS->getID( "MIB_RADIOCHECK" );
1140 SETCONST( pFlag, nRadioCheckId, MIB_RADIOCHECK );
1141 nAboutId = pHS->getID( "MIB_ABOUT" );
1142 SETCONST( pFlag, nAboutId, MIB_ABOUT );
1143 nHelpId = pHS->getID( "MIB_HELP" );
1144 SETCONST( pFlag, nHelpId, MIB_HELP );
1145
1146 // Variable einfuegen
1147 nVarId = aNmTb.Put( "_MenuItemFlags", VARNAME );
1148 pClassMenuItem->SetVariable( nVarId, pFlag, NULL,
1149 VAR_HIDDEN | VAR_NOENUM,
1150 RSC_MENUITEM_STATUS );
1151
1152 // Clientvariablen einfuegen
1153 aBaseLst.Insert(
1154 pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE,
1155 pFlag, nCheckableId ),
1156 LIST_APPEND );
1157 nId = aNmTb.Put( "Checkable", VARNAME );
1158 pClassMenuItem->SetVariable( nId, pClient, NULL,
1159 VAR_NODATAINST, 0, nVarId );
1160
1161 aBaseLst.Insert(
1162 pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE,
1163 pFlag, nAutoCheckId ),
1164 LIST_APPEND );
1165 nId = aNmTb.Put( "AutoCheck", VARNAME );
1166 pClassMenuItem->SetVariable( nId, pClient, NULL,
1167 VAR_NODATAINST, 0, nVarId );
1168
1169 aBaseLst.Insert(
1170 pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE,
1171 pFlag, nRadioCheckId ),
1172 LIST_APPEND );
1173 nId = aNmTb.Put( "RadioCheck", VARNAME );
1174 pClassMenuItem->SetVariable( nId, pClient, NULL,
1175 VAR_NODATAINST, 0, nVarId );
1176
1177 aBaseLst.Insert(
1178 pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE,
1179 pFlag, nAboutId ),
1180 LIST_APPEND );
1181 nId = aNmTb.Put( "About", VARNAME );
1182 pClassMenuItem->SetVariable( nId, pClient, NULL,
1183 VAR_NODATAINST, 0, nVarId );
1184
1185 aBaseLst.Insert(
1186 pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE,
1187 pFlag, nHelpId ),
1188 LIST_APPEND );
1189 nId = aNmTb.Put( "Help", VARNAME );
1190 pClassMenuItem->SetVariable( nId, pClient, NULL,
1191 VAR_NODATAINST, 0, nVarId );
1192
1193 }
1194 nId = aNmTb.Put( "Text", VARNAME );
1195 pClassMenuItem->SetVariable( nId, &aLangString, NULL, 0,
1196 RSC_MENUITEM_TEXT );
1197 nId = aNmTb.Put( "ItemBitmap", VARNAME );
1198 pClassMenuItem->SetVariable( nId, pClassBitmap, NULL, 0,
1199 RSC_MENUITEM_BITMAP );
1200 nId = aNmTb.Put( "HelpText", VARNAME );
1201 pClassMenuItem->SetVariable( nId, &aLangString, NULL, 0,
1202 RSC_MENUITEM_HELPTEXT );
1203 nId = aNmTb.Put( "HelpID", VARNAME );
1204 pClassMenuItem->SetVariable( nId, &aStringLiteral, NULL, 0,
1205 RSC_MENUITEM_HELPID );
1206 nId = aNmTb.Put( "AccelKey", VARNAME );
1207 pClassMenuItem->SetVariable( nId, pClassKeyCode, NULL, 0,
1208 RSC_MENUITEM_KEYCODE );
1209 nId = aNmTb.Put( "Check", VARNAME );
1210 pClassMenuItem->SetVariable( nId, &aBool, NULL, 0,
1211 RSC_MENUITEM_CHECKED );
1212 nId = aNmTb.Put( "Disable", VARNAME );
1213 pClassMenuItem->SetVariable( nId, &aBool, NULL, 0,
1214 RSC_MENUITEM_DISABLE );
1215 nId = aNmTb.Put( "Command", VARNAME );
1216 pClassMenuItem->SetVariable( nId, &aString, NULL, 0,
1217 RSC_MENUITEM_COMMAND );
1218
1219 return pClassMenuItem;
1220 }
1221
1222 /*************************************************************************
1223 |* RscTypCont::InitClassMenu()
1224 *************************************************************************/
1225 RscTop * RscTypCont::InitClassMenu( RscTop * pSuper,
1226 RscTop * pClassMenuItem )
1227 {
1228 Atom nId;
1229 RscTop * pClassMenu;
1230
1231 // Klasse anlegen
1232 nId = pHS->getID( "Menu" );
1233 pClassMenu = new RscClass( nId, RSC_MENU, pSuper );
1234 pClassMenu->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType );
1235 aNmTb.Put( nId, CLASSNAME, pClassMenu );
1236
1237 // Variablen anlegen
1238 {
1239 RscCont * pCont;
1240
1241 aBaseLst.Insert( pCont = new RscCont( pHS->getID( "ContMenuItem" ),
1242 RSC_NOTYPE ),
1243 LIST_APPEND );
1244 pCont->SetTypeClass( pClassMenuItem );
1245 nId = aNmTb.Put( "ItemList", VARNAME );
1246 pClassMenu->SetVariable( nId, pCont, NULL, 0, RSC_MENU_ITEMS );
1247 }
1248 nId = aNmTb.Put( "Text", VARNAME );
1249 pClassMenu->SetVariable( nId, &aLangString, NULL, 0, RSC_MENU_TEXT );
1250 nId = aNmTb.Put( "DefaultItemId", VARNAME );
1251 pClassMenu->SetVariable( nId, &aIdUShort, NULL, 0,
1252 RSC_MENU_DEFAULTITEMID );
1253
1254 return pClassMenu;
1255 }
1256
1257 /*************************************************************************
1258 |* RscTypCont::InitClassMessageBox()
1259 *************************************************************************/
1260 RscTop * RscTypCont::InitClassMessBox( RscTop * pSuper,
1261 RscEnum * pMessButtons,
1262 RscEnum * pMessDefButton )
1263 {
1264 Atom nId;
1265 RscTop * pClassMessBox;
1266
1267 // Klasse anlegen
1268 nId = pHS->getID( "MessBox" );
1269 pClassMessBox = new RscClass( nId, RSC_MESSBOX, pSuper );
1270 pClassMessBox->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
1271 aNmTb.Put( nId, CLASSNAME, pClassMessBox );
1272
1273 // Variablen anlegen
1274 nId = aNmTb.Put( "Buttons", VARNAME );
1275 pClassMessBox->SetVariable( nId, pMessButtons );
1276 nId = aNmTb.Put( "DefButton", VARNAME );
1277 pClassMessBox->SetVariable( nId, pMessDefButton );
1278 nId = aNmTb.Put( "HelpID", VARNAME );
1279 pClassMessBox->SetVariable( nId, &aStringLiteral );
1280 nId = aNmTb.Put( "SysModal", VARNAME );
1281 pClassMessBox->SetVariable( nId, &aBool );
1282 nId = aNmTb.Put( "Title", VARNAME );
1283 pClassMessBox->SetVariable( nId, &aLangString );
1284 nId = aNmTb.Put( "Message", VARNAME );
1285 pClassMessBox->SetVariable( nId, &aLangString );
1286 nId = aNmTb.Put( "HelpText", VARNAME );
1287 pClassMessBox->SetVariable( nId, &aLangString );
1288
1289 return pClassMessBox;
1290 }
1291
1292 /*************************************************************************
1293 |* RscTypCont::InitClassSplitter()
1294 *************************************************************************/
1295 RscTop * RscTypCont::InitClassSplitter( RscTop * pSuper )
1296 {
1297 Atom nId;
1298 RscTop * pClassSplitter;
1299
1300 // Klasse anlegen
1301 nId = pHS->getID( "Splitter" );
1302 pClassSplitter = new RscClass( nId, RSC_SPLITTER, pSuper );
1303 pClassSplitter->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
1304
1305 aNmTb.Put( nId, CLASSNAME, pClassSplitter );
1306
1307 INS_WINBIT(pClassSplitter,HScroll);
1308 INS_WINBIT(pClassSplitter,VScroll);
1309
1310 return pClassSplitter;
1311 }
1312
1313 /*************************************************************************
1314 |* RscTypCont::InitClassSplitWindow()
1315 *************************************************************************/
1316 RscTop * RscTypCont::InitClassSplitWindow( RscTop * pSuper )
1317 {
1318 Atom nId;
1319 RscTop * pClassSplitWindow;
1320
1321 // Klasse anlegen
1322 nId = pHS->getID( "SplitWindow" );
1323 pClassSplitWindow = new RscClass( nId, RSC_SPLITWINDOW, pSuper );
1324 pClassSplitWindow->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
1325
1326 aNmTb.Put( nId, CLASSNAME, pClassSplitWindow );
1327
1328 INS_WINBIT(pClassSplitWindow,Sizeable)
1329 INS_WINBIT(pClassSplitWindow,NoSplitDraw)
1330
1331 return pClassSplitWindow;
1332 }
1333
1334 /*************************************************************************
1335 |* RscTypCont::InitClassTime()
1336 *************************************************************************/
1337 RscTop * RscTypCont::InitClassTime( RscTop * pSuper )
1338 {
1339 Atom nId;
1340 RscTop * pClassTime;
1341
1342 // Klasse anlegen
1343 nId = pHS->getID( "Time" );
1344 pClassTime = new RscClass( nId, RSC_TIME, pSuper );
1345 pClassTime->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType );
1346
1347 aNmTb.Put( nId, CLASSNAME, pClassTime );
1348
1349 // Variablen anlegen
1350 nId = aNmTb.Put( "Hour", VARNAME );
1351 pClassTime->SetVariable( nId, &a0to23Short, NULL, 0, TIME_HOUR );
1352
1353 nId = aNmTb.Put( "Minute", VARNAME );
1354 pClassTime->SetVariable( nId, &a0to59Short, NULL, 0, TIME_MINUTE );
1355
1356 nId = aNmTb.Put( "Second", VARNAME );
1357 pClassTime->SetVariable( nId, &a0to59Short, NULL, 0, TIME_SECOND );
1358
1359 nId = aNmTb.Put( "Sec100", VARNAME ); // weiss noch nich
1360 pClassTime->SetVariable( nId, &a0to99Short, NULL, 0, TIME_SEC100 );
1361
1362 return pClassTime;
1363 }
1364
1365 /*************************************************************************
1366 |* RscTypCont::InitClassDate()
1367 *************************************************************************/
1368 RscTop * RscTypCont::InitClassDate( RscTop * pSuper )
1369 {
1370 Atom nId;
1371 RscTop * pClassDate;
1372
1373 // Klasse anlegen
1374 nId = pHS->getID( "Date" );
1375 pClassDate = new RscClass( nId, RSC_DATE, pSuper );
1376 pClassDate->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType );
1377
1378 aNmTb.Put( nId, CLASSNAME, pClassDate );
1379
1380 // Variablen anlegen
1381 nId = aNmTb.Put( "Year", VARNAME );
1382 pClassDate->SetVariable( nId, &a0to9999Short, NULL, 0, DATE_YEAR );
1383
1384 nId = aNmTb.Put( "Month", VARNAME );
1385 pClassDate->SetVariable( nId, &a1to12Short, NULL, 0, DATE_MONTH );
1386
1387 nId = aNmTb.Put( "Day", VARNAME );
1388 pClassDate->SetVariable( nId, &a1to31Short, NULL, 0, DATE_DAY );
1389
1390 return pClassDate;
1391 }
1392
1393 /*************************************************************************
1394 |* RscTypCont::InitClassPatternFormatter()
1395 *************************************************************************/
1396 RscTop * RscTypCont::InitClassPatternFormatter( RscTop * pSuper )
1397 {
1398 Atom nId;
1399 RscTop * pClassPattern;
1400
1401 // Klasse anlegen
1402 nId = pHS->getID( "PatternFormatter" );
1403 pClassPattern = new RscClass( nId, RSC_NOTYPE, pSuper );
1404 pClassPattern->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType );
1405
1406 // Variablen anlegen
1407 nId = aNmTb.Put( "StrictFormat", VARNAME );
1408 pClassPattern->SetVariable( nId, &aBool, NULL,
1409 0, PATTERNFORMATTER_STRICTFORMAT );
1410 nId = aNmTb.Put( "EditMask", VARNAME );
1411 pClassPattern->SetVariable( nId, &aLangString, NULL,
1412 0, PATTERNFORMATTER_EDITMASK );
1413 nId = aNmTb.Put( "LiteralMask", VARNAME );
1414 pClassPattern->SetVariable( nId, &aLangString, NULL,
1415 0, PATTERNFORMATTER_LITTERALMASK );
1416
1417 return pClassPattern;
1418 }
1419
1420 /*************************************************************************
1421 |* RscTypCont::InitClassNumericFormatter()
1422 *************************************************************************/
1423 RscTop * RscTypCont::InitClassNumericFormatter( RscTop * pSuper )
1424 {
1425 Atom nId;
1426 RscTop * pClassNumeric;
1427
1428 // Klasse anlegen
1429 nId = pHS->getID( "NumericFormatter" );
1430 pClassNumeric = new RscClass( nId, RSC_NOTYPE, pSuper );
1431 pClassNumeric->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType );
1432
1433 // Variablen anlegen
1434 nId = aNmTb.Put( "Minimum", VARNAME );
1435 pClassNumeric->SetVariable( nId, &aIdLong, NULL,
1436 0, NUMERICFORMATTER_MIN );
1437 nId = aNmTb.Put( "Maximum", VARNAME );
1438 pClassNumeric->SetVariable( nId, &aIdLong, NULL,
1439 0, NUMERICFORMATTER_MAX );
1440 nId = aNmTb.Put( "StrictFormat", VARNAME );
1441 pClassNumeric->SetVariable( nId, &aBool, NULL,
1442 0, NUMERICFORMATTER_STRICTFORMAT );
1443 nId = aNmTb.Put( "DecimalDigits", VARNAME );
1444 pClassNumeric->SetVariable( nId, &aUShort, NULL,
1445 0, NUMERICFORMATTER_DECIMALDIGITS );
1446 nId = aNmTb.Put( "Value", VARNAME );
1447 pClassNumeric->SetVariable( nId, &aIdLong, NULL,
1448 0, NUMERICFORMATTER_VALUE );
1449 nId = aNmTb.Put( "NoThousandSep", VARNAME );
1450 pClassNumeric->SetVariable( nId, &aBool, NULL,
1451 0, NUMERICFORMATTER_NOTHOUSANDSEP );
1452
1453 return pClassNumeric;
1454 }
1455
1456 /*************************************************************************
1457 |* RscTypCont::InitClassMetricFormatter()
1458 *************************************************************************/
1459 RscTop * RscTypCont::InitClassMetricFormatter( RscTop * pSuper,
1460 RscEnum * pFieldUnits )
1461 {
1462 Atom nId;
1463 RscTop * pClassMetric;
1464
1465 // Klasse anlegen
1466 nId = pHS->getID( "MetricFormatter" );
1467 pClassMetric = new RscClass( nId, RSC_NOTYPE, pSuper );
1468 pClassMetric->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType );
1469
1470 // Variablen anlegen
1471 nId = aNmTb.Put( "Unit", VARNAME );
1472 pClassMetric->SetVariable( nId, pFieldUnits, NULL,
1473 0, METRICFORMATTER_UNIT );
1474 nId = aNmTb.Put( "CustomUnitText", VARNAME );
1475 pClassMetric->SetVariable( nId, &aLangString, NULL,
1476 0, METRICFORMATTER_CUSTOMUNITTEXT );
1477
1478 return pClassMetric;
1479 }
1480
1481 /*************************************************************************
1482 |* RscTypCont::InitClassCurrencyFormatter()
1483 *************************************************************************/
1484 RscTop * RscTypCont::InitClassCurrencyFormatter
1485 (
1486 RscTop * pSuper,
1487 RscEnum * /* pFieldUnits */)
1488 {
1489 Atom nId;
1490 RscTop * pClassCurrency;
1491
1492 // Klasse anlegen
1493 nId = pHS->getID( "CurrencyFormatter" );
1494 pClassCurrency = new RscClass( nId, RSC_NOTYPE, pSuper );
1495 pClassCurrency->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType );
1496
1497 return pClassCurrency;
1498 }
1499
1500 /*************************************************************************
1501 |* RscTypCont::InitClassDateFormatter()
1502 *************************************************************************/
1503 RscTop * RscTypCont::InitClassDateFormatter( RscTop * pSuper,
1504 RscTop * pClassDate )
1505 {
1506 Atom nId;
1507 RscTop * pClassDateF;
1508
1509 // Klasse anlegen
1510 nId = pHS->getID( "DateFormatter" );
1511 pClassDateF = new RscClass( nId, RSC_NOTYPE, pSuper );
1512 pClassDateF->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType );
1513
1514 // Variablen anlegen
1515 nId = aNmTb.Put( "Minimum", VARNAME );
1516 pClassDateF->SetVariable( nId, pClassDate, NULL,
1517 0, DATEFORMATTER_MIN );
1518 nId = aNmTb.Put( "Maximum", VARNAME );
1519 pClassDateF->SetVariable( nId, pClassDate, NULL,
1520 0, DATEFORMATTER_MAX );
1521 nId = aNmTb.Put( "LongFormat", VARNAME );
1522 pClassDateF->SetVariable( nId, &aBool, NULL,
1523 0, DATEFORMATTER_LONGFORMAT );
1524 nId = aNmTb.Put( "StrictFormat", VARNAME );
1525 pClassDateF->SetVariable( nId, &aBool, NULL,
1526 0, DATEFORMATTER_STRICTFORMAT );
1527 nId = aNmTb.Put( "Value", VARNAME );
1528 pClassDateF->SetVariable( nId, pClassDate, NULL,
1529 0, DATEFORMATTER_VALUE );
1530
1531 return pClassDateF;
1532 }
1533
1534 /*************************************************************************
1535 |* RscTypCont::InitClassTimeFormatter()
1536 *************************************************************************/
1537 RscTop * RscTypCont::InitClassTimeFormatter( RscTop * pSuper,
1538 RscTop * pClassTime,
1539 RscEnum * pTimeFieldFormat )
1540 {
1541 Atom nId;
1542 RscTop * pClassTimeF;
1543
1544 // Klasse anlegen
1545 nId = pHS->getID( "TimeFormatter" );
1546 pClassTimeF = new RscClass( nId, RSC_NOTYPE, pSuper );
1547 pClassTimeF->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType );
1548
1549 // Variablen anlegen
1550 nId = aNmTb.Put( "Minimum", VARNAME );
1551 pClassTimeF->SetVariable( nId, pClassTime, NULL,
1552 0, TIMEFORMATTER_MIN );
1553 nId = aNmTb.Put( "Maximum", VARNAME );
1554 pClassTimeF->SetVariable( nId, pClassTime, NULL,
1555 0, TIMEFORMATTER_MAX );
1556 nId = aNmTb.Put( "Format", VARNAME );
1557 pClassTimeF->SetVariable( nId, pTimeFieldFormat, NULL,
1558 0, TIMEFORMATTER_TIMEFIELDFORMAT );
1559 nId = aNmTb.Put( "Duration", VARNAME );
1560 pClassTimeF->SetVariable( nId, &aBool, NULL,
1561 0, TIMEFORMATTER_DURATION );
1562 nId = aNmTb.Put( "StrictFormat", VARNAME );
1563 pClassTimeF->SetVariable( nId, &aBool, NULL,
1564 0, TIMEFORMATTER_STRICTFORMAT );
1565 nId = aNmTb.Put( "Value", VARNAME );
1566 pClassTimeF->SetVariable( nId, pClassTime, NULL,
1567 0, TIMEFORMATTER_VALUE );
1568
1569 return pClassTimeF;
1570 }
1571
1572 /*************************************************************************
1573 |* RscTypCont::InitClassSpinField()
1574 *************************************************************************/
1575 RscTop * RscTypCont::InitClassSpinField( RscTop * pSuper )
1576 {
1577 Atom nId;
1578 RscTop * pClassSpinField;
1579
1580 // Klasse anlegen
1581 nId = pHS->getID( "SpinField" );
1582 pClassSpinField = new RscClass( nId, RSC_SPINFIELD, pSuper );
1583 pClassSpinField->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
1584
1585 aNmTb.Put( nId, CLASSNAME, pClassSpinField );
1586
1587 INS_WINBIT(pClassSpinField,Repeat)
1588 INS_WINBIT(pClassSpinField,Spin)
1589
1590 return pClassSpinField;
1591 }
1592
1593 /*************************************************************************
1594 |* RscTypCont::InitClassPatternField()
1595 *************************************************************************/
1596 RscTop * RscTypCont::InitClassPatternField( RscTop * pSuper )
1597 {
1598 Atom nId;
1599 RscTop * pClassPatternField;
1600
1601 // Klasse anlegen
1602 nId = pHS->getID( "PatternField" );
1603 pClassPatternField = new RscClass( nId, RSC_PATTERNFIELD, pSuper );
1604 pClassPatternField->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
1605
1606 aNmTb.Put( nId, CLASSNAME, pClassPatternField );
1607
1608 return pClassPatternField;
1609 }
1610
1611 /*************************************************************************
1612 |* RscTypCont::InitClassNumericField()
1613 *************************************************************************/
1614 RscTop * RscTypCont::InitClassNumericField( RscTop * pSuper )
1615 {
1616 Atom nId;
1617 RscTop * pClassNumericField;
1618
1619 // Klasse anlegen
1620 nId = pHS->getID( "NumericField" );
1621 pClassNumericField = new RscClass( nId, RSC_NUMERICFIELD, pSuper );
1622 pClassNumericField->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
1623
1624 aNmTb.Put( nId, CLASSNAME, pClassNumericField );
1625
1626 // Variablen anlegen
1627 nId = aNmTb.Put( "First", VARNAME );
1628 pClassNumericField->SetVariable( nId, &aIdLong, NULL,
1629 0, NUMERICFIELD_FIRST );
1630 nId = aNmTb.Put( "Last", VARNAME );
1631 pClassNumericField->SetVariable( nId, &aIdLong, NULL,
1632 0, NUMERICFIELD_LAST );
1633 nId = aNmTb.Put( "SpinSize", VARNAME );
1634 pClassNumericField->SetVariable( nId, &aIdLong, NULL,
1635 0, NUMERICFIELD_SPINSIZE );
1636 return pClassNumericField;
1637 }
1638
1639 /*************************************************************************
1640 |* RscTypCont::InitClassMetricField()
1641 *************************************************************************/
1642 RscTop * RscTypCont::InitClassMetricField( RscTop * pSuper )
1643 {
1644 Atom nId;
1645 RscTop * pClassMetricField;
1646
1647 // Klasse anlegen
1648 nId = pHS->getID( "MetricField" );
1649 pClassMetricField = new RscClass( nId, RSC_METRICFIELD, pSuper );
1650 pClassMetricField->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
1651
1652 aNmTb.Put( nId, CLASSNAME, pClassMetricField );
1653
1654 // Variablen anlegen
1655 nId = aNmTb.Put( "First", VARNAME );
1656 pClassMetricField->SetVariable( nId, &aIdLong, NULL,
1657 0, METRICFIELD_FIRST );
1658 nId = aNmTb.Put( "Last", VARNAME );
1659 pClassMetricField->SetVariable( nId, &aIdLong, NULL,
1660 0, METRICFIELD_LAST );
1661 nId = aNmTb.Put( "SpinSize", VARNAME );
1662 pClassMetricField->SetVariable( nId, &aIdLong, NULL,
1663 0, METRICFIELD_SPINSIZE );
1664
1665 return pClassMetricField;
1666 }
1667
1668 /*************************************************************************
1669 |* RscTypCont::InitClassCurrencyField()
1670 *************************************************************************/
1671 RscTop * RscTypCont::InitClassCurrencyField
1672 (
1673 const char * pClassName,
1674 sal_uInt32 nRT,
1675 RscTop * pSuper
1676 )
1677 {
1678 Atom nId;
1679 RscTop * pClassCurrencyField;
1680
1681 // Klasse anlegen
1682 nId = pHS->getID( pClassName );
1683 pClassCurrencyField = new RscClass( nId, nRT, pSuper );
1684 pClassCurrencyField->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
1685
1686 aNmTb.Put( nId, CLASSNAME, pClassCurrencyField );
1687
1688 // Variablen anlegen
1689 nId = aNmTb.Put( "First", VARNAME );
1690 pClassCurrencyField->SetVariable( nId, &aIdLong, NULL,
1691 0, CURRENCYFIELD_FIRST );
1692 nId = aNmTb.Put( "Last", VARNAME );
1693 pClassCurrencyField->SetVariable( nId, &aIdLong, NULL,
1694 0, CURRENCYFIELD_LAST );
1695 nId = aNmTb.Put( "SpinSize", VARNAME );
1696 pClassCurrencyField->SetVariable( nId, &aIdLong, NULL,
1697 0, CURRENCYFIELD_SPINSIZE );
1698
1699 return pClassCurrencyField;
1700 }
1701
1702 /*************************************************************************
1703 |* RscTypCont::InitClassDateField()
1704 *************************************************************************/
1705 RscTop * RscTypCont::InitClassDateField( RscTop * pSuper, RscTop * pClassDate )
1706 {
1707 Atom nId;
1708 RscTop * pClassDateField;
1709
1710 // Klasse anlegen
1711 nId = pHS->getID( "DateField" );
1712 pClassDateField = new RscClass( nId, RSC_DATEFIELD, pSuper );
1713 pClassDateField->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
1714
1715 aNmTb.Put( nId, CLASSNAME, pClassDateField );
1716
1717 // Variablen anlegen
1718 nId = aNmTb.Put( "First", VARNAME );
1719 pClassDateField->SetVariable( nId, pClassDate, NULL, 0, DATEFIELD_FIRST );
1720 nId = aNmTb.Put( "Last", VARNAME );
1721 pClassDateField->SetVariable( nId, pClassDate, NULL, 0, DATEFIELD_LAST );
1722
1723 return pClassDateField;
1724 }
1725
1726 /*************************************************************************
1727 |* RscTypCont::InitClassTimeField()
1728 *************************************************************************/
1729 RscTop * RscTypCont::InitClassTimeField( RscTop * pSuper, RscTop * pClassTime )
1730 {
1731 Atom nId;
1732 RscTop * pClassTimeField;
1733
1734 // Klasse anlegen
1735 nId = pHS->getID( "TimeField" );
1736 pClassTimeField = new RscClass( nId, RSC_TIMEFIELD, pSuper );
1737 pClassTimeField->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
1738
1739 aNmTb.Put( nId, CLASSNAME, pClassTimeField );
1740
1741 // Variablen anlegen
1742 nId = aNmTb.Put( "First", VARNAME );
1743 pClassTimeField->SetVariable( nId, pClassTime, NULL, 0, TIMEFIELD_FIRST );
1744 nId = aNmTb.Put( "Last", VARNAME );
1745 pClassTimeField->SetVariable( nId, pClassTime, NULL, 0, TIMEFIELD_LAST );
1746
1747 return pClassTimeField;
1748 }
1749
1750 /*************************************************************************
1751 |* RscTypCont::InitClassPatternBox()
1752 *************************************************************************/
1753 RscTop * RscTypCont::InitClassPatternBox( RscTop * pSuper )
1754 {
1755 Atom nId;
1756 RscTop * pClassPatternBox;
1757
1758 // Klasse anlegen
1759 nId = pHS->getID( "PatternBox" );
1760 pClassPatternBox = new RscClass( nId, RSC_PATTERNBOX, pSuper );
1761 pClassPatternBox->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
1762
1763 aNmTb.Put( nId, CLASSNAME, pClassPatternBox );
1764
1765 return pClassPatternBox;
1766 }
1767
1768 /*************************************************************************
1769 |* RscTypCont::InitClassNumericBox()
1770 *************************************************************************/
1771 RscTop * RscTypCont::InitClassNumericBox( RscTop * pSuper )
1772 {
1773 Atom nId;
1774 RscTop * pClassNumericBox;
1775
1776 // Klasse anlegen
1777 nId = pHS->getID( "NumericBox" );
1778 pClassNumericBox = new RscClass( nId, RSC_NUMERICBOX, pSuper );
1779 pClassNumericBox->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
1780
1781 aNmTb.Put( nId, CLASSNAME, pClassNumericBox );
1782
1783 // Variablen anlegen
1784
1785 return pClassNumericBox;
1786 }
1787
1788 /*************************************************************************
1789 |* RscTypCont::InitClassMetricBox()
1790 *************************************************************************/
1791 RscTop * RscTypCont::InitClassMetricBox( RscTop * pSuper )
1792 {
1793 Atom nId;
1794 RscTop * pClassMetricBox;
1795
1796 // Klasse anlegen
1797 nId = pHS->getID( "MetricBox" );
1798 pClassMetricBox = new RscClass( nId, RSC_METRICBOX, pSuper );
1799 pClassMetricBox->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
1800
1801 aNmTb.Put( nId, CLASSNAME, pClassMetricBox );
1802
1803 // Variablen anlegen
1804
1805 return pClassMetricBox;
1806 }
1807
1808 /*************************************************************************
1809 |* RscTypCont::InitClassCurrencyBox()
1810 *************************************************************************/
1811 RscTop * RscTypCont::InitClassCurrencyBox
1812 (
1813 const char * pClassName,
1814 sal_uInt32 nRT,
1815 RscTop * pSuper
1816 )
1817 {
1818 Atom nId;
1819 RscTop * pClassCurrencyBox;
1820
1821 // Klasse anlegen
1822 nId = pHS->getID( pClassName );
1823 pClassCurrencyBox = new RscClass( nId, nRT, pSuper );
1824 pClassCurrencyBox->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
1825
1826 aNmTb.Put( nId, CLASSNAME, pClassCurrencyBox );
1827
1828 // Variablen anlegen
1829
1830 return pClassCurrencyBox;
1831 }
1832
1833 /*************************************************************************
1834 |* RscTypCont::InitClassDateBox()
1835 *************************************************************************/
1836 RscTop * RscTypCont::InitClassDateBox( RscTop * pSuper,
1837 RscTop * /*pClassDate*/ )
1838 {
1839 Atom nId;
1840 RscTop * pClassDateBox;
1841
1842 // Klasse anlegen
1843 nId = pHS->getID( "DateBox" );
1844 pClassDateBox = new RscClass( nId, RSC_DATEBOX, pSuper );
1845 pClassDateBox->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
1846
1847 aNmTb.Put( nId, CLASSNAME, pClassDateBox );
1848
1849 // Variablen anlegen
1850
1851 return pClassDateBox;
1852 }
1853
1854 /*************************************************************************
1855 |* RscTypCont::InitClassTimeBox()
1856 *************************************************************************/
1857 RscTop * RscTypCont::InitClassTimeBox( RscTop * pSuper,
1858 RscTop * /*pClassTime*/ )
1859 {
1860 Atom nId;
1861 RscTop * pClassTimeBox;
1862
1863 // Klasse anlegen
1864 nId = pHS->getID( "TimeBox" );
1865 pClassTimeBox = new RscClass( nId, RSC_TIMEBOX, pSuper );
1866 pClassTimeBox->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
1867
1868 aNmTb.Put( nId, CLASSNAME, pClassTimeBox );
1869
1870 // Variablen anlegen
1871
1872 return pClassTimeBox;
1873 }
1874
1875 /*************************************************************************
1876 |* RscTypCont::InitClassDockWindow()
1877 *************************************************************************/
1878 RscTop * RscTypCont::InitClassDockingWindow( RscTop * pSuper,
1879 RscEnum * pMapUnit )
1880 {
1881 Atom nId;
1882 RscTop * pClassDockWindow;
1883
1884 // Klasse anlegen
1885 nId = pHS->getID( "DockingWindow" );
1886 pClassDockWindow = new RscClass( nId, RSC_DOCKINGWINDOW, pSuper );
1887 pClassDockWindow->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
1888 aNmTb.Put( nId, CLASSNAME, pClassDockWindow );
1889
1890 // Variablen anlegen
1891 nId = aNmTb.Put( "_FloatingPosMapMode", VARNAME );
1892 pClassDockWindow->SetVariable( nId, pMapUnit, NULL, 0,
1893 RSC_DOCKINGWINDOW_XYMAPMODE );
1894 nId = aNmTb.Put( "_FloatingPosX", VARNAME );
1895 pClassDockWindow->SetVariable( nId, &aShort, NULL, 0,
1896 RSC_DOCKINGWINDOW_X );
1897 nId = aNmTb.Put( "_FloatingPosY", VARNAME );
1898 pClassDockWindow->SetVariable( nId, &aShort, NULL, 0,
1899 RSC_DOCKINGWINDOW_Y );
1900 nId = aNmTb.Put( "FloatingMode", VARNAME );
1901 pClassDockWindow->SetVariable( nId, &aBool, NULL, 0,
1902 RSC_DOCKINGWINDOW_FLOATING );
1903
1904 INS_WINBIT(pClassDockWindow,Moveable)
1905 INS_WINBIT(pClassDockWindow,Sizeable)
1906 INS_WINBIT(pClassDockWindow,EnableResizing)
1907 INS_WINBIT(pClassDockWindow,Closeable)
1908 INS_WINBIT(pClassDockWindow,HideWhenDeactivate);
1909 INS_WINBIT(pClassDockWindow,Zoomable);
1910 INS_WINBIT(pClassDockWindow,Dockable);
1911
1912 return pClassDockWindow;
1913 }
1914
1915 /*************************************************************************
1916 |* RscTypCont::InitClassToolBoxItem()
1917 *************************************************************************/
1918 RscTop * RscTypCont::InitClassToolBoxItem( RscTop * pSuper,
1919 RscTop * pClassBitmap,
1920 RscTop * pClassImage,
1921 RscEnum * pTriState )
1922 {
1923 Atom nId;
1924 RscTop * pClassToolBoxItem;
1925
1926 // Klasse anlegen
1927 nId = pHS->getID( "ToolBoxItem" );
1928 pClassToolBoxItem = new RscClass( nId, RSC_TOOLBOXITEM, pSuper );
1929 aNmTb.Put( nId, CLASSNAME, pClassToolBoxItem );
1930
1931 // Variablen anlegen
1932 nId = aNmTb.Put( "Identifier", VARNAME );
1933 pClassToolBoxItem->SetVariable( nId, &aIdNoZeroUShort, NULL, 0,
1934 RSC_TOOLBOXITEM_ID );
1935 {
1936 RscEnum * pEnum;
1937
1938 aBaseLst.Insert(
1939 pEnum = new RscEnum( pHS->getID( "EnumToolBoxItemType" ),
1940 RSC_NOTYPE ), LIST_APPEND );
1941 SETCONST( pEnum, "TOOLBOXITEM_BUTTON", TOOLBOXITEM_BUTTON );
1942 SETCONST( pEnum, "TOOLBOXITEM_SPACE", TOOLBOXITEM_SPACE );
1943 SETCONST( pEnum, "TOOLBOXITEM_SEPARATOR", TOOLBOXITEM_SEPARATOR );
1944 SETCONST( pEnum, "TOOLBOXITEM_BREAK", TOOLBOXITEM_BREAK );
1945
1946 // Variable einfuegen
1947 nId = aNmTb.Put( "Type", VARNAME );
1948 pClassToolBoxItem->SetVariable( nId, pEnum, NULL, 0,
1949 RSC_TOOLBOXITEM_TYPE );
1950 }
1951 {
1952 RscFlag * pFlag;
1953 RscClient * pClient;
1954 Atom l_nVarId, l_nAutoCheckId, l_nRadioCheckId, l_nCheckableId, l_nLeftId, l_nAutoSizeId, l_nDropDownId;
1955
1956 aBaseLst.Insert( pFlag = new RscFlag( pHS->getID( "FlagToolBoxState" ),
1957 RSC_NOTYPE ),
1958 LIST_APPEND );
1959
1960 // Konstanten in Tabelle stellen
1961 l_nCheckableId = pHS->getID( "TIB_CHECKABLE" );
1962 SETCONST( pFlag, l_nCheckableId, TIB_CHECKABLE );
1963 l_nAutoCheckId = pHS->getID( "TIB_AUTOCHECK" );
1964 SETCONST( pFlag, l_nAutoCheckId, TIB_AUTOCHECK );
1965 l_nRadioCheckId = pHS->getID( "TIB_RADIOCHECK" );
1966 SETCONST( pFlag, l_nRadioCheckId, TIB_RADIOCHECK );
1967 l_nLeftId = pHS->getID( "TIB_LEFT" );
1968 SETCONST( pFlag, l_nLeftId, TIB_LEFT );
1969 l_nAutoSizeId = pHS->getID( "TIB_AUTOSIZE" );
1970 SETCONST( pFlag, l_nAutoSizeId, TIB_AUTOSIZE );
1971 l_nDropDownId = pHS->getID( "TIB_DROPDOWN" );
1972 SETCONST( pFlag, l_nDropDownId, TIB_DROPDOWN );
1973
1974 // Variable einfuegen
1975 l_nVarId = aNmTb.Put( "_ToolBoxItemFlags", VARNAME );
1976 pClassToolBoxItem->SetVariable( l_nVarId, pFlag, NULL,
1977 VAR_HIDDEN | VAR_NOENUM,
1978 RSC_TOOLBOXITEM_STATUS );
1979
1980 // Clientvariablen einfuegen
1981 aBaseLst.Insert(
1982 pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE,
1983 pFlag, l_nCheckableId ), LIST_APPEND );
1984 nId = aNmTb.Put( "Checkable", VARNAME );
1985 pClassToolBoxItem->SetVariable( nId, pClient, NULL, VAR_NODATAINST, 0, l_nVarId );
1986
1987 aBaseLst.Insert(
1988 pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE,
1989 pFlag, l_nAutoCheckId ), LIST_APPEND );
1990 nId = aNmTb.Put( "AutoCheck", VARNAME );
1991 pClassToolBoxItem->SetVariable( nId, pClient, NULL, VAR_NODATAINST, 0, l_nVarId );
1992
1993 aBaseLst.Insert(
1994 pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE,
1995 pFlag, l_nRadioCheckId ), LIST_APPEND );
1996 nId = aNmTb.Put( "RadioCheck", VARNAME );
1997 pClassToolBoxItem->SetVariable( nId, pClient, NULL, VAR_NODATAINST, 0, l_nVarId );
1998
1999 aBaseLst.Insert(
2000 pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE,
2001 pFlag, l_nLeftId ), LIST_APPEND );
2002 nId = aNmTb.Put( "Left", VARNAME );
2003 pClassToolBoxItem->SetVariable( nId, pClient, NULL, VAR_NODATAINST, 0, l_nVarId );
2004
2005 aBaseLst.Insert(
2006 pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE,
2007 pFlag, l_nAutoSizeId ), LIST_APPEND );
2008 nId = aNmTb.Put( "AutoSize", VARNAME );
2009 pClassToolBoxItem->SetVariable( nId, pClient, NULL, VAR_NODATAINST, 0, l_nVarId );
2010
2011 aBaseLst.Insert(
2012 pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE,
2013 pFlag, l_nDropDownId ), LIST_APPEND );
2014 nId = aNmTb.Put( "DropDown", VARNAME );
2015 pClassToolBoxItem->SetVariable( nId, pClient, NULL, VAR_NODATAINST, 0, l_nVarId );
2016 }
2017 nId = aNmTb.Put( "HelpID", VARNAME );
2018 pClassToolBoxItem->SetVariable( nId, &aStringLiteral, NULL, 0,
2019 RSC_TOOLBOXITEM_HELPID );
2020 nId = aNmTb.Put( "Text", VARNAME );
2021 pClassToolBoxItem->SetVariable( nId, &aLangString, NULL, 0,
2022 RSC_TOOLBOXITEM_TEXT );
2023 nId = aNmTb.Put( "HelpText", VARNAME );
2024 pClassToolBoxItem->SetVariable( nId, &aLangString, NULL, 0,
2025 RSC_TOOLBOXITEM_HELPTEXT );
2026 nId = aNmTb.Put( "ItemBitmap", VARNAME );
2027 pClassToolBoxItem->SetVariable( nId, pClassBitmap, NULL, 0,
2028 RSC_TOOLBOXITEM_BITMAP );
2029 nId = aNmTb.Put( "ItemImage", VARNAME );
2030 pClassToolBoxItem->SetVariable( nId, pClassImage, NULL, 0,
2031 RSC_TOOLBOXITEM_IMAGE );
2032 nId = aNmTb.Put( "Disable", VARNAME );
2033 pClassToolBoxItem->SetVariable( nId, &aBool, NULL, 0,
2034 RSC_TOOLBOXITEM_DISABLE );
2035
2036 nId = aNmTb.Put( "State", VARNAME );
2037 pClassToolBoxItem->SetVariable( nId, pTriState, NULL, 0,
2038 RSC_TOOLBOXITEM_STATE );
2039 nId = aNmTb.Put( "Hide", VARNAME );
2040 pClassToolBoxItem->SetVariable( nId, &aBool, NULL, 0,
2041 RSC_TOOLBOXITEM_HIDE );
2042 nId = aNmTb.Put( "Hide", VARNAME );
2043 pClassToolBoxItem->SetVariable( nId, &aBool, NULL, 0,
2044 RSC_TOOLBOXITEM_HIDE );
2045 nId = aNmTb.Put( "Command", VARNAME );
2046 pClassToolBoxItem->SetVariable( nId, &aString, NULL, 0,
2047 RSC_TOOLBOXITEM_COMMAND );
2048
2049 return pClassToolBoxItem;
2050 }
2051
2052 /*************************************************************************
2053 |* RscTypCont::InitClassToolBox()
2054 *************************************************************************/
2055 RscTop * RscTypCont::InitClassToolBox( RscTop * pSuper,
2056 RscTop * pClassToolBoxItem,
2057 RscTop * pClassImageList )
2058 {
2059 Atom nId;
2060 RscTop * pClassToolBox;
2061
2062 // Klasse anlegen
2063 nId = pHS->getID( "ToolBox" );
2064 pClassToolBox = new RscClass( nId, RSC_TOOLBOX, pSuper );
2065 pClassToolBox->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
2066 aNmTb.Put( nId, CLASSNAME, pClassToolBox );
2067
2068 // Variablen anlegen
2069 {
2070 RscEnum * pEnum;
2071
2072 aBaseLst.Insert(
2073 pEnum = new RscEnum( pHS->getID( "EnumButtonType" ),
2074 RSC_NOTYPE ), LIST_APPEND );
2075 SETCONST( pEnum, "BUTTON_SYMBOL", BUTTON_SYMBOL );
2076 SETCONST( pEnum, "BUTTON_TEXT", BUTTON_TEXT );
2077 SETCONST( pEnum, "BUTTON_SYMBOLTEXT", BUTTON_SYMBOLTEXT );
2078
2079 // Variable einfuegen
2080 nId = aNmTb.Put( "ButtonType", VARNAME );
2081 pClassToolBox->SetVariable( nId, pEnum, NULL, 0,
2082 RSC_TOOLBOX_BUTTONTYPE );
2083 }
2084 {
2085 RscEnum * pEnum;
2086
2087 aBaseLst.Insert(
2088 pEnum = new RscEnum( pHS->getID( "EnumToolBoxAlign" ),
2089 RSC_NOTYPE ), LIST_APPEND );
2090 SETCONST( pEnum, "BOXALIGN_TOP", WINDOWALIGN_TOP );
2091 SETCONST( pEnum, "BOXALIGN_LEFT", WINDOWALIGN_LEFT );
2092 SETCONST( pEnum, "BOXALIGN_RIGHT", WINDOWALIGN_RIGHT );
2093 SETCONST( pEnum, "BOXALIGN_BOTTOM", WINDOWALIGN_BOTTOM );
2094
2095 // Variable einfuegen
2096 nId = aNmTb.Put( "Align", VARNAME );
2097 pClassToolBox->SetVariable( nId, pEnum, NULL, 0,
2098 RSC_TOOLBOX_ALIGN );
2099 }
2100 nId = aNmTb.Put( "LineCount", VARNAME );
2101 pClassToolBox->SetVariable( nId, &aIdNoZeroUShort, NULL, 0,
2102 RSC_TOOLBOX_LINECOUNT );
2103 nId = aNmTb.Put( "FloatingLines", VARNAME );
2104 pClassToolBox->SetVariable( nId, &aUShort, NULL, 0,
2105 RSC_TOOLBOX_FLOATLINES );
2106 nId = aNmTb.Put( "Customize", VARNAME );
2107 pClassToolBox->SetVariable( nId, &aBool, NULL, 0,
2108 RSC_TOOLBOX_CUSTOMIZE );
2109 nId = aNmTb.Put( "MenuStrings", VARNAME );
2110 pClassToolBox->SetVariable( nId, &aBool, NULL, 0,
2111 RSC_TOOLBOX_MENUSTRINGS );
2112 nId = aNmTb.Put( "ItemImageList", VARNAME );
2113 pClassToolBox->SetVariable( nId, pClassImageList, NULL, 0,
2114 RSC_TOOLBOX_ITEMIMAGELIST );
2115 {
2116 RscLangArray* pLA;
2117 RscCont * pCont;
2118
2119 aBaseLst.Insert( pCont = new RscCont( pHS->getID( "ContToolBoxItem" ),
2120 RSC_NOTYPE ),
2121 LIST_APPEND );
2122 pCont->SetTypeClass( pClassToolBoxItem );
2123 aBaseLst.Insert( pLA = new RscLangArray( pHS->getID( "LangContToolBoxItem" ),
2124 RSC_NOTYPE,
2125 pCont,
2126 &aLangType ),
2127 LIST_APPEND );
2128 nId = aNmTb.Put( "ItemList", VARNAME );
2129 pClassToolBox->SetVariable( nId, pLA, NULL, 0,
2130 RSC_TOOLBOX_ITEMLIST );
2131 }
2132 INS_WINBIT(pClassToolBox,Scroll)
2133 INS_WINBIT(pClassToolBox,LineSpacing)
2134 INS_WINBIT(pClassToolBox,RectStyle)
2135 INS_WINBIT(pClassToolBox,Tabstop)
2136
2137 return pClassToolBox;
2138 }
2139
2140 /*************************************************************************
2141 |* RscTypCont::InitClassStatusBar()
2142 *************************************************************************/
2143 RscTop * RscTypCont::InitClassStatusBar( RscTop * pSuper )
2144 {
2145 Atom nId;
2146 RscTop * pClassStatusBar;
2147
2148 // Klasse anlegen
2149 nId = pHS->getID( "StatusBar" );
2150 pClassStatusBar = new RscClass( nId, RSC_STATUSBAR, pSuper );
2151 pClassStatusBar->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
2152 aNmTb.Put( nId, CLASSNAME, pClassStatusBar );
2153
2154 // Variablen anlegen
2155 INS_WINBIT(pClassStatusBar,Left)
2156 INS_WINBIT(pClassStatusBar,Right)
2157
2158 return pClassStatusBar;
2159 }
2160
2161 /*************************************************************************
2162 |* RscTypCont::InitClassMoreButton()
2163 *************************************************************************/
2164 RscTop * RscTypCont::InitClassMoreButton( RscTop * pSuper, RscEnum * pMapUnit )
2165 {
2166 Atom nId;
2167 RscTop * pClassMoreButton;
2168
2169 // Klasse anlegen
2170 nId = pHS->getID( "MoreButton" );
2171 pClassMoreButton = new RscClass( nId, RSC_MOREBUTTON, pSuper );
2172 pClassMoreButton->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
2173 aNmTb.Put( nId, CLASSNAME, pClassMoreButton );
2174
2175 // Variablen anlegen
2176 nId = aNmTb.Put( "State", VARNAME );
2177 pClassMoreButton->SetVariable( nId, &aBool, NULL, 0,
2178 RSC_MOREBUTTON_STATE );
2179 nId = aNmTb.Put( "MapUnit", VARNAME );
2180 pClassMoreButton->SetVariable( nId, pMapUnit, NULL, 0,
2181 RSC_MOREBUTTON_MAPUNIT );
2182 nId = aNmTb.Put( "Delta", VARNAME );
2183 pClassMoreButton->SetVariable( nId, &aUShort, NULL, 0,
2184 RSC_MOREBUTTON_DELTA );
2185
2186 return pClassMoreButton;
2187 }
2188
2189 /*************************************************************************
2190 |* RscTypCont::InitClassFloatingWindow()
2191 *************************************************************************/
2192 RscTop * RscTypCont::InitClassFloatingWindow( RscTop * pSuper,
2193 RscEnum * pMapUnit )
2194 {
2195 Atom nId;
2196 RscTop * pClassFloatingWindow;
2197
2198 // Klasse anlegen
2199 nId = pHS->getID( "FloatingWindow" );
2200 pClassFloatingWindow = new RscClass( nId, RSC_FLOATINGWINDOW, pSuper );
2201 pClassFloatingWindow->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
2202 aNmTb.Put( nId, CLASSNAME, pClassFloatingWindow );
2203
2204 // Variablen anlegen
2205 nId = aNmTb.Put( "_ZoomInMapMode", VARNAME );
2206 pClassFloatingWindow->SetVariable( nId, pMapUnit, NULL, 0,
2207 RSC_FLOATINGWINDOW_WHMAPMODE );
2208 nId = aNmTb.Put( "_ZoomInWidth", VARNAME );
2209 pClassFloatingWindow->SetVariable( nId, &aShort, NULL, 0,
2210 RSC_FLOATINGWINDOW_WIDTH );
2211 nId = aNmTb.Put( "_ZoomInHeight", VARNAME );
2212 pClassFloatingWindow->SetVariable( nId, &aShort, NULL, 0,
2213 RSC_FLOATINGWINDOW_HEIGHT );
2214 nId = aNmTb.Put( "ZoomIn", VARNAME );
2215 pClassFloatingWindow->SetVariable( nId, &aBool, NULL, 0,
2216 RSC_FLOATINGWINDOW_ZOOMIN );
2217
2218 INS_WINBIT(pClassFloatingWindow,Zoomable)
2219 INS_WINBIT(pClassFloatingWindow,HideWhenDeactivate)
2220 INS_WINBIT(pClassFloatingWindow,EnableResizing)
2221
2222 return pClassFloatingWindow;
2223 }
2224
2225 /*************************************************************************
2226 |* RscTypCont::InitClassTabControlItem()
2227 *************************************************************************/
2228 RscTop * RscTypCont::InitClassTabControlItem( RscTop * pSuper,
2229 RscTop * /*pClassTabPage*/ )
2230 {
2231 Atom nId;
2232 RscTop * pClassTabControlItem;
2233
2234 // Klasse anlegen
2235 nId = pHS->getID( "PageItem" );
2236 pClassTabControlItem = new RscClass( nId, RSC_TABCONTROLITEM, pSuper );
2237 aNmTb.Put( nId, CLASSNAME, pClassTabControlItem );
2238
2239 // Variablen anlegen
2240 nId = aNmTb.Put( "Identifier", VARNAME );
2241 pClassTabControlItem->SetVariable( nId, &aIdNoZeroUShort, NULL, 0,
2242 RSC_TABCONTROLITEM_ID );
2243 nId = aNmTb.Put( "Text", VARNAME );
2244 pClassTabControlItem->SetVariable( nId, &aLangString, NULL, 0,
2245 RSC_TABCONTROLITEM_TEXT );
2246 nId = aNmTb.Put( "PageResID", VARNAME );
2247 pClassTabControlItem->SetVariable( nId, &aIdLong, NULL, 0,
2248 RSC_TABCONTROLITEM_PAGERESID );
2249
2250 return pClassTabControlItem;
2251 }
2252
2253 /*************************************************************************
2254 |* RscTypCont::InitClassTabControl()
2255 *************************************************************************/
2256 RscTop * RscTypCont::InitClassTabControl( RscTop * pSuper,
2257 RscTop * pClassTabControlItem )
2258 {
2259 Atom nId;
2260 RscTop * pClassTabControl;
2261
2262 // Klasse anlegen
2263 nId = pHS->getID( "TabControl" );
2264 pClassTabControl = new RscClass( nId, RSC_TABCONTROL, pSuper );
2265 pClassTabControl->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType );
2266 aNmTb.Put( nId, CLASSNAME, pClassTabControl );
2267
2268 // Variablen anlegen
2269 {
2270 RscCont * pCont;
2271
2272 aBaseLst.Insert( pCont = new RscCont( pHS->getID( "ContTabControlItem" ),
2273 RSC_NOTYPE ),
2274 LIST_APPEND );
2275 pCont->SetTypeClass( pClassTabControlItem );
2276 nId = aNmTb.Put( "PageList", VARNAME );
2277 pClassTabControl->SetVariable( nId, pCont, NULL, 0,
2278 RSC_TABCONTROL_ITEMLIST );
2279
2280 INS_WINBIT( pClassTabControl, DropDown );
2281 }
2282
2283 return pClassTabControl;
2284 }
2285
2286 /*************************************************************************
2287 |* RscTypCont::InitClassSfxFamilyStyleItem()
2288 *************************************************************************/
2289 RscTop * RscTypCont::InitClassSfxStyleFamilyItem( RscTop * pSuper,
2290 RscTop * pClassBitmap,
2291 RscTop * pClassImage,
2292 RscArray * pStrLst )
2293 {
2294 Atom nId;
2295 RscTop * pClassSfxFamilyStyleItem;
2296
2297 // Klasse anlegen
2298 nId = pHS->getID( "SfxStyleFamilyItem" );
2299 pClassSfxFamilyStyleItem = new RscClass( nId, RSC_SFX_STYLE_FAMILY_ITEM, pSuper );
2300 aNmTb.Put( nId, CLASSNAME, pClassSfxFamilyStyleItem );
2301
2302 nId = aNmTb.Put( "FilterList", VARNAME );
2303 pClassSfxFamilyStyleItem->SetVariable( nId, pStrLst, NULL, 0,
2304 RSC_SFX_STYLE_ITEM_LIST );
2305 nId = aNmTb.Put( "StyleBitmap", VARNAME );
2306 pClassSfxFamilyStyleItem->SetVariable( nId, pClassBitmap, NULL, 0,
2307 RSC_SFX_STYLE_ITEM_BITMAP );
2308 nId = aNmTb.Put( "Text", VARNAME );
2309 pClassSfxFamilyStyleItem->SetVariable( nId, &aLangString, NULL, 0,
2310 RSC_SFX_STYLE_ITEM_TEXT );
2311 nId = aNmTb.Put( "HelpText", VARNAME );
2312 pClassSfxFamilyStyleItem->SetVariable( nId, &aLangString, NULL, 0,
2313 RSC_SFX_STYLE_ITEM_HELPTEXT );
2314 {
2315 RscEnum * pSfxStyleFamily;
2316 pSfxStyleFamily = new RscEnum( pHS->getID( "StyleFamily" ),
2317 RSC_NOTYPE );
2318
2319 SETCONST( pSfxStyleFamily, "SFX_STYLE_FAMILY_PARA", SFX_STYLE_FAMILY_PARA );
2320 SETCONST( pSfxStyleFamily, "SFX_STYLE_FAMILY_CHAR", SFX_STYLE_FAMILY_CHAR );
2321 SETCONST( pSfxStyleFamily, "SFX_STYLE_FAMILY_FRAME",SFX_STYLE_FAMILY_FRAME);
2322 SETCONST( pSfxStyleFamily, "SFX_STYLE_FAMILY_PAGE", SFX_STYLE_FAMILY_PAGE );
2323 SETCONST( pSfxStyleFamily, "SFX_STYLE_FAMILY_PSEUDO", SFX_STYLE_FAMILY_PSEUDO );
2324 aBaseLst.Insert( pSfxStyleFamily );
2325
2326 nId = aNmTb.Put( "StyleFamily", VARNAME );
2327 pClassSfxFamilyStyleItem->SetVariable( nId, pSfxStyleFamily, NULL, 0,
2328 RSC_SFX_STYLE_ITEM_STYLEFAMILY );
2329 }
2330 nId = aNmTb.Put( "StyleImage", VARNAME );
2331 pClassSfxFamilyStyleItem->SetVariable( nId, pClassImage, NULL, 0,
2332 RSC_SFX_STYLE_ITEM_IMAGE );
2333 return pClassSfxFamilyStyleItem;
2334 }
2335
2336 /*************************************************************************
2337 |* RscTypCont::InitClassSfxTemplateDialogm()
2338 *************************************************************************/
2339 RscTop * RscTypCont::InitClassSfxTemplateDialog( RscTop * pSuper,
2340 RscTop * pClassFamilyStyleItem )
2341 {
2342 Atom nId;
2343 RscTop * pClassSfxTemplateDialog;
2344
2345 // Klasse anlegen
2346 nId = pHS->getID( "SfxStyleFamilies" );
2347 pClassSfxTemplateDialog = new RscClass( nId, RSC_SFX_STYLE_FAMILIES, pSuper );
2348 aNmTb.Put( nId, CLASSNAME, pClassSfxTemplateDialog );
2349
2350 // Variablen anlegen
2351 {
2352 RscCont * pCont;
2353
2354 aBaseLst.Insert( pCont = new RscCont(
2355 pHS->getID( "ContFamilyStyleItem" ),
2356 RSC_NOTYPE ),
2357 LIST_APPEND );
2358 pCont->SetTypeClass( pClassFamilyStyleItem );
2359 nId = aNmTb.Put( "StyleFamilyList", VARNAME );
2360 pClassSfxTemplateDialog->SetVariable( nId, pCont );
2361 }
2362
2363 return pClassSfxTemplateDialog;
2364 }
2365
2366 /*************************************************************************
2367 |* RscTypCont::InitClassSfxSlotInfo()
2368 *************************************************************************/
2369 RscTop * RscTypCont::InitClassSfxSlotInfo( RscTop * pSuper )
2370 {
2371 Atom nId;
2372 RscTop * pClassSfxSlotInfo;
2373
2374 // Klasse anlegen
2375 nId = pHS->getID( "SfxSlotInfo" );
2376 pClassSfxSlotInfo = new RscClass( nId, RSC_SFX_SLOT_INFO, pSuper );
2377 aNmTb.Put( nId, CLASSNAME, pClassSfxSlotInfo );
2378
2379 nId = aNmTb.Put( "SlotName", VARNAME );
2380 pClassSfxSlotInfo->SetVariable( nId, &aLangString, NULL, 0,
2381 RSC_SFX_SLOT_INFO_SLOTNAME );
2382 nId = aNmTb.Put( "HelpText", VARNAME );
2383 pClassSfxSlotInfo->SetVariable( nId, &aLangString, NULL, 0,
2384 RSC_SFX_SLOT_INFO_HELPTEXT );
2385 return pClassSfxSlotInfo;
2386 }
2387
2388
FREE OFFICE SUITE