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