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