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