Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 :
21 : #include <stdlib.h>
22 : #include <stdio.h>
23 :
24 : #include <tools/rc.h>
25 : #include <tools/wintypes.hxx>
26 : #include <rsc/rsc-vcl-shared-types.hxx>
27 :
28 : #include <rscmgr.hxx>
29 : #include <rscclass.hxx>
30 : #include <rsccont.hxx>
31 : #include <rscdb.hxx>
32 : #include <rsc/rscsfx.hxx>
33 : #include <rsclex.hxx>
34 : #include <rscyacc.hxx>
35 :
36 31425 : void RscTypCont::InsWinBit( RscTop * pClass, const OString& rName,
37 : Atom nVal )
38 : {
39 : RscClient * pClient;
40 :
41 : // Clientvariablen einfuegen
42 : aBaseLst.push_back(
43 94275 : pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE, &aWinBits, nVal )
44 62850 : );
45 31425 : Atom nId = aNmTb.Put( rName.getStr(), VARNAME );
46 : pClass->SetVariable( nId, pClient, NULL,
47 31425 : VAR_NODATAINST, 0, nWinBitVarId );
48 31425 : }
49 :
50 : #define INS_WINBIT( pClass, WinBit ) \
51 : InsWinBit( pClass, #WinBit, n##WinBit##Id );
52 :
53 419 : RscTop * RscTypCont::InitClassMgr()
54 : {
55 : RscTop * pClassMgr;
56 : RscBaseCont * pClass;
57 : Atom nId;
58 :
59 419 : aBaseLst.push_back( pClass = new RscBaseCont( InvalidAtom, RSC_NOTYPE, NULL, false ) );
60 :
61 419 : nId = pHS->getID( "Resource" );
62 419 : pClassMgr = new RscMgr( nId, RSC_RESOURCE, pClass );
63 419 : aNmTb.Put( nId, CLASSNAME, pClassMgr );
64 419 : pClassMgr->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType );
65 :
66 : // Variablen anlegen
67 : {
68 : RscContWriteSrc * pCont;
69 :
70 : // Variablen anlegen
71 419 : aBaseLst.push_back( pCont = new RscContExtraData( pHS->getID( "ContExtradata" ), RSC_NOTYPE ) );
72 419 : pCont->SetTypeClass( &aShort, &aString );
73 419 : nRsc_EXTRADATA = nId = aNmTb.Put( "ExtraData", VARNAME );
74 419 : pClassMgr->SetVariable( nId, pCont );
75 : };
76 419 : nId = aNmTb.Put( "Comment", VARNAME );
77 419 : pClassMgr->SetVariable( nId, &aString, NULL, VAR_NORC );
78 :
79 419 : pClass->SetTypeClass( pClassMgr );
80 :
81 419 : return pClassMgr;
82 : }
83 :
84 419 : RscTop * RscTypCont::InitClassString( RscTop * pSuper )
85 : {
86 : Atom nId;
87 : RscTop * pClassString;
88 :
89 419 : nId = pHS->getID( "String" );
90 419 : pClassString = new RscClass( nId, RSC_STRING, pSuper );
91 419 : aNmTb.Put( nId, CLASSNAME, pClassString );
92 419 : pClassString->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType );
93 :
94 : // Variablen anlegen
95 419 : nId = aNmTb.Put( "Text", VARNAME );
96 419 : pClassString->SetVariable( nId, &aLangString );
97 419 : return pClassString;
98 : }
99 :
100 419 : RscTop * RscTypCont::InitClassBitmap( RscTop * pSuper )
101 : {
102 : Atom nId;
103 : RscTop * pClassBitmap;
104 :
105 419 : nId = pHS->getID( "Bitmap" );
106 419 : pClassBitmap = new RscSysDepend( nId, RSC_BITMAP, pSuper );
107 419 : pClassBitmap->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType );
108 419 : aNmTb.Put( nId, CLASSNAME, pClassBitmap );
109 :
110 : // Die Klasse RscSysDepend behandelt die Variablen
111 : // "FILE" gesondert
112 419 : nId = aNmTb.Put( "File", VARNAME );
113 419 : pClassBitmap->SetVariable( nId, &aLangString, NULL, VAR_NORC );
114 :
115 419 : return pClassBitmap;
116 : }
117 :
118 419 : RscTop * RscTypCont::InitClassColor( RscTop * pSuper, RscEnum * pColor )
119 : {
120 : Atom nId;
121 : RscTop * pClassColor;
122 :
123 : // Klasse anlegen
124 419 : nId = pHS->getID( "Color" );
125 419 : pClassColor = new RscClass( nId, RSC_COLOR, pSuper );
126 419 : pClassColor->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType );
127 419 : aNmTb.Put( nId, CLASSNAME, pClassColor );
128 :
129 : // Variablen anlegen
130 419 : nId = aNmTb.Put( "Red", VARNAME );
131 419 : pClassColor->SetVariable( nId, &aUShort );
132 419 : nId = aNmTb.Put( "Green", VARNAME );
133 419 : pClassColor->SetVariable( nId, &aUShort );
134 419 : nId = aNmTb.Put( "Blue", VARNAME );
135 419 : pClassColor->SetVariable( nId, &aUShort );
136 419 : nId = aNmTb.Put( "Predefine", VARNAME );
137 419 : pClassColor->SetVariable( nId, pColor );
138 :
139 419 : return pClassColor;
140 : }
141 :
142 419 : RscTop * RscTypCont::InitClassImage( RscTop * pSuper, RscTop * pClassBitmap,
143 : RscTop * pClassColor )
144 : {
145 : Atom nId;
146 : RscTop * pClassImage;
147 :
148 : // Klasse anlegen
149 419 : nId = pHS->getID( "Image" );
150 419 : pClassImage = new RscClass( nId, RSC_IMAGE, pSuper );
151 419 : pClassImage->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType );
152 419 : aNmTb.Put( nId, CLASSNAME, pClassImage );
153 :
154 : // Variablen anlegen
155 419 : nId = aNmTb.Put( "ImageBitmap", VARNAME );
156 419 : pClassImage->SetVariable( nId, pClassBitmap, NULL, 0, RSC_IMAGE_IMAGEBITMAP );
157 419 : nId = aNmTb.Put( "MaskBitmap", VARNAME );
158 419 : pClassImage->SetVariable( nId, pClassBitmap, NULL, 0, RSC_IMAGE_MASKBITMAP );
159 419 : nId = aNmTb.Put( "MaskColor", VARNAME );
160 : pClassImage->SetVariable( nId, pClassColor, NULL,
161 419 : VAR_SVDYNAMIC, RSC_IMAGE_MASKCOLOR );
162 :
163 419 : return pClassImage;
164 : }
165 :
166 419 : RscTop * RscTypCont::InitClassImageList( RscTop * pSuper,
167 : RscTop * pClassColor, RscCont * pStrLst )
168 : {
169 : Atom nId;
170 : RscTop * pClassImageList;
171 :
172 : // Klasse anlegen
173 419 : nId = pHS->getID( "ImageList" );
174 419 : pClassImageList = new RscClass( nId, RSC_IMAGELIST, pSuper );
175 419 : pClassImageList->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType );
176 419 : aNmTb.Put( nId, CLASSNAME, pClassImageList );
177 :
178 419 : nId = aNmTb.Put( "Prefix", VARNAME );
179 419 : pClassImageList->SetVariable( nId, &aString );
180 :
181 419 : nId = aNmTb.Put( "MaskColor", VARNAME );
182 : pClassImageList->SetVariable( nId, pClassColor, NULL,
183 419 : VAR_SVDYNAMIC, RSC_IMAGELIST_MASKCOLOR );
184 :
185 419 : RscCont * pCont = new RscCont( pHS->getID( "sal_uInt16 *" ), RSC_NOTYPE );
186 419 : pCont->SetTypeClass( &aIdUShort );
187 419 : aBaseLst.push_back( pCont );
188 419 : nId = aNmTb.Put( "IdList", VARNAME );
189 : pClassImageList->SetVariable( nId, pCont, NULL, 0,
190 419 : RSC_IMAGELIST_IDLIST );
191 :
192 419 : nId = aNmTb.Put( "FileList", VARNAME );
193 419 : pClassImageList->SetVariable( nId, pStrLst );
194 :
195 419 : nId = aNmTb.Put( "IdCount", VARNAME );
196 : pClassImageList->SetVariable( nId, &aUShort, NULL, 0,
197 419 : RSC_IMAGELIST_IDCOUNT );
198 419 : return pClassImageList;
199 : }
200 :
201 419 : RscTop * RscTypCont::InitClassWindow( RscTop * pSuper, RscEnum * pMapUnit,
202 : RscArray * pLangGeo )
203 : {
204 : Atom nId;
205 : RscTop * pClassWindow;
206 :
207 : // Klasse anlegen
208 419 : nId = pHS->getID( "Window" );
209 419 : pClassWindow = new RscClass( nId, RSC_WINDOW, pSuper );
210 419 : pClassWindow->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
211 419 : aNmTb.Put( nId, CLASSNAME, pClassWindow );
212 :
213 : // Variablen anlegen
214 : {
215 : RscFlag * pFlag;
216 : RscClient * pClient;
217 : Atom nVarId, nDisableId, nOutputSizeId;
218 :
219 419 : aBaseLst.push_back( pFlag = new RscFlag( pHS->getID( "FlagWndExtra" ), RSC_NOTYPE ) );
220 :
221 : // Konstanten in Tabelle stellen
222 419 : nDisableId = pHS->getID( "RSWND_DISABLE" );
223 419 : SETCONST( pFlag, nDisableId, RSWND_DISABLED );
224 419 : nOutputSizeId = pHS->getID( "RSWND_OUTPUTSIZE" );
225 419 : SETCONST( pFlag, nOutputSizeId, RSWND_CLIENTSIZE );
226 :
227 : // Variable einfuegen
228 419 : nVarId = aNmTb.Put( "_RscExtraFlags", VARNAME );
229 : pClassWindow->SetVariable( nVarId, pFlag, NULL,
230 419 : VAR_HIDDEN | VAR_NOENUM );
231 :
232 : aBaseLst.push_back(
233 1257 : pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE, pFlag, nDisableId )
234 838 : );
235 419 : nId = aNmTb.Put( "Disable", VARNAME );
236 : pClassWindow->SetVariable( nId, pClient, NULL,
237 419 : VAR_NODATAINST, 0, nVarId );
238 :
239 : aBaseLst.push_back(
240 1257 : pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE, pFlag, nOutputSizeId )
241 838 : );
242 419 : nId = aNmTb.Put( "OutputSize", VARNAME );
243 : pClassWindow->SetVariable( nId, pClient, NULL,
244 419 : VAR_NODATAINST, 0, nVarId );
245 : }
246 :
247 : pClassWindow->SetVariable( nWinBitVarId, &aWinBits, NULL,
248 419 : VAR_HIDDEN | VAR_NOENUM );
249 :
250 419 : INS_WINBIT(pClassWindow,Border)
251 419 : INS_WINBIT(pClassWindow,Hide)
252 419 : INS_WINBIT(pClassWindow,ClipChildren)
253 419 : INS_WINBIT(pClassWindow,SVLook)
254 419 : InsWinBit( pClassWindow, "DialogControl", nTabControlId );
255 :
256 419 : nId = aNmTb.Put( "HelpID", VARNAME );
257 419 : pClassWindow->SetVariable( nId, &aStringLiteral, NULL, 0, WINDOW_HELPID );
258 :
259 :
260 419 : nRsc_XYMAPMODEId = nId = aNmTb.Put( "_XYMapMode", VARNAME );
261 419 : pClassWindow->SetVariable( nId, pMapUnit, NULL, 0, WINDOW_XYMAPMODE );
262 419 : nRsc_X = nId = aNmTb.Put( "_X", VARNAME );
263 419 : pClassWindow->SetVariable( nId, &aLong, NULL, 0, WINDOW_X );
264 419 : nRsc_Y = nId = aNmTb.Put( "_Y", VARNAME );
265 419 : pClassWindow->SetVariable( nId, &aLong, NULL, 0, WINDOW_Y );
266 :
267 419 : nRsc_WHMAPMODEId = nId = aNmTb.Put( "_WHMapMode", VARNAME );
268 419 : pClassWindow->SetVariable( nId, pMapUnit, NULL, 0, WINDOW_WHMAPMODE );
269 419 : nRsc_WIDTH = nId = aNmTb.Put( "_Width", VARNAME );
270 419 : pClassWindow->SetVariable( nId, &aLong, NULL, 0, WINDOW_WIDTH );
271 419 : nRsc_HEIGHT = nId = aNmTb.Put( "_Height", VARNAME );
272 419 : pClassWindow->SetVariable( nId, &aLong, NULL, 0, WINDOW_HEIGHT );
273 :
274 419 : nRsc_DELTALANG = nId = aNmTb.Put( "DeltaLang", VARNAME );
275 419 : pClassWindow->SetVariable( nId, pLangGeo, NULL, VAR_NORC | VAR_NOENUM);
276 419 : nId = aNmTb.Put( "Text", VARNAME );
277 419 : pClassWindow->SetVariable( nId, &aLangString, NULL, 0, WINDOW_TEXT );
278 419 : nId = aNmTb.Put( "HelpText", VARNAME );
279 419 : pClassWindow->SetVariable( nId, &aLangString, NULL, 0, WINDOW_HELPTEXT );
280 419 : nId = aNmTb.Put( "QuickHelpText", VARNAME );
281 419 : pClassWindow->SetVariable( nId, &aLangString, NULL, 0, WINDOW_QUICKTEXT );
282 419 : nId = aNmTb.Put( "ExtraLong", VARNAME );
283 419 : pClassWindow->SetVariable( nId, &aLong, NULL, 0, WINDOW_EXTRALONG );
284 419 : nId = aNmTb.Put( "UniqueId", VARNAME );
285 419 : pClassWindow->SetVariable( nId, &aString, NULL, 0, WINDOW_UNIQUEID );
286 :
287 : // BorderStyle
288 419 : RscEnum* pBorderStyleEnum = new RscEnum( pHS->getID( "WindowBorderStyle" ), RSC_NOTYPE );
289 419 : aBaseLst.push_back( pBorderStyleEnum );
290 :
291 : // Konstanten in Tabelle stellen
292 419 : SETCONST( pBorderStyleEnum, pHS->getID( "WINDOW_BORDER_NORMAL" ), WindowBorderStyle::NORMAL );
293 419 : SETCONST( pBorderStyleEnum, pHS->getID( "WINDOW_BORDER_MONO" ), WindowBorderStyle::MONO );
294 419 : SETCONST( pBorderStyleEnum, pHS->getID( "WINDOW_BORDER_MENU" ), WindowBorderStyle::MENU );
295 419 : SETCONST( pBorderStyleEnum, pHS->getID( "WINDOW_BORDER_NOBORDER" ), WindowBorderStyle::NOBORDER );
296 :
297 : // Variable einfuegen
298 419 : nId = aNmTb.Put( "BorderStyle", VARNAME );
299 : pClassWindow->SetVariable( nId, pBorderStyleEnum, NULL,
300 : 0,
301 419 : WINDOW_BORDER_STYLE );
302 :
303 419 : return pClassWindow;
304 : }
305 :
306 419 : RscTop * RscTypCont::InitClassSystemWindow( RscTop * pSuper )
307 : {
308 : Atom nId;
309 : RscTop * pClassSystemWindow;
310 :
311 : // Klasse anlegen
312 419 : nId = pHS->getID( "SystemWindow" );
313 419 : pClassSystemWindow = new RscClass( nId, RSC_SYSWINDOW, pSuper );
314 419 : pClassSystemWindow->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
315 419 : aNmTb.Put( nId, CLASSNAME, pClassSystemWindow );
316 :
317 419 : INS_WINBIT(pClassSystemWindow,Sizeable)
318 419 : INS_WINBIT(pClassSystemWindow,Moveable)
319 419 : InsWinBit( pClassSystemWindow, "Minable", nMinimizeId );
320 419 : InsWinBit( pClassSystemWindow, "Maxable", nMaximizeId );
321 419 : INS_WINBIT(pClassSystemWindow,Closeable)
322 419 : INS_WINBIT(pClassSystemWindow,App)
323 419 : INS_WINBIT(pClassSystemWindow,SysWin)
324 :
325 419 : return pClassSystemWindow ;
326 : }
327 :
328 419 : RscTop * RscTypCont::InitClassWorkWindow( RscTop * pSuper )
329 : {
330 : Atom nId;
331 : RscTop * pClassWorkWindow;
332 :
333 : // Klasse anlegen
334 419 : nId = pHS->getID( "WorkWindow" );
335 419 : pClassWorkWindow = new RscClass( nId, RSC_WORKWIN, pSuper );
336 419 : pClassWorkWindow->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
337 :
338 419 : aNmTb.Put( nId, CLASSNAME, pClassWorkWindow );
339 :
340 : // Variablen anlegen
341 : {
342 : Atom nVarId;
343 : RscEnum * pShow;
344 :
345 419 : aBaseLst.push_back( pShow = new RscEnum( pHS->getID( "EnumShowState" ), RSC_NOTYPE ) );
346 :
347 419 : SETCONST( pShow, "SHOW_NORMAL", WORKWIN_SHOWNORMAL );
348 419 : SETCONST( pShow, "SHOW_MINIMIZED", WORKWIN_SHOWMINIMIZED );
349 419 : SETCONST( pShow, "SHOW_MAXIMIZED", WORKWIN_SHOWMAXIMIZED );
350 :
351 :
352 : // Variable einfuegen
353 419 : nVarId = aNmTb.Put( "Show", VARNAME );
354 419 : pClassWorkWindow->SetVariable( nVarId, pShow, NULL );
355 : }
356 :
357 419 : return pClassWorkWindow;
358 : }
359 :
360 419 : RscTop * RscTypCont::InitClassControl( RscTop * pSuper )
361 : {
362 : Atom nId;
363 : RscTop * pClassControl;
364 :
365 : // Klasse anlegen
366 419 : nId = pHS->getID( "Control" );
367 419 : pClassControl = new RscClass( nId, RSC_CONTROL, pSuper );
368 419 : pClassControl->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
369 419 : aNmTb.Put( nId, CLASSNAME, pClassControl );
370 :
371 419 : InsWinBit( pClassControl, "TabStop", nTabstopId );
372 419 : INS_WINBIT(pClassControl,Group)
373 :
374 419 : return pClassControl;
375 : }
376 :
377 419 : RscTop * RscTypCont::InitClassCheckBox( RscTop * pSuper )
378 : {
379 : Atom nId;
380 : RscTop * pClassCheckBox;
381 :
382 : // Klasse anlegen
383 419 : nId = pHS->getID( "CheckBox" );
384 419 : pClassCheckBox = new RscClass( nId, RSC_CHECKBOX, pSuper );
385 419 : pClassCheckBox->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
386 419 : aNmTb.Put( nId, CLASSNAME, pClassCheckBox );
387 :
388 : // Variablen anlegen
389 419 : INS_WINBIT( pClassCheckBox, WordBreak )
390 419 : INS_WINBIT( pClassCheckBox, Top )
391 419 : INS_WINBIT( pClassCheckBox, VCenter )
392 419 : INS_WINBIT( pClassCheckBox, Bottom )
393 :
394 419 : nId = aNmTb.Put( "Check", VARNAME );
395 419 : pClassCheckBox->SetVariable( nId, &aBool );
396 :
397 419 : return pClassCheckBox;
398 : }
399 :
400 419 : RscTop * RscTypCont::InitClassPushButton( RscTop * pSuper )
401 : {
402 : Atom nId;
403 : RscTop * pClassPushButton;
404 :
405 : // Klasse anlegen
406 419 : nId = pHS->getID( "PushButton" );
407 419 : pClassPushButton = new RscClass( nId, RSC_PUSHBUTTON, pSuper );
408 419 : pClassPushButton->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
409 419 : aNmTb.Put( nId, CLASSNAME, pClassPushButton );
410 :
411 419 : InsWinBit( pClassPushButton, "DefButton", nDefaultId );
412 419 : INS_WINBIT( pClassPushButton, Top )
413 419 : INS_WINBIT( pClassPushButton, VCenter )
414 419 : INS_WINBIT( pClassPushButton, Bottom )
415 :
416 419 : return pClassPushButton;
417 : }
418 :
419 419 : RscTop * RscTypCont::InitClassImageButton( RscTop * pSuper,
420 : RscTop * pClassImage,
421 : RscEnum * pTriState )
422 : {
423 : Atom nId;
424 : RscTop * pClassImageButton;
425 :
426 : // Klasse anlegen
427 419 : nId = pHS->getID( "ImageButton" );
428 419 : pClassImageButton = new RscClass( nId, RSC_IMAGEBUTTON, pSuper );
429 419 : pClassImageButton->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
430 419 : aNmTb.Put( nId, CLASSNAME, pClassImageButton );
431 :
432 : // Variablen anlegen
433 : {
434 419 : nId = aNmTb.Put( "ButtonImage", VARNAME );
435 : pClassImageButton->SetVariable( nId, pClassImage, NULL, 0,
436 419 : RSC_IMAGEBUTTON_IMAGE );
437 : }
438 : // Variablen anlegen
439 : {
440 : Atom nVarId;
441 : RscEnum * pSymbol;
442 :
443 419 : aBaseLst.push_back( pSymbol = new RscEnum( pHS->getID( "EnumSymbolButton" ), RSC_NOTYPE ) );
444 :
445 419 : SETCONST( pSymbol, "IMAGEBUTTON_DONTKNOW", SymbolType::DONTKNOW );
446 419 : SETCONST( pSymbol, "IMAGEBUTTON_IMAGE", SymbolType::IMAGE );
447 419 : SETCONST( pSymbol, "IMAGEBUTTON_ARROW_UP", SymbolType::ARROW_UP );
448 419 : SETCONST( pSymbol, "IMAGEBUTTON_ARROW_DOWN", SymbolType::ARROW_DOWN );
449 419 : SETCONST( pSymbol, "IMAGEBUTTON_ARROW_LEFT", SymbolType::ARROW_LEFT );
450 419 : SETCONST( pSymbol, "IMAGEBUTTON_ARROW_RIGHT", SymbolType::ARROW_RIGHT );
451 419 : SETCONST( pSymbol, "IMAGEBUTTON_SPIN_UP", SymbolType::SPIN_UP );
452 419 : SETCONST( pSymbol, "IMAGEBUTTON_SPIN_DOWN", SymbolType::SPIN_DOWN );
453 419 : SETCONST( pSymbol, "IMAGEBUTTON_SPIN_LEFT", SymbolType::SPIN_LEFT );
454 419 : SETCONST( pSymbol, "IMAGEBUTTON_SPIN_RIGHT", SymbolType::SPIN_RIGHT );
455 419 : SETCONST( pSymbol, "IMAGEBUTTON_FIRST", SymbolType::FIRST );
456 419 : SETCONST( pSymbol, "IMAGEBUTTON_LAST", SymbolType::LAST );
457 419 : SETCONST( pSymbol, "IMAGEBUTTON_PREV", SymbolType::PREV );
458 419 : SETCONST( pSymbol, "IMAGEBUTTON_NEXT", SymbolType::NEXT );
459 419 : SETCONST( pSymbol, "IMAGEBUTTON_PAGEUP", SymbolType::PAGEUP );
460 419 : SETCONST( pSymbol, "IMAGEBUTTON_PAGEDOWN", SymbolType::PAGEDOWN );
461 419 : SETCONST( pSymbol, "IMAGEBUTTON_PLAY", SymbolType::PLAY );
462 419 : SETCONST( pSymbol, "IMAGEBUTTON_REVERSEPLAY", SymbolType::REVERSEPLAY );
463 419 : SETCONST( pSymbol, "IMAGEBUTTON_STOP", SymbolType::STOP );
464 419 : SETCONST( pSymbol, "IMAGEBUTTON_PAUSE", SymbolType::PAUSE );
465 419 : SETCONST( pSymbol, "IMAGEBUTTON_WINDSTART", SymbolType::WINDSTART );
466 419 : SETCONST( pSymbol, "IMAGEBUTTON_WINDEND", SymbolType::WINDEND );
467 419 : SETCONST( pSymbol, "IMAGEBUTTON_WINDBACKWARD", SymbolType::WINDBACKWARD );
468 419 : SETCONST( pSymbol, "IMAGEBUTTON_WINDFORWARD", SymbolType::WINDFORWARD );
469 :
470 : // Variable einfuegen
471 419 : nVarId = aNmTb.Put( "Symbol", VARNAME );
472 : pClassImageButton->SetVariable( nVarId, pSymbol, NULL, 0,
473 419 : RSC_IMAGEBUTTON_SYMBOL );
474 : }
475 419 : nId = aNmTb.Put( "State", VARNAME );
476 : pClassImageButton->SetVariable( nId, pTriState, NULL, 0,
477 419 : RSC_IMAGEBUTTON_STATE );
478 :
479 419 : INS_WINBIT(pClassImageButton,Repeat)
480 419 : INS_WINBIT(pClassImageButton,SmallStyle)
481 419 : INS_WINBIT(pClassImageButton,RectStyle)
482 :
483 419 : return pClassImageButton;
484 : }
485 :
486 419 : RscTop * RscTypCont::InitClassEdit( RscTop * pSuper )
487 : {
488 : Atom nId;
489 : RscTop * pClassEdit;
490 :
491 : // Klasse anlegen
492 419 : nId = pHS->getID( "Edit" );
493 419 : pClassEdit = new RscClass( nId, RSC_EDIT, pSuper );
494 419 : pClassEdit->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
495 419 : aNmTb.Put( nId, CLASSNAME, pClassEdit );
496 :
497 419 : INS_WINBIT(pClassEdit,Left)
498 419 : INS_WINBIT(pClassEdit,Center)
499 419 : INS_WINBIT(pClassEdit,Right)
500 419 : INS_WINBIT(pClassEdit,PassWord)
501 419 : INS_WINBIT(pClassEdit,ReadOnly)
502 :
503 419 : nId = aNmTb.Put( "MaxTextLength", VARNAME );
504 419 : pClassEdit->SetVariable( nId, &aUShort );
505 :
506 419 : return pClassEdit;
507 : }
508 :
509 419 : RscTop * RscTypCont::InitClassListBox( RscTop * pSuper, RscArray * pStrLst )
510 : {
511 : Atom nId;
512 : RscTop * pClassListBox;
513 :
514 : // Klasse anlegen
515 419 : nId = pHS->getID( "ListBox" );
516 419 : pClassListBox = new RscClass( nId, RSC_LISTBOX, pSuper );
517 419 : pClassListBox->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
518 419 : aNmTb.Put( nId, CLASSNAME, pClassListBox );
519 :
520 : // Variablen anlegen
521 419 : INS_WINBIT(pClassListBox,Sort)
522 419 : INS_WINBIT(pClassListBox,DropDown)
523 419 : INS_WINBIT(pClassListBox,HScroll);
524 419 : INS_WINBIT(pClassListBox,VScroll);
525 419 : INS_WINBIT(pClassListBox,AutoSize)
526 419 : INS_WINBIT(pClassListBox,AutoHScroll)
527 419 : INS_WINBIT(pClassListBox,DDExtraWidth)
528 :
529 : {
530 419 : RSCINST aDflt = aUShort.Create( NULL, RSCINST(), false );
531 419 : aDflt.pClass->SetNumber( aDflt, (sal_uInt16)0xFFFF );
532 419 : nId = aNmTb.Put( "CurPos", VARNAME );
533 419 : pClassListBox->SetVariable( nId, &aUShort, &aDflt );
534 : }
535 419 : nId = aNmTb.Put( "StringList", VARNAME );
536 419 : pClassListBox->SetVariable( nId, pStrLst );
537 :
538 419 : return pClassListBox;
539 : }
540 :
541 419 : RscTop * RscTypCont::InitClassComboBox( RscTop * pSuper, RscArray * pStrLst )
542 : {
543 : Atom nId;
544 : RscTop * pClassComboBox;
545 :
546 : // Klasse anlegen
547 419 : nId = pHS->getID( "ComboBox" );
548 419 : pClassComboBox = new RscClass( nId, RSC_COMBOBOX, pSuper );
549 419 : pClassComboBox->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
550 419 : aNmTb.Put( nId, CLASSNAME, pClassComboBox );
551 :
552 : // Variablen anlegen
553 419 : INS_WINBIT(pClassComboBox,DropDown)
554 419 : INS_WINBIT(pClassComboBox,Sort)
555 419 : INS_WINBIT(pClassComboBox,HScroll);
556 419 : INS_WINBIT(pClassComboBox,VScroll);
557 419 : INS_WINBIT(pClassComboBox,AutoSize)
558 419 : INS_WINBIT(pClassComboBox,AutoHScroll)
559 419 : INS_WINBIT(pClassComboBox,DDExtraWidth)
560 :
561 419 : nId = aNmTb.Put( "StringList", VARNAME );
562 419 : pClassComboBox->SetVariable( nId, pStrLst );
563 :
564 419 : return pClassComboBox;
565 : }
566 :
567 419 : RscTop * RscTypCont::InitClassFixedText( RscTop * pSuper )
568 : {
569 : Atom nId;
570 : RscTop * pClassFixedText;
571 :
572 : // Klasse anlegen
573 419 : nId = pHS->getID( "FixedText" );
574 419 : pClassFixedText = new RscClass( nId, RSC_TEXT, pSuper );
575 419 : pClassFixedText->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
576 419 : aNmTb.Put( nId, CLASSNAME, pClassFixedText );
577 :
578 : // Variablen anlegen
579 419 : INS_WINBIT(pClassFixedText,Left)
580 419 : INS_WINBIT(pClassFixedText,Center)
581 419 : INS_WINBIT(pClassFixedText,Right)
582 419 : INS_WINBIT(pClassFixedText,WordBreak)
583 419 : INS_WINBIT(pClassFixedText,LeftLabel)
584 419 : INS_WINBIT(pClassFixedText,NoLabel)
585 419 : INS_WINBIT(pClassFixedText,Top)
586 419 : INS_WINBIT(pClassFixedText,VCenter)
587 419 : INS_WINBIT(pClassFixedText,Bottom)
588 :
589 419 : return pClassFixedText;
590 : }
591 :
592 419 : RscTop * RscTypCont::InitClassFixedImage( RscTop * pSuper, RscTop * pClassImage )
593 : {
594 : Atom nId;
595 : RscTop * pClassFixedImage;
596 :
597 : // Klasse anlegen
598 419 : nId = pHS->getID( "FixedImage" );
599 419 : pClassFixedImage = new RscClass( nId, RSC_FIXEDIMAGE, pSuper );
600 419 : pClassFixedImage->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
601 419 : aNmTb.Put( nId, CLASSNAME, pClassFixedImage );
602 :
603 : // Variablen anlegen
604 419 : nId = aNmTb.Put( "Fixed", VARNAME );
605 419 : pClassFixedImage->SetVariable( nId, pClassImage, 0, 0, RSC_FIXEDIMAGE_IMAGE );
606 :
607 419 : return pClassFixedImage;
608 : }
609 :
610 419 : RscTop * RscTypCont::InitClassRadioButton( RscTop * pSuper )
611 : {
612 : Atom nId;
613 : RscTop * pClassRadioButton;
614 :
615 : // Klasse anlegen
616 419 : nId = pHS->getID( "RadioButton" );
617 419 : pClassRadioButton = new RscClass( nId, RSC_RADIOBUTTON, pSuper );
618 419 : pClassRadioButton->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
619 419 : aNmTb.Put( nId, CLASSNAME, pClassRadioButton );
620 :
621 : // Variablen anlegen
622 419 : INS_WINBIT( pClassRadioButton, WordBreak )
623 419 : INS_WINBIT( pClassRadioButton, Top )
624 419 : INS_WINBIT( pClassRadioButton, VCenter )
625 419 : INS_WINBIT( pClassRadioButton, Bottom )
626 :
627 419 : nId = aNmTb.Put( "Check", VARNAME );
628 419 : pClassRadioButton->SetVariable( nId, &aBool );
629 :
630 419 : return pClassRadioButton;
631 : }
632 :
633 419 : RscTop * RscTypCont::InitClassKeyCode( RscTop * pSuper, RscEnum * pKey )
634 : {
635 : Atom nId;
636 : RscTop * pClassKeyCode;
637 :
638 : // Klasse anlegen
639 419 : nId = pHS->getID( "KeyCode" );
640 419 : pClassKeyCode = new RscClass( nId, RSC_KEYCODE, pSuper );
641 419 : aNmTb.Put( nId, CLASSNAME, pClassKeyCode );
642 :
643 : // Variablen anlegen
644 419 : nId = aNmTb.Put( "Code", VARNAME );
645 419 : pClassKeyCode->SetVariable( nId, pKey );
646 :
647 : {
648 : RscFlag * pFlag;
649 : RscClient * pClient;
650 : Atom nVarId, nShiftId, nMod1Id, nMod2Id;
651 :
652 419 : aBaseLst.push_back( pFlag = new RscFlag( pHS->getID( "FlagKeyModifier" ), RSC_NOTYPE ) );
653 :
654 : // Konstanten in Tabelle stellen
655 419 : nShiftId = pHS->getID( "KEY_SHIFT" );
656 419 : SETCONST( pFlag, nShiftId, KEY_SHIFT );
657 419 : nMod1Id = pHS->getID( "KEY_MOD1" );
658 419 : SETCONST( pFlag, nMod1Id, KEY_MOD1 );
659 419 : nMod2Id = pHS->getID( "KEY_MOD2" );
660 419 : SETCONST( pFlag, nMod2Id, KEY_MOD2 );
661 :
662 : // Variable einfuegen
663 419 : nVarId = aNmTb.Put( "_ModifierFlags", VARNAME );
664 : pClassKeyCode->SetVariable( nVarId, pFlag, NULL,
665 419 : VAR_HIDDEN | VAR_NOENUM );
666 :
667 : // Clientvariablen einfuegen
668 : aBaseLst.push_back(
669 1257 : pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE, pFlag, nShiftId )
670 838 : );
671 419 : nId = aNmTb.Put( "Shift", VARNAME );
672 : pClassKeyCode->SetVariable( nId, pClient, NULL,
673 419 : VAR_NODATAINST, 0, nVarId );
674 :
675 : aBaseLst.push_back(
676 1257 : pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE, pFlag, nMod1Id )
677 838 : );
678 419 : nId = aNmTb.Put( "Modifier1", VARNAME );
679 : pClassKeyCode->SetVariable( nId, pClient, NULL,
680 419 : VAR_NODATAINST, 0, nVarId );
681 :
682 :
683 : aBaseLst.push_back(
684 1257 : pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE, pFlag, nMod2Id )
685 838 : );
686 419 : nId = aNmTb.Put( "Modifier2", VARNAME );
687 : pClassKeyCode->SetVariable( nId, pClient, NULL,
688 419 : VAR_NODATAINST, 0, nVarId );
689 : }
690 : {
691 : Atom nVarId;
692 : RscEnum * pKeyFunc;
693 :
694 419 : aBaseLst.push_back( pKeyFunc = new RscEnum( pHS->getID( "EnumKeyFunc" ), RSC_NOTYPE ) );
695 :
696 419 : SETCONST( pKeyFunc, "KEYFUNC_DONTKNOW", KeyFuncType::DONTKNOW );
697 419 : SETCONST( pKeyFunc, "KEYFUNC_NEW", KeyFuncType::NEW );
698 419 : SETCONST( pKeyFunc, "KEYFUNC_OPEN", KeyFuncType::OPEN );
699 419 : SETCONST( pKeyFunc, "KEYFUNC_SAVE", KeyFuncType::SAVE );
700 419 : SETCONST( pKeyFunc, "KEYFUNC_SAVEAS", KeyFuncType::SAVEAS );
701 419 : SETCONST( pKeyFunc, "KEYFUNC_PRINT", KeyFuncType::PRINT );
702 419 : SETCONST( pKeyFunc, "KEYFUNC_CLOSE", KeyFuncType::CLOSE );
703 419 : SETCONST( pKeyFunc, "KEYFUNC_QUIT", KeyFuncType::QUIT );
704 419 : SETCONST( pKeyFunc, "KEYFUNC_CUT", KeyFuncType::CUT );
705 419 : SETCONST( pKeyFunc, "KEYFUNC_COPY", KeyFuncType::COPY );
706 419 : SETCONST( pKeyFunc, "KEYFUNC_PASTE", KeyFuncType::PASTE );
707 419 : SETCONST( pKeyFunc, "KEYFUNC_UNDO", KeyFuncType::UNDO );
708 419 : SETCONST( pKeyFunc, "KEYFUNC_REDO", KeyFuncType::REDO );
709 419 : SETCONST( pKeyFunc, "KEYFUNC_DELETE", KeyFuncType::DELETE );
710 419 : SETCONST( pKeyFunc, "KEYFUNC_REPEAT", KeyFuncType::REPEAT );
711 419 : SETCONST( pKeyFunc, "KEYFUNC_FIND", KeyFuncType::FIND );
712 419 : SETCONST( pKeyFunc, "KEYFUNC_PROPERTIES", KeyFuncType::PROPERTIES );
713 419 : SETCONST( pKeyFunc, "KEYFUNC_FRONT", KeyFuncType::FRONT );
714 419 : SETCONST( pKeyFunc, "KEYFUNC_FINDBACKWARD", KeyFuncType::FINDBACKWARD );
715 : // Variable einfuegen
716 419 : nVarId = aNmTb.Put( "Function", VARNAME );
717 419 : pClassKeyCode->SetVariable( nVarId, pKeyFunc, NULL );
718 : }
719 :
720 419 : return pClassKeyCode;
721 : }
722 :
723 419 : RscTop * RscTypCont::InitClassAccelItem( RscTop * pSuper,
724 : RscTop * pClassKeyCode )
725 : {
726 : Atom nId;
727 : RscTop * pClassAccelItem;
728 :
729 : // Klasse anlegen
730 419 : nId = pHS->getID( "AcceleratorItem" );
731 419 : pClassAccelItem = new RscClass( nId, RSC_ACCELITEM, pSuper );
732 419 : aNmTb.Put( nId, CLASSNAME, pClassAccelItem );
733 :
734 : // Variablen anlegen
735 419 : nId = aNmTb.Put( "Identifier", VARNAME );
736 419 : pClassAccelItem->SetVariable( nId, &aIdNoZeroUShort );
737 419 : nId = aNmTb.Put( "Disable", VARNAME );
738 419 : pClassAccelItem->SetVariable( nId, &aBool );
739 419 : nId = aNmTb.Put( "Key", VARNAME );
740 : pClassAccelItem->SetVariable( nId, pClassKeyCode, NULL, 0,
741 419 : ACCELITEM_KEY );
742 :
743 419 : return pClassAccelItem;
744 : }
745 :
746 419 : RscTop * RscTypCont::InitClassAccel( RscTop * pSuper, RscTop * pClassAccelItem )
747 : {
748 : Atom nId;
749 : RscTop * pClassAccel;
750 :
751 : // Klasse anlegen
752 419 : nId = pHS->getID( "Accelerator" );
753 419 : pClassAccel = new RscClass( nId, RSC_ACCEL, pSuper );
754 419 : pClassAccel->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType );
755 419 : aNmTb.Put( nId, CLASSNAME, pClassAccel );
756 :
757 : // Variablen anlegen
758 419 : nId = aNmTb.Put( "HelpText", VARNAME );
759 419 : pClassAccel->SetVariable( nId, &aLangString );
760 : {
761 : RscCont * pCont;
762 :
763 : aBaseLst.push_back(
764 1257 : pCont = new RscCont( pHS->getID( "ContAcceleratorKey" ), RSC_NOTYPE )
765 838 : );
766 419 : pCont->SetTypeClass( pClassAccelItem );
767 419 : nId = aNmTb.Put( "ItemList", VARNAME );
768 419 : pClassAccel->SetVariable( nId, pCont );
769 : }
770 :
771 419 : return pClassAccel;
772 : }
773 :
774 419 : RscTop * RscTypCont::InitClassMenuItem( RscTop * pSuper,
775 : RscTop * pClassBitmap,
776 : RscTop * pClassKeyCode )
777 : {
778 : Atom nId;
779 : RscTop * pClassMenuItem;
780 :
781 : // Klasse anlegen
782 419 : nId = pHS->getID( "MenuItem" );
783 419 : pClassMenuItem = new RscClass( nId, RSC_MENUITEM, pSuper );
784 419 : aNmTb.Put( nId, CLASSNAME, pClassMenuItem );
785 :
786 : // Variablen anlegen
787 419 : nId = aNmTb.Put( "Separator", VARNAME );
788 : pClassMenuItem->SetVariable( nId, &aBool, NULL, 0,
789 419 : RSC_MENUITEM_SEPARATOR );
790 419 : nId = aNmTb.Put( "Identifier", VARNAME );
791 : pClassMenuItem->SetVariable( nId, &aIdNoZeroUShort, NULL, 0,
792 419 : RSC_MENUITEM_ID );
793 : {
794 : RscFlag * pFlag;
795 : RscClient * pClient;
796 : Atom nVarId, nAutoCheckId, nRadioCheckId;
797 : Atom nCheckableId, nAboutId, nHelpId;
798 :
799 419 : aBaseLst.push_back( pFlag = new RscFlag( pHS->getID( "FlagMenuState" ), RSC_NOTYPE ) );
800 :
801 : // Konstanten in Tabelle stellen
802 419 : nCheckableId = pHS->getID( "MIB_CHECKABLE" );
803 419 : SETCONST( pFlag, nCheckableId, MenuItemBits::CHECKABLE );
804 419 : nAutoCheckId = pHS->getID( "MIB_AUTOCHECK" );
805 419 : SETCONST( pFlag, nAutoCheckId, MenuItemBits::AUTOCHECK );
806 419 : nRadioCheckId = pHS->getID( "MIB_RADIOCHECK" );
807 419 : SETCONST( pFlag, nRadioCheckId, MenuItemBits::RADIOCHECK );
808 419 : nAboutId = pHS->getID( "MIB_ABOUT" );
809 419 : SETCONST( pFlag, nAboutId, MenuItemBits::ABOUT );
810 419 : nHelpId = pHS->getID( "MIB_HELP" );
811 419 : SETCONST( pFlag, nHelpId, MenuItemBits::HELP );
812 :
813 : // Variable einfuegen
814 419 : nVarId = aNmTb.Put( "_MenuItemFlags", VARNAME );
815 : pClassMenuItem->SetVariable( nVarId, pFlag, NULL,
816 : VAR_HIDDEN | VAR_NOENUM,
817 419 : RSC_MENUITEM_STATUS );
818 :
819 : // Clientvariablen einfuegen
820 : aBaseLst.push_back(
821 1257 : pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE, pFlag, nCheckableId )
822 838 : );
823 419 : nId = aNmTb.Put( "Checkable", VARNAME );
824 : pClassMenuItem->SetVariable( nId, pClient, NULL,
825 419 : VAR_NODATAINST, 0, nVarId );
826 :
827 : aBaseLst.push_back(
828 1257 : pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE, pFlag, nAutoCheckId )
829 838 : );
830 419 : nId = aNmTb.Put( "AutoCheck", VARNAME );
831 : pClassMenuItem->SetVariable( nId, pClient, NULL,
832 419 : VAR_NODATAINST, 0, nVarId );
833 :
834 : aBaseLst.push_back(
835 1257 : pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE, pFlag, nRadioCheckId )
836 838 : );
837 419 : nId = aNmTb.Put( "RadioCheck", VARNAME );
838 : pClassMenuItem->SetVariable( nId, pClient, NULL,
839 419 : VAR_NODATAINST, 0, nVarId );
840 :
841 : aBaseLst.push_back(
842 1257 : pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE, pFlag, nAboutId )
843 838 : );
844 419 : nId = aNmTb.Put( "About", VARNAME );
845 : pClassMenuItem->SetVariable( nId, pClient, NULL,
846 419 : VAR_NODATAINST, 0, nVarId );
847 :
848 : aBaseLst.push_back(
849 1257 : pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE, pFlag, nHelpId )
850 838 : );
851 419 : nId = aNmTb.Put( "Help", VARNAME );
852 : pClassMenuItem->SetVariable( nId, pClient, NULL,
853 419 : VAR_NODATAINST, 0, nVarId );
854 :
855 : }
856 419 : nId = aNmTb.Put( "Text", VARNAME );
857 : pClassMenuItem->SetVariable( nId, &aLangString, NULL, 0,
858 419 : RSC_MENUITEM_TEXT );
859 419 : nId = aNmTb.Put( "ItemBitmap", VARNAME );
860 : pClassMenuItem->SetVariable( nId, pClassBitmap, NULL, 0,
861 419 : RSC_MENUITEM_BITMAP );
862 419 : nId = aNmTb.Put( "HelpText", VARNAME );
863 : pClassMenuItem->SetVariable( nId, &aLangString, NULL, 0,
864 419 : RSC_MENUITEM_HELPTEXT );
865 419 : nId = aNmTb.Put( "HelpID", VARNAME );
866 : pClassMenuItem->SetVariable( nId, &aStringLiteral, NULL, 0,
867 419 : RSC_MENUITEM_HELPID );
868 419 : nId = aNmTb.Put( "AccelKey", VARNAME );
869 : pClassMenuItem->SetVariable( nId, pClassKeyCode, NULL, 0,
870 419 : RSC_MENUITEM_KEYCODE );
871 419 : nId = aNmTb.Put( "Check", VARNAME );
872 : pClassMenuItem->SetVariable( nId, &aBool, NULL, 0,
873 419 : RSC_MENUITEM_CHECKED );
874 419 : nId = aNmTb.Put( "Disable", VARNAME );
875 : pClassMenuItem->SetVariable( nId, &aBool, NULL, 0,
876 419 : RSC_MENUITEM_DISABLE );
877 419 : nId = aNmTb.Put( "Command", VARNAME );
878 : pClassMenuItem->SetVariable( nId, &aString, NULL, 0,
879 419 : RSC_MENUITEM_COMMAND );
880 :
881 419 : return pClassMenuItem;
882 : }
883 :
884 419 : RscTop * RscTypCont::InitClassMenu( RscTop * pSuper,
885 : RscTop * pClassMenuItem )
886 : {
887 : Atom nId;
888 : RscTop * pClassMenu;
889 :
890 : // Klasse anlegen
891 419 : nId = pHS->getID( "Menu" );
892 419 : pClassMenu = new RscClass( nId, RSC_MENU, pSuper );
893 419 : pClassMenu->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType );
894 419 : aNmTb.Put( nId, CLASSNAME, pClassMenu );
895 :
896 : // Variablen anlegen
897 : {
898 : RscCont * pCont;
899 :
900 419 : aBaseLst.push_back( pCont = new RscCont( pHS->getID( "ContMenuItem" ), RSC_NOTYPE ) );
901 419 : pCont->SetTypeClass( pClassMenuItem );
902 419 : nId = aNmTb.Put( "ItemList", VARNAME );
903 419 : pClassMenu->SetVariable( nId, pCont, NULL, 0, RSC_MENU_ITEMS );
904 : }
905 419 : nId = aNmTb.Put( "Text", VARNAME );
906 419 : pClassMenu->SetVariable( nId, &aLangString, NULL, 0, RSC_MENU_TEXT );
907 419 : nId = aNmTb.Put( "DefaultItemId", VARNAME );
908 : pClassMenu->SetVariable( nId, &aIdUShort, NULL, 0,
909 419 : RSC_MENU_DEFAULTITEMID );
910 :
911 419 : return pClassMenu;
912 : }
913 :
914 419 : RscTop * RscTypCont::InitClassSplitter( RscTop * pSuper )
915 : {
916 : Atom nId;
917 : RscTop * pClassSplitter;
918 :
919 : // Klasse anlegen
920 419 : nId = pHS->getID( "Splitter" );
921 419 : pClassSplitter = new RscClass( nId, RSC_SPLITTER, pSuper );
922 419 : pClassSplitter->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
923 :
924 419 : aNmTb.Put( nId, CLASSNAME, pClassSplitter );
925 :
926 419 : INS_WINBIT(pClassSplitter,HScroll);
927 419 : INS_WINBIT(pClassSplitter,VScroll);
928 :
929 419 : return pClassSplitter;
930 : }
931 :
932 419 : RscTop * RscTypCont::InitClassSplitWindow( RscTop * pSuper )
933 : {
934 : Atom nId;
935 : RscTop * pClassSplitWindow;
936 :
937 : // Klasse anlegen
938 419 : nId = pHS->getID( "SplitWindow" );
939 419 : pClassSplitWindow = new RscClass( nId, RSC_SPLITWINDOW, pSuper );
940 419 : pClassSplitWindow->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
941 :
942 419 : aNmTb.Put( nId, CLASSNAME, pClassSplitWindow );
943 :
944 419 : INS_WINBIT(pClassSplitWindow,Sizeable)
945 419 : INS_WINBIT(pClassSplitWindow,NoSplitDraw)
946 :
947 419 : return pClassSplitWindow;
948 : }
949 :
950 419 : RscTop * RscTypCont::InitClassTime( RscTop * pSuper )
951 : {
952 : Atom nId;
953 : RscTop * pClassTime;
954 :
955 : // Klasse anlegen
956 419 : nId = pHS->getID( "Time" );
957 419 : pClassTime = new RscClass( nId, RSC_TIME, pSuper );
958 419 : pClassTime->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType );
959 :
960 419 : aNmTb.Put( nId, CLASSNAME, pClassTime );
961 :
962 : // Variablen anlegen
963 419 : nId = aNmTb.Put( "Hour", VARNAME );
964 419 : pClassTime->SetVariable( nId, &a0to23Short, NULL, 0, TIME_HOUR );
965 :
966 419 : nId = aNmTb.Put( "Minute", VARNAME );
967 419 : pClassTime->SetVariable( nId, &a0to59Short, NULL, 0, TIME_MINUTE );
968 :
969 419 : nId = aNmTb.Put( "Second", VARNAME );
970 419 : pClassTime->SetVariable( nId, &a0to59Short, NULL, 0, TIME_SECOND );
971 :
972 419 : nId = aNmTb.Put( "Sec100", VARNAME ); // weiss noch nich
973 419 : pClassTime->SetVariable( nId, &a0to99Short, NULL, 0, TIME_SEC100 );
974 :
975 419 : return pClassTime;
976 : }
977 :
978 419 : RscTop * RscTypCont::InitClassDate( RscTop * pSuper )
979 : {
980 : Atom nId;
981 : RscTop * pClassDate;
982 :
983 : // Klasse anlegen
984 419 : nId = pHS->getID( "Date" );
985 419 : pClassDate = new RscClass( nId, RSC_DATE, pSuper );
986 419 : pClassDate->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType );
987 :
988 419 : aNmTb.Put( nId, CLASSNAME, pClassDate );
989 :
990 : // Variablen anlegen
991 419 : nId = aNmTb.Put( "Year", VARNAME );
992 419 : pClassDate->SetVariable( nId, &a0to9999Short, NULL, 0, DATE_YEAR );
993 :
994 419 : nId = aNmTb.Put( "Month", VARNAME );
995 419 : pClassDate->SetVariable( nId, &a1to12Short, NULL, 0, DATE_MONTH );
996 :
997 419 : nId = aNmTb.Put( "Day", VARNAME );
998 419 : pClassDate->SetVariable( nId, &a1to31Short, NULL, 0, DATE_DAY );
999 :
1000 419 : return pClassDate;
1001 : }
1002 :
1003 838 : RscTop * RscTypCont::InitClassNumericFormatter( RscTop * pSuper )
1004 : {
1005 : Atom nId;
1006 : RscTop * pClassNumeric;
1007 :
1008 : // Klasse anlegen
1009 838 : nId = pHS->getID( "NumericFormatter" );
1010 838 : pClassNumeric = new RscClass( nId, RSC_NOTYPE, pSuper );
1011 838 : pClassNumeric->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType );
1012 :
1013 : // Variablen anlegen
1014 838 : nId = aNmTb.Put( "Minimum", VARNAME );
1015 : pClassNumeric->SetVariable( nId, &aIdLong, NULL,
1016 838 : 0, NUMERICFORMATTER_MIN );
1017 838 : nId = aNmTb.Put( "Maximum", VARNAME );
1018 : pClassNumeric->SetVariable( nId, &aIdLong, NULL,
1019 838 : 0, NUMERICFORMATTER_MAX );
1020 838 : nId = aNmTb.Put( "StrictFormat", VARNAME );
1021 : pClassNumeric->SetVariable( nId, &aBool, NULL,
1022 838 : 0, NUMERICFORMATTER_STRICTFORMAT );
1023 838 : nId = aNmTb.Put( "DecimalDigits", VARNAME );
1024 : pClassNumeric->SetVariable( nId, &aUShort, NULL,
1025 838 : 0, NUMERICFORMATTER_DECIMALDIGITS );
1026 838 : nId = aNmTb.Put( "Value", VARNAME );
1027 : pClassNumeric->SetVariable( nId, &aIdLong, NULL,
1028 838 : 0, NUMERICFORMATTER_VALUE );
1029 838 : nId = aNmTb.Put( "NoThousandSep", VARNAME );
1030 : pClassNumeric->SetVariable( nId, &aBool, NULL,
1031 838 : 0, NUMERICFORMATTER_NOTHOUSANDSEP );
1032 :
1033 838 : return pClassNumeric;
1034 : }
1035 :
1036 419 : RscTop * RscTypCont::InitClassMetricFormatter( RscTop * pSuper,
1037 : RscEnum * pFieldUnits )
1038 : {
1039 : Atom nId;
1040 : RscTop * pClassMetric;
1041 :
1042 : // Klasse anlegen
1043 419 : nId = pHS->getID( "MetricFormatter" );
1044 419 : pClassMetric = new RscClass( nId, RSC_NOTYPE, pSuper );
1045 419 : pClassMetric->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType );
1046 :
1047 : // Variablen anlegen
1048 419 : nId = aNmTb.Put( "Unit", VARNAME );
1049 : pClassMetric->SetVariable( nId, pFieldUnits, NULL,
1050 419 : 0, METRICFORMATTER_UNIT );
1051 419 : nId = aNmTb.Put( "CustomUnitText", VARNAME );
1052 : pClassMetric->SetVariable( nId, &aLangString, NULL,
1053 419 : 0, METRICFORMATTER_CUSTOMUNITTEXT );
1054 :
1055 419 : return pClassMetric;
1056 : }
1057 :
1058 419 : RscTop * RscTypCont::InitClassDateFormatter( RscTop * pSuper,
1059 : RscTop * pClassDate )
1060 : {
1061 : Atom nId;
1062 : RscTop * pClassDateF;
1063 :
1064 : // Klasse anlegen
1065 419 : nId = pHS->getID( "DateFormatter" );
1066 419 : pClassDateF = new RscClass( nId, RSC_NOTYPE, pSuper );
1067 419 : pClassDateF->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType );
1068 :
1069 : // Variablen anlegen
1070 419 : nId = aNmTb.Put( "Minimum", VARNAME );
1071 : pClassDateF->SetVariable( nId, pClassDate, NULL,
1072 419 : 0, DATEFORMATTER_MIN );
1073 419 : nId = aNmTb.Put( "Maximum", VARNAME );
1074 : pClassDateF->SetVariable( nId, pClassDate, NULL,
1075 419 : 0, DATEFORMATTER_MAX );
1076 419 : nId = aNmTb.Put( "LongFormat", VARNAME );
1077 : pClassDateF->SetVariable( nId, &aBool, NULL,
1078 419 : 0, DATEFORMATTER_LONGFORMAT );
1079 419 : nId = aNmTb.Put( "StrictFormat", VARNAME );
1080 : pClassDateF->SetVariable( nId, &aBool, NULL,
1081 419 : 0, DATEFORMATTER_STRICTFORMAT );
1082 419 : nId = aNmTb.Put( "Value", VARNAME );
1083 : pClassDateF->SetVariable( nId, pClassDate, NULL,
1084 419 : 0, DATEFORMATTER_VALUE );
1085 :
1086 419 : return pClassDateF;
1087 : }
1088 :
1089 419 : RscTop * RscTypCont::InitClassTimeFormatter( RscTop * pSuper,
1090 : RscTop * pClassTime,
1091 : RscEnum * pTimeFieldFormat )
1092 : {
1093 : Atom nId;
1094 : RscTop * pClassTimeF;
1095 :
1096 : // Klasse anlegen
1097 419 : nId = pHS->getID( "TimeFormatter" );
1098 419 : pClassTimeF = new RscClass( nId, RSC_NOTYPE, pSuper );
1099 419 : pClassTimeF->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType );
1100 :
1101 : // Variablen anlegen
1102 419 : nId = aNmTb.Put( "Minimum", VARNAME );
1103 : pClassTimeF->SetVariable( nId, pClassTime, NULL,
1104 419 : 0, TIMEFORMATTER_MIN );
1105 419 : nId = aNmTb.Put( "Maximum", VARNAME );
1106 : pClassTimeF->SetVariable( nId, pClassTime, NULL,
1107 419 : 0, TIMEFORMATTER_MAX );
1108 419 : nId = aNmTb.Put( "Format", VARNAME );
1109 : pClassTimeF->SetVariable( nId, pTimeFieldFormat, NULL,
1110 419 : 0, TIMEFORMATTER_TIMEFIELDFORMAT );
1111 419 : nId = aNmTb.Put( "Duration", VARNAME );
1112 : pClassTimeF->SetVariable( nId, &aBool, NULL,
1113 419 : 0, TIMEFORMATTER_DURATION );
1114 419 : nId = aNmTb.Put( "StrictFormat", VARNAME );
1115 : pClassTimeF->SetVariable( nId, &aBool, NULL,
1116 419 : 0, TIMEFORMATTER_STRICTFORMAT );
1117 419 : nId = aNmTb.Put( "Value", VARNAME );
1118 : pClassTimeF->SetVariable( nId, pClassTime, NULL,
1119 419 : 0, TIMEFORMATTER_VALUE );
1120 :
1121 419 : return pClassTimeF;
1122 : }
1123 :
1124 419 : RscTop * RscTypCont::InitClassSpinField( RscTop * pSuper )
1125 : {
1126 : Atom nId;
1127 : RscTop * pClassSpinField;
1128 :
1129 : // Klasse anlegen
1130 419 : nId = pHS->getID( "SpinField" );
1131 419 : pClassSpinField = new RscClass( nId, RSC_SPINFIELD, pSuper );
1132 419 : pClassSpinField->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
1133 :
1134 419 : aNmTb.Put( nId, CLASSNAME, pClassSpinField );
1135 :
1136 419 : INS_WINBIT(pClassSpinField,Repeat)
1137 419 : INS_WINBIT(pClassSpinField,Spin)
1138 :
1139 419 : return pClassSpinField;
1140 : }
1141 :
1142 419 : RscTop * RscTypCont::InitClassNumericField( RscTop * pSuper )
1143 : {
1144 : Atom nId;
1145 : RscTop * pClassNumericField;
1146 :
1147 : // Klasse anlegen
1148 419 : nId = pHS->getID( "NumericField" );
1149 419 : pClassNumericField = new RscClass( nId, RSC_NUMERICFIELD, pSuper );
1150 419 : pClassNumericField->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
1151 :
1152 419 : aNmTb.Put( nId, CLASSNAME, pClassNumericField );
1153 :
1154 : // Variablen anlegen
1155 419 : nId = aNmTb.Put( "First", VARNAME );
1156 : pClassNumericField->SetVariable( nId, &aIdLong, NULL,
1157 419 : 0, NUMERICFIELD_FIRST );
1158 419 : nId = aNmTb.Put( "Last", VARNAME );
1159 : pClassNumericField->SetVariable( nId, &aIdLong, NULL,
1160 419 : 0, NUMERICFIELD_LAST );
1161 419 : nId = aNmTb.Put( "SpinSize", VARNAME );
1162 : pClassNumericField->SetVariable( nId, &aIdLong, NULL,
1163 419 : 0, NUMERICFIELD_SPINSIZE );
1164 419 : return pClassNumericField;
1165 : }
1166 :
1167 419 : RscTop * RscTypCont::InitClassMetricField( RscTop * pSuper )
1168 : {
1169 : Atom nId;
1170 : RscTop * pClassMetricField;
1171 :
1172 : // Klasse anlegen
1173 419 : nId = pHS->getID( "MetricField" );
1174 419 : pClassMetricField = new RscClass( nId, RSC_METRICFIELD, pSuper );
1175 419 : pClassMetricField->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
1176 :
1177 419 : aNmTb.Put( nId, CLASSNAME, pClassMetricField );
1178 :
1179 : // Variablen anlegen
1180 419 : nId = aNmTb.Put( "First", VARNAME );
1181 : pClassMetricField->SetVariable( nId, &aIdLong, NULL,
1182 419 : 0, METRICFIELD_FIRST );
1183 419 : nId = aNmTb.Put( "Last", VARNAME );
1184 : pClassMetricField->SetVariable( nId, &aIdLong, NULL,
1185 419 : 0, METRICFIELD_LAST );
1186 419 : nId = aNmTb.Put( "SpinSize", VARNAME );
1187 : pClassMetricField->SetVariable( nId, &aIdLong, NULL,
1188 419 : 0, METRICFIELD_SPINSIZE );
1189 :
1190 419 : return pClassMetricField;
1191 : }
1192 :
1193 419 : RscTop * RscTypCont::InitClassDateField( RscTop * pSuper, RscTop * pClassDate )
1194 : {
1195 : Atom nId;
1196 : RscTop * pClassDateField;
1197 :
1198 : // Klasse anlegen
1199 419 : nId = pHS->getID( "DateField" );
1200 419 : pClassDateField = new RscClass( nId, RSC_DATEFIELD, pSuper );
1201 419 : pClassDateField->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
1202 :
1203 419 : aNmTb.Put( nId, CLASSNAME, pClassDateField );
1204 :
1205 : // Variablen anlegen
1206 419 : nId = aNmTb.Put( "First", VARNAME );
1207 419 : pClassDateField->SetVariable( nId, pClassDate, NULL, 0, DATEFIELD_FIRST );
1208 419 : nId = aNmTb.Put( "Last", VARNAME );
1209 419 : pClassDateField->SetVariable( nId, pClassDate, NULL, 0, DATEFIELD_LAST );
1210 :
1211 419 : return pClassDateField;
1212 : }
1213 :
1214 419 : RscTop * RscTypCont::InitClassTimeField( RscTop * pSuper, RscTop * pClassTime )
1215 : {
1216 : Atom nId;
1217 : RscTop * pClassTimeField;
1218 :
1219 : // Klasse anlegen
1220 419 : nId = pHS->getID( "TimeField" );
1221 419 : pClassTimeField = new RscClass( nId, RSC_TIMEFIELD, pSuper );
1222 419 : pClassTimeField->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
1223 :
1224 419 : aNmTb.Put( nId, CLASSNAME, pClassTimeField );
1225 :
1226 : // Variablen anlegen
1227 419 : nId = aNmTb.Put( "First", VARNAME );
1228 419 : pClassTimeField->SetVariable( nId, pClassTime, NULL, 0, TIMEFIELD_FIRST );
1229 419 : nId = aNmTb.Put( "Last", VARNAME );
1230 419 : pClassTimeField->SetVariable( nId, pClassTime, NULL, 0, TIMEFIELD_LAST );
1231 :
1232 419 : return pClassTimeField;
1233 : }
1234 :
1235 419 : RscTop * RscTypCont::InitClassDockingWindow( RscTop * pSuper,
1236 : RscEnum * pMapUnit )
1237 : {
1238 : Atom nId;
1239 : RscTop * pClassDockWindow;
1240 :
1241 : // Klasse anlegen
1242 419 : nId = pHS->getID( "DockingWindow" );
1243 419 : pClassDockWindow = new RscClass( nId, RSC_DOCKINGWINDOW, pSuper );
1244 419 : pClassDockWindow->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
1245 419 : aNmTb.Put( nId, CLASSNAME, pClassDockWindow );
1246 :
1247 : // Variablen anlegen
1248 419 : nId = aNmTb.Put( "_FloatingPosMapMode", VARNAME );
1249 : pClassDockWindow->SetVariable( nId, pMapUnit, NULL, 0,
1250 419 : RSC_DOCKINGWINDOW_XYMAPMODE );
1251 419 : nId = aNmTb.Put( "_FloatingPosX", VARNAME );
1252 : pClassDockWindow->SetVariable( nId, &aShort, NULL, 0,
1253 419 : RSC_DOCKINGWINDOW_X );
1254 419 : nId = aNmTb.Put( "_FloatingPosY", VARNAME );
1255 : pClassDockWindow->SetVariable( nId, &aShort, NULL, 0,
1256 419 : RSC_DOCKINGWINDOW_Y );
1257 419 : nId = aNmTb.Put( "FloatingMode", VARNAME );
1258 : pClassDockWindow->SetVariable( nId, &aBool, NULL, 0,
1259 419 : RSC_DOCKINGWINDOW_FLOATING );
1260 :
1261 419 : INS_WINBIT(pClassDockWindow,Moveable)
1262 419 : INS_WINBIT(pClassDockWindow,Sizeable)
1263 419 : INS_WINBIT(pClassDockWindow,EnableResizing)
1264 419 : INS_WINBIT(pClassDockWindow,Closeable)
1265 419 : INS_WINBIT(pClassDockWindow,HideWhenDeactivate);
1266 419 : INS_WINBIT(pClassDockWindow,Zoomable);
1267 419 : INS_WINBIT(pClassDockWindow,Dockable);
1268 :
1269 419 : return pClassDockWindow;
1270 : }
1271 :
1272 419 : RscTop * RscTypCont::InitClassToolBoxItem( RscTop * pSuper,
1273 : RscTop * pClassBitmap,
1274 : RscTop * pClassImage,
1275 : RscEnum * pTriState )
1276 : {
1277 : Atom nId;
1278 : RscTop * pClassToolBoxItem;
1279 :
1280 : // Klasse anlegen
1281 419 : nId = pHS->getID( "ToolBoxItem" );
1282 419 : pClassToolBoxItem = new RscClass( nId, RSC_TOOLBOXITEM, pSuper );
1283 419 : aNmTb.Put( nId, CLASSNAME, pClassToolBoxItem );
1284 :
1285 : // Variablen anlegen
1286 419 : nId = aNmTb.Put( "Identifier", VARNAME );
1287 : pClassToolBoxItem->SetVariable( nId, &aIdNoZeroUShort, NULL, 0,
1288 419 : RSC_TOOLBOXITEM_ID );
1289 : {
1290 : RscEnum * pEnum;
1291 :
1292 419 : aBaseLst.push_back( pEnum = new RscEnum( pHS->getID( "EnumToolBoxItemType" ), RSC_NOTYPE ) );
1293 419 : SETCONST( pEnum, "TOOLBOXITEM_BUTTON", TOOLBOXITEM_BUTTON );
1294 419 : SETCONST( pEnum, "TOOLBOXITEM_SPACE", TOOLBOXITEM_SPACE );
1295 419 : SETCONST( pEnum, "TOOLBOXITEM_SEPARATOR", TOOLBOXITEM_SEPARATOR );
1296 419 : SETCONST( pEnum, "TOOLBOXITEM_BREAK", TOOLBOXITEM_BREAK );
1297 :
1298 : // Variable einfuegen
1299 419 : nId = aNmTb.Put( "Type", VARNAME );
1300 : pClassToolBoxItem->SetVariable( nId, pEnum, NULL, 0,
1301 419 : RSC_TOOLBOXITEM_TYPE );
1302 : }
1303 : {
1304 : RscFlag * pFlag;
1305 : RscClient * pClient;
1306 : Atom l_nVarId, l_nAutoCheckId, l_nRadioCheckId, l_nCheckableId, l_nLeftId, l_nAutoSizeId, l_nDropDownId;
1307 :
1308 419 : aBaseLst.push_back( pFlag = new RscFlag( pHS->getID( "FlagToolBoxState" ), RSC_NOTYPE ) );
1309 :
1310 : // Konstanten in Tabelle stellen
1311 419 : l_nCheckableId = pHS->getID( "ToolBoxItemBits::CHECKABLE" );
1312 419 : SETCONST( pFlag, l_nCheckableId, ToolBoxItemBits::CHECKABLE );
1313 419 : l_nAutoCheckId = pHS->getID( "ToolBoxItemBits::AUTOCHECK" );
1314 419 : SETCONST( pFlag, l_nAutoCheckId, ToolBoxItemBits::AUTOCHECK );
1315 419 : l_nRadioCheckId = pHS->getID( "ToolBoxItemBits::RADIOCHECK" );
1316 419 : SETCONST( pFlag, l_nRadioCheckId, ToolBoxItemBits::RADIOCHECK );
1317 419 : l_nLeftId = pHS->getID( "ToolBoxItemBits::LEFT" );
1318 419 : SETCONST( pFlag, l_nLeftId, ToolBoxItemBits::LEFT );
1319 419 : l_nAutoSizeId = pHS->getID( "ToolBoxItemBits::AUTOSIZE" );
1320 419 : SETCONST( pFlag, l_nAutoSizeId, ToolBoxItemBits::AUTOSIZE );
1321 419 : l_nDropDownId = pHS->getID( "ToolBoxItemBits::DROPDOWN" );
1322 419 : SETCONST( pFlag, l_nDropDownId, ToolBoxItemBits::DROPDOWN );
1323 :
1324 : // Variable einfuegen
1325 419 : l_nVarId = aNmTb.Put( "_ToolBoxItemFlags", VARNAME );
1326 : pClassToolBoxItem->SetVariable( l_nVarId, pFlag, NULL,
1327 : VAR_HIDDEN | VAR_NOENUM,
1328 419 : RSC_TOOLBOXITEM_STATUS );
1329 :
1330 : // Clientvariablen einfuegen
1331 : aBaseLst.push_back(
1332 1257 : pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE, pFlag, l_nCheckableId )
1333 838 : );
1334 419 : nId = aNmTb.Put( "Checkable", VARNAME );
1335 419 : pClassToolBoxItem->SetVariable( nId, pClient, NULL, VAR_NODATAINST, 0, l_nVarId );
1336 :
1337 : aBaseLst.push_back(
1338 1257 : pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE, pFlag, l_nAutoCheckId )
1339 838 : );
1340 419 : nId = aNmTb.Put( "AutoCheck", VARNAME );
1341 419 : pClassToolBoxItem->SetVariable( nId, pClient, NULL, VAR_NODATAINST, 0, l_nVarId );
1342 :
1343 : aBaseLst.push_back(
1344 1257 : pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE, pFlag, l_nRadioCheckId )
1345 838 : );
1346 419 : nId = aNmTb.Put( "RadioCheck", VARNAME );
1347 419 : pClassToolBoxItem->SetVariable( nId, pClient, NULL, VAR_NODATAINST, 0, l_nVarId );
1348 :
1349 : aBaseLst.push_back(
1350 1257 : pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE, pFlag, l_nLeftId )
1351 838 : );
1352 419 : nId = aNmTb.Put( "Left", VARNAME );
1353 419 : pClassToolBoxItem->SetVariable( nId, pClient, NULL, VAR_NODATAINST, 0, l_nVarId );
1354 :
1355 : aBaseLst.push_back(
1356 1257 : pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE, pFlag, l_nAutoSizeId )
1357 838 : );
1358 419 : nId = aNmTb.Put( "AutoSize", VARNAME );
1359 419 : pClassToolBoxItem->SetVariable( nId, pClient, NULL, VAR_NODATAINST, 0, l_nVarId );
1360 :
1361 : aBaseLst.push_back(
1362 1257 : pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE, pFlag, l_nDropDownId )
1363 838 : );
1364 419 : nId = aNmTb.Put( "DropDown", VARNAME );
1365 419 : pClassToolBoxItem->SetVariable( nId, pClient, NULL, VAR_NODATAINST, 0, l_nVarId );
1366 : }
1367 419 : nId = aNmTb.Put( "HelpID", VARNAME );
1368 : pClassToolBoxItem->SetVariable( nId, &aStringLiteral, NULL, 0,
1369 419 : RSC_TOOLBOXITEM_HELPID );
1370 419 : nId = aNmTb.Put( "Text", VARNAME );
1371 : pClassToolBoxItem->SetVariable( nId, &aLangString, NULL, 0,
1372 419 : RSC_TOOLBOXITEM_TEXT );
1373 419 : nId = aNmTb.Put( "HelpText", VARNAME );
1374 : pClassToolBoxItem->SetVariable( nId, &aLangString, NULL, 0,
1375 419 : RSC_TOOLBOXITEM_HELPTEXT );
1376 419 : nId = aNmTb.Put( "ItemBitmap", VARNAME );
1377 : pClassToolBoxItem->SetVariable( nId, pClassBitmap, NULL, 0,
1378 419 : RSC_TOOLBOXITEM_BITMAP );
1379 419 : nId = aNmTb.Put( "ItemImage", VARNAME );
1380 : pClassToolBoxItem->SetVariable( nId, pClassImage, NULL, 0,
1381 419 : RSC_TOOLBOXITEM_IMAGE );
1382 419 : nId = aNmTb.Put( "Disable", VARNAME );
1383 : pClassToolBoxItem->SetVariable( nId, &aBool, NULL, 0,
1384 419 : RSC_TOOLBOXITEM_DISABLE );
1385 :
1386 419 : nId = aNmTb.Put( "State", VARNAME );
1387 : pClassToolBoxItem->SetVariable( nId, pTriState, NULL, 0,
1388 419 : RSC_TOOLBOXITEM_STATE );
1389 419 : nId = aNmTb.Put( "Hide", VARNAME );
1390 : pClassToolBoxItem->SetVariable( nId, &aBool, NULL, 0,
1391 419 : RSC_TOOLBOXITEM_HIDE );
1392 419 : nId = aNmTb.Put( "Hide", VARNAME );
1393 : pClassToolBoxItem->SetVariable( nId, &aBool, NULL, 0,
1394 419 : RSC_TOOLBOXITEM_HIDE );
1395 419 : nId = aNmTb.Put( "Command", VARNAME );
1396 : pClassToolBoxItem->SetVariable( nId, &aString, NULL, 0,
1397 419 : RSC_TOOLBOXITEM_COMMAND );
1398 :
1399 419 : return pClassToolBoxItem;
1400 : }
1401 :
1402 419 : RscTop * RscTypCont::InitClassToolBox( RscTop * pSuper,
1403 : RscTop * pClassToolBoxItem,
1404 : RscTop * pClassImageList )
1405 : {
1406 : Atom nId;
1407 : RscTop * pClassToolBox;
1408 :
1409 : // Klasse anlegen
1410 419 : nId = pHS->getID( "ToolBox" );
1411 419 : pClassToolBox = new RscClass( nId, RSC_TOOLBOX, pSuper );
1412 419 : pClassToolBox->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
1413 419 : aNmTb.Put( nId, CLASSNAME, pClassToolBox );
1414 :
1415 : // Variablen anlegen
1416 : {
1417 : RscEnum * pEnum;
1418 :
1419 419 : aBaseLst.push_back( pEnum = new RscEnum( pHS->getID( "EnumButtonType" ), RSC_NOTYPE ) );
1420 419 : SETCONST( pEnum, "BUTTON_SYMBOL", BUTTON_SYMBOL );
1421 419 : SETCONST( pEnum, "BUTTON_TEXT", BUTTON_TEXT );
1422 419 : SETCONST( pEnum, "BUTTON_SYMBOLTEXT", BUTTON_SYMBOLTEXT );
1423 :
1424 : // Variable einfuegen
1425 419 : nId = aNmTb.Put( "ButtonType", VARNAME );
1426 : pClassToolBox->SetVariable( nId, pEnum, NULL, 0,
1427 419 : RSC_TOOLBOX_BUTTONTYPE );
1428 : }
1429 : {
1430 : RscEnum * pEnum;
1431 :
1432 419 : aBaseLst.push_back( pEnum = new RscEnum( pHS->getID( "EnumToolBoxAlign" ), RSC_NOTYPE ) );
1433 419 : SETCONST( pEnum, "BOXALIGN_TOP", WINDOWALIGN_TOP );
1434 419 : SETCONST( pEnum, "BOXALIGN_LEFT", WINDOWALIGN_LEFT );
1435 419 : SETCONST( pEnum, "BOXALIGN_RIGHT", WINDOWALIGN_RIGHT );
1436 419 : SETCONST( pEnum, "BOXALIGN_BOTTOM", WINDOWALIGN_BOTTOM );
1437 :
1438 : // Variable einfuegen
1439 419 : nId = aNmTb.Put( "Align", VARNAME );
1440 : pClassToolBox->SetVariable( nId, pEnum, NULL, 0,
1441 419 : RSC_TOOLBOX_ALIGN );
1442 : }
1443 419 : nId = aNmTb.Put( "LineCount", VARNAME );
1444 : pClassToolBox->SetVariable( nId, &aIdNoZeroUShort, NULL, 0,
1445 419 : RSC_TOOLBOX_LINECOUNT );
1446 419 : nId = aNmTb.Put( "FloatingLines", VARNAME );
1447 : pClassToolBox->SetVariable( nId, &aUShort, NULL, 0,
1448 419 : RSC_TOOLBOX_FLOATLINES );
1449 419 : nId = aNmTb.Put( "Customize", VARNAME );
1450 : pClassToolBox->SetVariable( nId, &aBool, NULL, 0,
1451 419 : RSC_TOOLBOX_CUSTOMIZE );
1452 419 : nId = aNmTb.Put( "MenuStrings", VARNAME );
1453 : pClassToolBox->SetVariable( nId, &aBool, NULL, 0,
1454 419 : RSC_TOOLBOX_MENUSTRINGS );
1455 419 : nId = aNmTb.Put( "ItemImageList", VARNAME );
1456 : pClassToolBox->SetVariable( nId, pClassImageList, NULL, 0,
1457 419 : RSC_TOOLBOX_ITEMIMAGELIST );
1458 : {
1459 : RscLangArray* pLA;
1460 : RscCont * pCont;
1461 :
1462 419 : aBaseLst.push_back( pCont = new RscCont( pHS->getID( "ContToolBoxItem" ), RSC_NOTYPE ) );
1463 419 : pCont->SetTypeClass( pClassToolBoxItem );
1464 : aBaseLst.push_back(
1465 838 : pLA = new RscLangArray( pHS->getID( "LangContToolBoxItem" )
1466 : , RSC_NOTYPE
1467 : , pCont
1468 : , &aLangType
1469 419 : )
1470 838 : );
1471 419 : nId = aNmTb.Put( "ItemList", VARNAME );
1472 : pClassToolBox->SetVariable( nId, pLA, NULL, 0,
1473 419 : RSC_TOOLBOX_ITEMLIST );
1474 : }
1475 419 : INS_WINBIT(pClassToolBox,Scroll)
1476 419 : INS_WINBIT(pClassToolBox,LineSpacing)
1477 419 : INS_WINBIT(pClassToolBox,RectStyle)
1478 419 : INS_WINBIT(pClassToolBox,Tabstop)
1479 :
1480 419 : return pClassToolBox;
1481 : }
1482 :
1483 419 : RscTop * RscTypCont::InitClassSfxStyleFamilyItem( RscTop * pSuper,
1484 : RscTop * pClassBitmap,
1485 : RscTop * pClassImage,
1486 : RscArray * pStrLst )
1487 : {
1488 : Atom nId;
1489 : RscTop * pClassSfxFamilyStyleItem;
1490 :
1491 : // Klasse anlegen
1492 419 : nId = pHS->getID( "SfxStyleFamilyItem" );
1493 419 : pClassSfxFamilyStyleItem = new RscClass( nId, RSC_SFX_STYLE_FAMILY_ITEM, pSuper );
1494 419 : aNmTb.Put( nId, CLASSNAME, pClassSfxFamilyStyleItem );
1495 :
1496 419 : nId = aNmTb.Put( "FilterList", VARNAME );
1497 : pClassSfxFamilyStyleItem->SetVariable( nId, pStrLst, NULL, 0,
1498 419 : RSC_SFX_STYLE_ITEM_LIST );
1499 419 : nId = aNmTb.Put( "StyleBitmap", VARNAME );
1500 : pClassSfxFamilyStyleItem->SetVariable( nId, pClassBitmap, NULL, 0,
1501 419 : RSC_SFX_STYLE_ITEM_BITMAP );
1502 419 : nId = aNmTb.Put( "Text", VARNAME );
1503 : pClassSfxFamilyStyleItem->SetVariable( nId, &aLangString, NULL, 0,
1504 419 : RSC_SFX_STYLE_ITEM_TEXT );
1505 419 : nId = aNmTb.Put( "HelpText", VARNAME );
1506 : pClassSfxFamilyStyleItem->SetVariable( nId, &aLangString, NULL, 0,
1507 419 : RSC_SFX_STYLE_ITEM_HELPTEXT );
1508 : {
1509 : RscEnum * pSfxStyleFamily;
1510 838 : pSfxStyleFamily = new RscEnum( pHS->getID( "StyleFamily" ),
1511 419 : RSC_NOTYPE );
1512 :
1513 419 : SETCONST( pSfxStyleFamily, "SFX_STYLE_FAMILY_PARA", SFX_STYLE_FAMILY_PARA );
1514 419 : SETCONST( pSfxStyleFamily, "SFX_STYLE_FAMILY_CHAR", SFX_STYLE_FAMILY_CHAR );
1515 419 : SETCONST( pSfxStyleFamily, "SFX_STYLE_FAMILY_FRAME",SFX_STYLE_FAMILY_FRAME);
1516 419 : SETCONST( pSfxStyleFamily, "SFX_STYLE_FAMILY_PAGE", SFX_STYLE_FAMILY_PAGE );
1517 419 : SETCONST( pSfxStyleFamily, "SFX_STYLE_FAMILY_PSEUDO", SFX_STYLE_FAMILY_PSEUDO );
1518 419 : aBaseLst.push_back( pSfxStyleFamily );
1519 :
1520 419 : nId = aNmTb.Put( "StyleFamily", VARNAME );
1521 : pClassSfxFamilyStyleItem->SetVariable( nId, pSfxStyleFamily, NULL, 0,
1522 419 : RSC_SFX_STYLE_ITEM_STYLEFAMILY );
1523 : }
1524 419 : nId = aNmTb.Put( "StyleImage", VARNAME );
1525 : pClassSfxFamilyStyleItem->SetVariable( nId, pClassImage, NULL, 0,
1526 419 : RSC_SFX_STYLE_ITEM_IMAGE );
1527 419 : return pClassSfxFamilyStyleItem;
1528 : }
1529 :
1530 419 : RscTop * RscTypCont::InitClassSfxTemplateDialog( RscTop * pSuper,
1531 : RscTop * pClassFamilyStyleItem )
1532 : {
1533 : Atom nId;
1534 : RscTop * pClassSfxTemplateDialog;
1535 :
1536 : // Klasse anlegen
1537 419 : nId = pHS->getID( "SfxStyleFamilies" );
1538 419 : pClassSfxTemplateDialog = new RscClass( nId, RSC_SFX_STYLE_FAMILIES, pSuper );
1539 419 : aNmTb.Put( nId, CLASSNAME, pClassSfxTemplateDialog );
1540 :
1541 : // Variablen anlegen
1542 : {
1543 : RscCont * pCont;
1544 :
1545 : aBaseLst.push_back(
1546 1257 : pCont = new RscCont( pHS->getID( "ContFamilyStyleItem" ), RSC_NOTYPE )
1547 838 : );
1548 419 : pCont->SetTypeClass( pClassFamilyStyleItem );
1549 419 : nId = aNmTb.Put( "StyleFamilyList", VARNAME );
1550 419 : pClassSfxTemplateDialog->SetVariable( nId, pCont );
1551 : }
1552 :
1553 419 : return pClassSfxTemplateDialog;
1554 : }
1555 :
1556 419 : RscTop * RscTypCont::InitClassSfxSlotInfo( RscTop * pSuper )
1557 : {
1558 : Atom nId;
1559 : RscTop * pClassSfxSlotInfo;
1560 :
1561 : // Klasse anlegen
1562 419 : nId = pHS->getID( "SfxSlotInfo" );
1563 419 : pClassSfxSlotInfo = new RscClass( nId, RSC_SFX_SLOT_INFO, pSuper );
1564 419 : aNmTb.Put( nId, CLASSNAME, pClassSfxSlotInfo );
1565 :
1566 419 : nId = aNmTb.Put( "SlotName", VARNAME );
1567 : pClassSfxSlotInfo->SetVariable( nId, &aLangString, NULL, 0,
1568 419 : RSC_SFX_SLOT_INFO_SLOTNAME );
1569 419 : nId = aNmTb.Put( "HelpText", VARNAME );
1570 : pClassSfxSlotInfo->SetVariable( nId, &aLangString, NULL, 0,
1571 419 : RSC_SFX_SLOT_INFO_HELPTEXT );
1572 419 : return pClassSfxSlotInfo;
1573 : }
1574 :
1575 :
1576 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
