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