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