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