rsc/source/parser/rscicpx.cxx

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