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