/************************************************************** * * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. * *************************************************************/ // MARKER(update_precomp.py): autogen include statement, do not remove #include "precompiled_rsc.hxx" /****************** I N C L U D E S **************************************/ // C and C++ Includes. #include #include #include #include #include #include #include #include #include #include "rsclex.hxx" #include /************************************************************************* |* RscTypCont::InsWinBit() *************************************************************************/ void RscTypCont::InsWinBit( RscTop * pClass, const ByteString & rName, Atom nVal ) { RscClient * pClient; // Clientvariablen einfuegen aBaseLst.Insert( pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE, &aWinBits, nVal ), LIST_APPEND ); Atom nId = aNmTb.Put( rName.GetBuffer(), VARNAME ); pClass->SetVariable( nId, pClient, NULL, VAR_NODATAINST, 0, nWinBitVarId ); } #define INS_WINBIT( pClass, WinBit ) \ InsWinBit( pClass, #WinBit, n##WinBit##Id ); /************************************************************************* |* RscTypCont::InitClassMgr() *************************************************************************/ RscTop * RscTypCont::InitClassMgr() { RscTop * pClassMgr; RscBaseCont * pClass; Atom nId; aBaseLst.Insert( pClass = new RscBaseCont( InvalidAtom, RSC_NOTYPE, NULL, sal_False ), LIST_APPEND ); nId = pHS->getID( "Resource" ); pClassMgr = new RscMgr( nId, RSC_RESOURCE, pClass ); aNmTb.Put( nId, CLASSNAME, pClassMgr ); pClassMgr->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType ); // Variablen anlegen { RscContWriteSrc * pCont; // Variablen anlegen aBaseLst.Insert( pCont = new RscContExtraData( pHS->getID( "ContExtradata" ), RSC_NOTYPE ), LIST_APPEND ); pCont->SetTypeClass( &aShort, &aString ); nRsc_EXTRADATA = nId = aNmTb.Put( "ExtraData", VARNAME ); pClassMgr->SetVariable( nId, pCont ); }; nId = aNmTb.Put( "Comment", VARNAME ); pClassMgr->SetVariable( nId, &aString, NULL, VAR_NORC ); pClass->SetTypeClass( pClassMgr ); return pClassMgr; } /************************************************************************* |* RscTypCont::InitClassString() *************************************************************************/ RscTop * RscTypCont::InitClassString( RscTop * pSuper ){ Atom nId; RscTop * pClassString; nId = pHS->getID( "String" ); pClassString = new RscClass( nId, RSC_STRING, pSuper ); aNmTb.Put( nId, CLASSNAME, pClassString ); pClassString->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType ); // Variablen anlegen nId = aNmTb.Put( "Text", VARNAME ); pClassString->SetVariable( nId, &aLangString ); return( pClassString ); } /************************************************************************* |* RscTypCont::InitClassBitmap() *************************************************************************/ RscTop * RscTypCont::InitClassBitmap( RscTop * pSuper ){ Atom nId; RscTop * pClassBitmap; nId = pHS->getID( "Bitmap" ); pClassBitmap = new RscSysDepend( nId, RSC_BITMAP, pSuper ); pClassBitmap->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType ); aNmTb.Put( nId, CLASSNAME, pClassBitmap ); // Die Klasse RscSysDepend behandelt die Variablen // "FILE" gesondert nId = aNmTb.Put( "File", VARNAME ); pClassBitmap->SetVariable( nId, &aLangString, NULL, VAR_NORC ); return( pClassBitmap ); } /************************************************************************* |* RscTypCont::InitClassColor() *************************************************************************/ RscTop * RscTypCont::InitClassColor( RscTop * pSuper, RscEnum * pColor ){ Atom nId; RscTop * pClassColor; // Klasse anlegen nId = pHS->getID( "Color" ); pClassColor = new RscClass( nId, RSC_COLOR, pSuper ); pClassColor->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType ); aNmTb.Put( nId, CLASSNAME, pClassColor ); // Variablen anlegen nId = aNmTb.Put( "Red", VARNAME ); pClassColor->SetVariable( nId, &aUShort ); nId = aNmTb.Put( "Green", VARNAME ); pClassColor->SetVariable( nId, &aUShort ); nId = aNmTb.Put( "Blue", VARNAME ); pClassColor->SetVariable( nId, &aUShort ); nId = aNmTb.Put( "Predefine", VARNAME ); pClassColor->SetVariable( nId, pColor ); return( pClassColor ); } /************************************************************************* |* RscTypCont::InitClassImage() *************************************************************************/ RscTop * RscTypCont::InitClassImage( RscTop * pSuper, RscTop * pClassBitmap, RscTop * pClassColor ) { Atom nId; RscTop * pClassImage; // Klasse anlegen nId = pHS->getID( "Image" ); pClassImage = new RscClass( nId, RSC_IMAGE, pSuper ); pClassImage->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType ); aNmTb.Put( nId, CLASSNAME, pClassImage ); // Variablen anlegen nId = aNmTb.Put( "ImageBitmap", VARNAME ); pClassImage->SetVariable( nId, pClassBitmap, NULL, 0, RSC_IMAGE_IMAGEBITMAP ); nId = aNmTb.Put( "MaskBitmap", VARNAME ); pClassImage->SetVariable( nId, pClassBitmap, NULL, 0, RSC_IMAGE_MASKBITMAP ); nId = aNmTb.Put( "MaskColor", VARNAME ); pClassImage->SetVariable( nId, pClassColor, NULL, VAR_SVDYNAMIC, RSC_IMAGE_MASKCOLOR ); return( pClassImage ); } /************************************************************************* |* RscTypCont::InitClassImageList() *************************************************************************/ RscTop * RscTypCont::InitClassImageList( RscTop * pSuper, RscTop * /*pClassBitmap*/, RscTop * pClassColor, RscCont * pStrLst ) { Atom nId; RscTop * pClassImageList; // Klasse anlegen nId = pHS->getID( "ImageList" ); pClassImageList = new RscClass( nId, RSC_IMAGELIST, pSuper ); pClassImageList->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType ); aNmTb.Put( nId, CLASSNAME, pClassImageList ); nId = aNmTb.Put( "Prefix", VARNAME ); pClassImageList->SetVariable( nId, &aString ); nId = aNmTb.Put( "MaskColor", VARNAME ); pClassImageList->SetVariable( nId, pClassColor, NULL, VAR_SVDYNAMIC, RSC_IMAGELIST_MASKCOLOR ); RscCont * pCont = new RscCont( pHS->getID( "sal_uInt16 *" ), RSC_NOTYPE ); pCont->SetTypeClass( &aIdUShort ); aBaseLst.Insert( pCont, LIST_APPEND ); nId = aNmTb.Put( "IdList", VARNAME ); pClassImageList->SetVariable( nId, pCont, NULL, 0, RSC_IMAGELIST_IDLIST ); nId = aNmTb.Put( "FileList", VARNAME ); pClassImageList->SetVariable( nId, pStrLst ); nId = aNmTb.Put( "IdCount", VARNAME ); pClassImageList->SetVariable( nId, &aUShort, NULL, 0, RSC_IMAGELIST_IDCOUNT ); return( pClassImageList ); } /************************************************************************* |* RscTypCont::InitClassWindow() *************************************************************************/ RscTop * RscTypCont::InitClassWindow( RscTop * pSuper, RscEnum * pMapUnit, RscArray * pLangGeo ) { Atom nId; RscTop * pClassWindow; // Klasse anlegen nId = pHS->getID( "Window" ); pClassWindow = new RscClass( nId, RSC_WINDOW, pSuper ); pClassWindow->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassWindow ); // Variablen anlegen { RscFlag * pFlag; RscClient * pClient; Atom nVarId, nDisableId, nOutputSizeId; aBaseLst.Insert( pFlag = new RscFlag( pHS->getID( "FlagWndExtra" ), RSC_NOTYPE ), LIST_APPEND ); // Konstanten in Tabelle stellen nDisableId = pHS->getID( "RSWND_DISABLE" ); SETCONST( pFlag, nDisableId, RSWND_DISABLED ); nOutputSizeId = pHS->getID( "RSWND_OUTPUTSIZE" ); SETCONST( pFlag, nOutputSizeId, RSWND_CLIENTSIZE ); // Variable einfuegen nVarId = aNmTb.Put( "_RscExtraFlags", VARNAME ); pClassWindow->SetVariable( nVarId, pFlag, NULL, VAR_HIDDEN | VAR_NOENUM ); aBaseLst.Insert( pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE, pFlag, nDisableId ), LIST_APPEND ); nId = aNmTb.Put( "Disable", VARNAME ); pClassWindow->SetVariable( nId, pClient, NULL, VAR_NODATAINST, 0, nVarId ); aBaseLst.Insert( pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE, pFlag, nOutputSizeId ), LIST_APPEND ); nId = aNmTb.Put( "OutputSize", VARNAME ); pClassWindow->SetVariable( nId, pClient, NULL, VAR_NODATAINST, 0, nVarId ); } pClassWindow->SetVariable( nWinBitVarId, &aWinBits, NULL, VAR_HIDDEN | VAR_NOENUM ); INS_WINBIT(pClassWindow,Border) INS_WINBIT(pClassWindow,Hide) INS_WINBIT(pClassWindow,ClipChildren) INS_WINBIT(pClassWindow,SVLook) InsWinBit( pClassWindow, "DialogControl", nTabControlId ); nId = aNmTb.Put( "HelpID", VARNAME ); pClassWindow->SetVariable( nId, &aStringLiteral, NULL, 0, WINDOW_HELPID ); nRsc_XYMAPMODEId = nId = aNmTb.Put( "_XYMapMode", VARNAME ); pClassWindow->SetVariable( nId, pMapUnit, NULL, 0, WINDOW_XYMAPMODE ); nRsc_X = nId = aNmTb.Put( "_X", VARNAME ); pClassWindow->SetVariable( nId, &aLong, NULL, 0, WINDOW_X ); nRsc_Y = nId = aNmTb.Put( "_Y", VARNAME ); pClassWindow->SetVariable( nId, &aLong, NULL, 0, WINDOW_Y ); nRsc_WHMAPMODEId = nId = aNmTb.Put( "_WHMapMode", VARNAME ); pClassWindow->SetVariable( nId, pMapUnit, NULL, 0, WINDOW_WHMAPMODE ); nRsc_WIDTH = nId = aNmTb.Put( "_Width", VARNAME ); pClassWindow->SetVariable( nId, &aLong, NULL, 0, WINDOW_WIDTH ); nRsc_HEIGHT = nId = aNmTb.Put( "_Height", VARNAME ); pClassWindow->SetVariable( nId, &aLong, NULL, 0, WINDOW_HEIGHT ); nRsc_DELTALANG = nId = aNmTb.Put( "DeltaLang", VARNAME ); pClassWindow->SetVariable( nId, pLangGeo, NULL, VAR_NORC | VAR_NOENUM); nId = aNmTb.Put( "Text", VARNAME ); pClassWindow->SetVariable( nId, &aLangString, NULL, 0, WINDOW_TEXT ); nId = aNmTb.Put( "HelpText", VARNAME ); pClassWindow->SetVariable( nId, &aLangString, NULL, 0, WINDOW_HELPTEXT ); nId = aNmTb.Put( "QuickHelpText", VARNAME ); pClassWindow->SetVariable( nId, &aLangString, NULL, 0, WINDOW_QUICKTEXT ); nId = aNmTb.Put( "ExtraLong", VARNAME ); pClassWindow->SetVariable( nId, &aLong, NULL, 0, WINDOW_EXTRALONG ); nId = aNmTb.Put( "UniqueId", VARNAME ); pClassWindow->SetVariable( nId, &aString, NULL, 0, WINDOW_UNIQUEID ); // BorderStyle RscEnum* pBorderStyleEnum = new RscEnum( pHS->getID( "WindowBorderStyle" ), RSC_NOTYPE ); aBaseLst.Insert( pBorderStyleEnum, LIST_APPEND ); // Konstanten in Tabelle stellen SETCONST( pBorderStyleEnum, pHS->getID( "WINDOW_BORDER_NORMAL" ), WINDOW_BORDER_NORMAL ); SETCONST( pBorderStyleEnum, pHS->getID( "WINDOW_BORDER_MONO" ), WINDOW_BORDER_MONO ); SETCONST( pBorderStyleEnum, pHS->getID( "WINDOW_BORDER_ACTIVE" ), WINDOW_BORDER_ACTIVE ); SETCONST( pBorderStyleEnum, pHS->getID( "WINDOW_BORDER_DOUBLEOUT" ), WINDOW_BORDER_DOUBLEOUT ); SETCONST( pBorderStyleEnum, pHS->getID( "WINDOW_BORDER_MENU" ), WINDOW_BORDER_MENU ); SETCONST( pBorderStyleEnum, pHS->getID( "WINDOW_BORDER_NOBORDER" ), WINDOW_BORDER_NOBORDER ); // Variable einfuegen nId = aNmTb.Put( "BorderStyle", VARNAME ); pClassWindow->SetVariable( nId, pBorderStyleEnum, NULL, 0, WINDOW_BORDER_STYLE ); return( pClassWindow ); } /************************************************************************* |* RscTypCont::InitClassSystemWindow() *************************************************************************/ RscTop * RscTypCont::InitClassSystemWindow( RscTop * pSuper ) { Atom nId; RscTop * pClassSystemWindow; // Klasse anlegen nId = pHS->getID( "SystemWindow" ); pClassSystemWindow = new RscClass( nId, RSC_SYSWINDOW, pSuper ); pClassSystemWindow->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassSystemWindow ); INS_WINBIT(pClassSystemWindow,Sizeable) INS_WINBIT(pClassSystemWindow,Moveable) InsWinBit( pClassSystemWindow, "Minable", nMinimizeId ); InsWinBit( pClassSystemWindow, "Maxable", nMaximizeId ); INS_WINBIT(pClassSystemWindow,Closeable) INS_WINBIT(pClassSystemWindow,App) INS_WINBIT(pClassSystemWindow,SysWin) return pClassSystemWindow ; } /************************************************************************* |* RscTypCont::InitClassWorkWindow() *************************************************************************/ RscTop * RscTypCont::InitClassWorkWindow( RscTop * pSuper ) { Atom nId; RscTop * pClassWorkWindow; // Klasse anlegen nId = pHS->getID( "WorkWindow" ); pClassWorkWindow = new RscClass( nId, RSC_WORKWIN, pSuper ); pClassWorkWindow->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassWorkWindow ); // Variablen anlegen { Atom nVarId; RscEnum * pShow; aBaseLst.Insert( pShow = new RscEnum( pHS->getID( "EnumShowState" ), RSC_NOTYPE ), LIST_APPEND ); SETCONST( pShow, "SHOW_NORMAL", WORKWIN_SHOWNORMAL ); SETCONST( pShow, "SHOW_MINIMIZED", WORKWIN_SHOWMINIMIZED ); SETCONST( pShow, "SHOW_MAXIMIZED", WORKWIN_SHOWMAXIMIZED ); // Variable einfuegen nVarId = aNmTb.Put( "Show", VARNAME ); pClassWorkWindow->SetVariable( nVarId, pShow, NULL ); } return pClassWorkWindow; } /************************************************************************* |* RscTypCont::InitClassDialogBox() *************************************************************************/ RscTop * RscTypCont::InitClassModalDialog( RscTop * pSuper ) { Atom nId; RscTop * pClassDialog; // Klasse anlegen nId = pHS->getID( "ModalDialog" ); pClassDialog = new RscClass( nId, RSC_MODALDIALOG, pSuper ); pClassDialog->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassDialog ); InsWinBit( pClassDialog, "SysModal", nSysmodalId ); return pClassDialog; } /************************************************************************* |* RscTypCont::InitClassModelessDialog() *************************************************************************/ RscTop * RscTypCont::InitClassModelessDialog( RscTop * pSuper ) { Atom nId; RscTop * pClassDialog; // Klasse anlegen nId = pHS->getID( "ModelessDialog" ); pClassDialog = new RscClass( nId, RSC_MODELESSDIALOG, pSuper ); pClassDialog->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassDialog ); return pClassDialog; } /************************************************************************* |* RscTypCont::InitClassControl() *************************************************************************/ RscTop * RscTypCont::InitClassControl( RscTop * pSuper ) { Atom nId; RscTop * pClassControl; // Klasse anlegen nId = pHS->getID( "Control" ); pClassControl = new RscClass( nId, RSC_CONTROL, pSuper ); pClassControl->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassControl ); InsWinBit( pClassControl, "TabStop", nTabstopId ); INS_WINBIT(pClassControl,Group) return pClassControl; } /************************************************************************* |* RscTypCont::InitClassCheckBox() *************************************************************************/ RscTop * RscTypCont::InitClassCheckBox( RscTop * pSuper ) { Atom nId; RscTop * pClassCheckBox; // Klasse anlegen nId = pHS->getID( "CheckBox" ); pClassCheckBox = new RscClass( nId, RSC_CHECKBOX, pSuper ); pClassCheckBox->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassCheckBox ); // Variablen anlegen INS_WINBIT( pClassCheckBox, WordBreak ) INS_WINBIT( pClassCheckBox, Top ) INS_WINBIT( pClassCheckBox, VCenter ) INS_WINBIT( pClassCheckBox, Bottom ) nId = aNmTb.Put( "Check", VARNAME ); pClassCheckBox->SetVariable( nId, &aBool ); return pClassCheckBox; } /************************************************************************* |* RscTypCont::InitClassPushButton() *************************************************************************/ RscTop * RscTypCont::InitClassPushButton( RscTop * pSuper ) { Atom nId; RscTop * pClassPushButton; // Klasse anlegen nId = pHS->getID( "PushButton" ); pClassPushButton = new RscClass( nId, RSC_PUSHBUTTON, pSuper ); pClassPushButton->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassPushButton ); InsWinBit( pClassPushButton, "DefButton", nDefaultId ); INS_WINBIT( pClassPushButton, Top ) INS_WINBIT( pClassPushButton, VCenter ) INS_WINBIT( pClassPushButton, Bottom ) return pClassPushButton; } /************************************************************************* |* RscTypCont::InitClassTriStateBox() *************************************************************************/ RscTop * RscTypCont::InitClassTriStateBox( RscTop * pSuper, RscEnum * pTriState ) { Atom nId; RscTop * pClassTriStateBox; nId = pHS->getID( "TriStateBox" ); pClassTriStateBox = new RscClass( nId, RSC_TRISTATEBOX, pSuper ); pClassTriStateBox->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassTriStateBox ); // Variablen anlegen nId = aNmTb.Put( "State", VARNAME ); pClassTriStateBox->SetVariable( nId, pTriState ); nId = aNmTb.Put( "TriStateDisable", VARNAME ); pClassTriStateBox->SetVariable( nId, &aBool ); return( pClassTriStateBox ); } /************************************************************************* |* RscTypCont::InitClassMenuButton() *************************************************************************/ RscTop * RscTypCont::InitClassMenuButton( RscTop * pSuper, RscTop * pClassMenu ) { Atom nId; RscTop * pClassMenuButton; nId = pHS->getID( "MenuButton" ); pClassMenuButton = new RscClass( nId, RSC_MENUBUTTON, pSuper ); pClassMenuButton->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassMenuButton ); // Variablen anlegen nId = aNmTb.Put( "ButtonMenu", VARNAME ); pClassMenuButton->SetVariable( nId, pClassMenu, NULL, 0, RSCMENUBUTTON_MENU ); return( pClassMenuButton ); } /************************************************************************* |* RscTypCont::InitClassImageButton() *************************************************************************/ RscTop * RscTypCont::InitClassImageButton( RscTop * pSuper, RscTop * pClassImage, RscEnum * pTriState ) { Atom nId; RscTop * pClassImageButton; // Klasse anlegen nId = pHS->getID( "ImageButton" ); pClassImageButton = new RscClass( nId, RSC_IMAGEBUTTON, pSuper ); pClassImageButton->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassImageButton ); // Variablen anlegen { nId = aNmTb.Put( "ButtonImage", VARNAME ); pClassImageButton->SetVariable( nId, pClassImage, NULL, 0, RSC_IMAGEBUTTON_IMAGE ); } // Variablen anlegen { Atom nVarId; RscEnum * pSymbol; aBaseLst.Insert( pSymbol = new RscEnum( pHS->getID( "EnumSymbolButton" ), RSC_NOTYPE ), LIST_APPEND ); SETCONST( pSymbol, "IMAGEBUTTON_DONTKNOW", SYMBOL_DONTKNOW ); SETCONST( pSymbol, "IMAGEBUTTON_IMAGE", SYMBOL_IMAGE ); SETCONST( pSymbol, "IMAGEBUTTON_ARROW_UP", SYMBOL_ARROW_UP ); SETCONST( pSymbol, "IMAGEBUTTON_ARROW_DOWN", SYMBOL_ARROW_DOWN ); SETCONST( pSymbol, "IMAGEBUTTON_ARROW_LEFT", SYMBOL_ARROW_LEFT ); SETCONST( pSymbol, "IMAGEBUTTON_ARROW_RIGHT", SYMBOL_ARROW_RIGHT ); SETCONST( pSymbol, "IMAGEBUTTON_SPIN_UP", SYMBOL_SPIN_UP ); SETCONST( pSymbol, "IMAGEBUTTON_SPIN_DOWN", SYMBOL_SPIN_DOWN ); SETCONST( pSymbol, "IMAGEBUTTON_SPIN_LEFT", SYMBOL_SPIN_LEFT ); SETCONST( pSymbol, "IMAGEBUTTON_SPIN_RIGHT", SYMBOL_SPIN_RIGHT ); SETCONST( pSymbol, "IMAGEBUTTON_FIRST", SYMBOL_FIRST ); SETCONST( pSymbol, "IMAGEBUTTON_LAST", SYMBOL_LAST ); SETCONST( pSymbol, "IMAGEBUTTON_PREV", SYMBOL_PREV ); SETCONST( pSymbol, "IMAGEBUTTON_NEXT", SYMBOL_NEXT ); SETCONST( pSymbol, "IMAGEBUTTON_PAGEUP", SYMBOL_PAGEUP ); SETCONST( pSymbol, "IMAGEBUTTON_PAGEDOWN", SYMBOL_PAGEDOWN ); SETCONST( pSymbol, "IMAGEBUTTON_PLAY", SYMBOL_PLAY ); SETCONST( pSymbol, "IMAGEBUTTON_REVERSEPLAY", SYMBOL_REVERSEPLAY ); SETCONST( pSymbol, "IMAGEBUTTON_STOP", SYMBOL_STOP ); SETCONST( pSymbol, "IMAGEBUTTON_PAUSE", SYMBOL_PAUSE ); SETCONST( pSymbol, "IMAGEBUTTON_WINDSTART", SYMBOL_WINDSTART ); SETCONST( pSymbol, "IMAGEBUTTON_WINDEND", SYMBOL_WINDEND ); SETCONST( pSymbol, "IMAGEBUTTON_WINDBACKWARD", SYMBOL_WINDBACKWARD ); SETCONST( pSymbol, "IMAGEBUTTON_WINDFORWARD", SYMBOL_WINDFORWARD ); // Variable einfuegen nVarId = aNmTb.Put( "Symbol", VARNAME ); pClassImageButton->SetVariable( nVarId, pSymbol, NULL, 0, RSC_IMAGEBUTTON_SYMBOL ); } nId = aNmTb.Put( "State", VARNAME ); pClassImageButton->SetVariable( nId, pTriState, NULL, 0, RSC_IMAGEBUTTON_STATE ); INS_WINBIT(pClassImageButton,Repeat) INS_WINBIT(pClassImageButton,SmallStyle) INS_WINBIT(pClassImageButton,RectStyle) return pClassImageButton; } /************************************************************************* |* RscTypCont::InitClassEdit() *************************************************************************/ RscTop * RscTypCont::InitClassEdit( RscTop * pSuper ) { Atom nId; RscTop * pClassEdit; // Klasse anlegen nId = pHS->getID( "Edit" ); pClassEdit = new RscClass( nId, RSC_EDIT, pSuper ); pClassEdit->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassEdit ); INS_WINBIT(pClassEdit,Left) INS_WINBIT(pClassEdit,Center) INS_WINBIT(pClassEdit,Right) INS_WINBIT(pClassEdit,PassWord) INS_WINBIT(pClassEdit,ReadOnly) nId = aNmTb.Put( "MaxTextLength", VARNAME ); pClassEdit->SetVariable( nId, &aUShort ); return pClassEdit; } /************************************************************************* |* RscTypCont::InitClassMultiLineedit() *************************************************************************/ RscTop * RscTypCont::InitClassMultiLineEdit( RscTop * pSuper ) { Atom nId; RscTop * pClassMultiLineEdit; // Klasse anlegen nId = pHS->getID( "MultiLineEdit" ); pClassMultiLineEdit = new RscClass( nId, RSC_MULTILINEEDIT, pSuper ); pClassMultiLineEdit->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassMultiLineEdit ); INS_WINBIT( pClassMultiLineEdit, HScroll ); INS_WINBIT( pClassMultiLineEdit, VScroll ); INS_WINBIT( pClassMultiLineEdit, IgnoreTab ); INS_WINBIT( pClassMultiLineEdit, AutoVScroll ) return pClassMultiLineEdit; } /************************************************************************* |* RscTypCont::InitClassScrollBar() *************************************************************************/ RscTop * RscTypCont::InitClassScrollBar( RscTop * pSuper ) { Atom nId; RscTop * pClassScrollBar; // Klasse anlegen nId = pHS->getID( "ScrollBar" ); pClassScrollBar = new RscClass( nId, RSC_SCROLLBAR, pSuper ); pClassScrollBar->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassScrollBar ); // Variablen anlegen nId = aNmTb.Put( "MinPos", VARNAME ); pClassScrollBar->SetVariable( nId, &aShort ); { RSCINST aDfltI; aDfltI = aShort.Create( NULL, RSCINST(), sal_False ); aDfltI.pClass->SetNumber( aDfltI, 100 ); // aDfltI.pClass->MakeDefault( aDfltI ); nId = aNmTb.Put( "MaxPos", VARNAME ); pClassScrollBar->SetVariable( nId, &aShort, &aDfltI ); } nId = aNmTb.Put( "ThumbPos", VARNAME ); pClassScrollBar->SetVariable( nId, &aShort ); { RSCINST aDfltI; aDfltI = aShort.Create( NULL, RSCINST(), sal_False ); aDfltI.pClass->SetNumber( aDfltI, 1 ); // aDfltI.pClass->MakeDefault( aDfltI ); nId = aNmTb.Put( "PageSize", VARNAME); pClassScrollBar->SetVariable( nId, &aShort, &aDfltI ); } { RSCINST aDfltI; aDfltI = aShort.Create( NULL, RSCINST(), sal_False ); aDfltI.pClass->SetNumber( aDfltI, 1 ); // aDfltI.pClass->MakeDefault( aDfltI ); nId = aNmTb.Put( "LineSize", VARNAME ); pClassScrollBar->SetVariable( nId, &aShort, &aDfltI ); } nId = aNmTb.Put( "VisibleSize", VARNAME ); pClassScrollBar->SetVariable( nId, &aShort ); INS_WINBIT( pClassScrollBar, HScroll ); INS_WINBIT( pClassScrollBar, VScroll ); INS_WINBIT( pClassScrollBar, Drag ) return pClassScrollBar; } /************************************************************************* |* RscTypCont::InitClassListBox() *************************************************************************/ RscTop * RscTypCont::InitClassListBox( RscTop * pSuper, RscArray * pStrLst ) { Atom nId; RscTop * pClassListBox; // Klasse anlegen nId = pHS->getID( "ListBox" ); pClassListBox = new RscClass( nId, RSC_LISTBOX, pSuper ); pClassListBox->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassListBox ); // Variablen anlegen INS_WINBIT(pClassListBox,Sort) INS_WINBIT(pClassListBox,DropDown) INS_WINBIT(pClassListBox,HScroll); INS_WINBIT(pClassListBox,VScroll); INS_WINBIT(pClassListBox,AutoSize) INS_WINBIT(pClassListBox,AutoHScroll) INS_WINBIT(pClassListBox,DDExtraWidth) { RSCINST aDflt = aUShort.Create( NULL, RSCINST(), sal_False ); aDflt.pClass->SetNumber( aDflt, (sal_uInt16)0xFFFF ); nId = aNmTb.Put( "CurPos", VARNAME ); pClassListBox->SetVariable( nId, &aUShort, &aDflt ); } nId = aNmTb.Put( "StringList", VARNAME ); pClassListBox->SetVariable( nId, pStrLst ); return pClassListBox; } /************************************************************************* |* RscTypCont::InitClassMultiListBox() *************************************************************************/ RscTop * RscTypCont::InitClassMultiListBox( RscTop * pSuper ) { Atom nId; RscTop * pClassMultiListBox; // Klasse anlegen nId = pHS->getID( "MultiListBox" ); pClassMultiListBox = new RscClass( nId, RSC_MULTILISTBOX, pSuper ); pClassMultiListBox->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassMultiListBox ); INS_WINBIT(pClassMultiListBox,SimpleMode) return pClassMultiListBox; } /************************************************************************* |* RscTypCont::InitClassComboBox() *************************************************************************/ RscTop * RscTypCont::InitClassComboBox( RscTop * pSuper, RscArray * pStrLst ) { Atom nId; RscTop * pClassComboBox; // Klasse anlegen nId = pHS->getID( "ComboBox" ); pClassComboBox = new RscClass( nId, RSC_COMBOBOX, pSuper ); pClassComboBox->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassComboBox ); // Variablen anlegen INS_WINBIT(pClassComboBox,DropDown) INS_WINBIT(pClassComboBox,Sort) INS_WINBIT(pClassComboBox,HScroll); INS_WINBIT(pClassComboBox,VScroll); INS_WINBIT(pClassComboBox,AutoSize) INS_WINBIT(pClassComboBox,AutoHScroll) INS_WINBIT(pClassComboBox,DDExtraWidth) nId = aNmTb.Put( "StringList", VARNAME ); pClassComboBox->SetVariable( nId, pStrLst ); return pClassComboBox; } /************************************************************************* |* RscTypCont::InitClassFixedText() *************************************************************************/ RscTop * RscTypCont::InitClassFixedText( RscTop * pSuper ) { Atom nId; RscTop * pClassFixedText; // Klasse anlegen nId = pHS->getID( "FixedText" ); pClassFixedText = new RscClass( nId, RSC_TEXT, pSuper ); pClassFixedText->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassFixedText ); // Variablen anlegen INS_WINBIT(pClassFixedText,Left) INS_WINBIT(pClassFixedText,Center) INS_WINBIT(pClassFixedText,Right) INS_WINBIT(pClassFixedText,WordBreak) INS_WINBIT(pClassFixedText,LeftLabel) INS_WINBIT(pClassFixedText,NoLabel) INS_WINBIT(pClassFixedText,Top) INS_WINBIT(pClassFixedText,VCenter) INS_WINBIT(pClassFixedText,Bottom) return pClassFixedText; } /************************************************************************* |* RscTypCont::InitClassFixedBitmap() *************************************************************************/ RscTop * RscTypCont::InitClassFixedBitmap( RscTop * pSuper, RscTop * pClassBitmap ) { Atom nId; RscTop * pClassFixedBitmap; // Klasse anlegen nId = pHS->getID( "FixedBitmap" ); pClassFixedBitmap = new RscClass( nId, RSC_FIXEDBITMAP, pSuper ); pClassFixedBitmap->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassFixedBitmap ); INS_WINBIT(pClassFixedBitmap,Scale) // Variablen anlegen nId = aNmTb.Put( "Fixed", VARNAME ); pClassFixedBitmap->SetVariable( nId, pClassBitmap, 0, 0, RSC_FIXEDBITMAP_BITMAP ); return pClassFixedBitmap; } /************************************************************************* |* RscTypCont::InitClassFixedImage() *************************************************************************/ RscTop * RscTypCont::InitClassFixedImage( RscTop * pSuper, RscTop * pClassImage ) { Atom nId; RscTop * pClassFixedImage; // Klasse anlegen nId = pHS->getID( "FixedImage" ); pClassFixedImage = new RscClass( nId, RSC_FIXEDIMAGE, pSuper ); pClassFixedImage->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassFixedImage ); // Variablen anlegen nId = aNmTb.Put( "Fixed", VARNAME ); pClassFixedImage->SetVariable( nId, pClassImage, 0, 0, RSC_FIXEDIMAGE_IMAGE ); return pClassFixedImage; } /************************************************************************* |* RscTypCont::InitClassImageRadioButton() *************************************************************************/ RscTop * RscTypCont::InitClassRadioButton( RscTop * pSuper ) { Atom nId; RscTop * pClassRadioButton; // Klasse anlegen nId = pHS->getID( "RadioButton" ); pClassRadioButton = new RscClass( nId, RSC_RADIOBUTTON, pSuper ); pClassRadioButton->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassRadioButton ); // Variablen anlegen INS_WINBIT( pClassRadioButton, WordBreak ) INS_WINBIT( pClassRadioButton, Top ) INS_WINBIT( pClassRadioButton, VCenter ) INS_WINBIT( pClassRadioButton, Bottom ) nId = aNmTb.Put( "Check", VARNAME ); pClassRadioButton->SetVariable( nId, &aBool ); return pClassRadioButton; } /************************************************************************* |* RscTypCont::InitClassImageRadioButton() *************************************************************************/ RscTop * RscTypCont::InitClassImageRadioButton( RscTop * pSuper, RscTop * pClassImage ) { Atom nId; RscTop * pClassImageRadioButton; // Klasse anlegen nId = pHS->getID( "ImageRadioButton" ); pClassImageRadioButton = new RscClass( nId, RSC_IMAGERADIOBUTTON, pSuper ); pClassImageRadioButton->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassImageRadioButton ); // Variablen anlegen INS_WINBIT(pClassImageRadioButton,TopImage) nId = aNmTb.Put( "RadioButtonImage", VARNAME ); pClassImageRadioButton->SetVariable( nId, pClassImage, 0, 0, RSC_IMAGERADIOBUTTON_IMAGE ); return pClassImageRadioButton; } /************************************************************************* |* RscTypCont::InitClassKeyCode() *************************************************************************/ RscTop * RscTypCont::InitClassKeyCode( RscTop * pSuper, RscEnum * pKey ) { Atom nId; RscTop * pClassKeyCode; // Klasse anlegen nId = pHS->getID( "KeyCode" ); pClassKeyCode = new RscClass( nId, RSC_KEYCODE, pSuper ); aNmTb.Put( nId, CLASSNAME, pClassKeyCode ); // Variablen anlegen nId = aNmTb.Put( "Code", VARNAME ); pClassKeyCode->SetVariable( nId, pKey ); { RscFlag * pFlag; RscClient * pClient; Atom nVarId, nShiftId, nMod1Id, nMod2Id; aBaseLst.Insert( pFlag = new RscFlag( pHS->getID( "FlagKeyModifier" ), RSC_NOTYPE ), LIST_APPEND ); // Konstanten in Tabelle stellen nShiftId = pHS->getID( "KEY_SHIFT" ); SETCONST( pFlag, nShiftId, KEY_SHIFT ); nMod1Id = pHS->getID( "KEY_MOD1" ); SETCONST( pFlag, nMod1Id, KEY_MOD1 ); nMod2Id = pHS->getID( "KEY_MOD2" ); SETCONST( pFlag, nMod2Id, KEY_MOD2 ); // Variable einfuegen nVarId = aNmTb.Put( "_ModifierFlags", VARNAME ); pClassKeyCode->SetVariable( nVarId, pFlag, NULL, VAR_HIDDEN | VAR_NOENUM ); // Clientvariablen einfuegen aBaseLst.Insert( pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE, pFlag, nShiftId ), LIST_APPEND ); nId = aNmTb.Put( "Shift", VARNAME ); pClassKeyCode->SetVariable( nId, pClient, NULL, VAR_NODATAINST, 0, nVarId ); aBaseLst.Insert( pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE, pFlag, nMod1Id ), LIST_APPEND ); nId = aNmTb.Put( "Modifier1", VARNAME ); pClassKeyCode->SetVariable( nId, pClient, NULL, VAR_NODATAINST, 0, nVarId ); aBaseLst.Insert( pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE, pFlag, nMod2Id ), LIST_APPEND ); nId = aNmTb.Put( "Modifier2", VARNAME ); pClassKeyCode->SetVariable( nId, pClient, NULL, VAR_NODATAINST, 0, nVarId ); } { Atom nVarId; RscEnum * pKeyFunc; aBaseLst.Insert( pKeyFunc = new RscEnum( pHS->getID( "EnumKeyFunc" ), RSC_NOTYPE ), LIST_APPEND ); SETCONST( pKeyFunc, "KEYFUNC_DONTKNOW", KEYFUNC_DONTKNOW ); SETCONST( pKeyFunc, "KEYFUNC_NEW", KEYFUNC_NEW ); SETCONST( pKeyFunc, "KEYFUNC_OPEN", KEYFUNC_OPEN ); SETCONST( pKeyFunc, "KEYFUNC_SAVE", KEYFUNC_SAVE ); SETCONST( pKeyFunc, "KEYFUNC_SAVEAS", KEYFUNC_SAVEAS ); SETCONST( pKeyFunc, "KEYFUNC_PRINT", KEYFUNC_PRINT ); SETCONST( pKeyFunc, "KEYFUNC_CLOSE", KEYFUNC_CLOSE ); SETCONST( pKeyFunc, "KEYFUNC_QUIT", KEYFUNC_QUIT ); SETCONST( pKeyFunc, "KEYFUNC_CUT", KEYFUNC_CUT ); SETCONST( pKeyFunc, "KEYFUNC_COPY", KEYFUNC_COPY ); SETCONST( pKeyFunc, "KEYFUNC_PASTE", KEYFUNC_PASTE ); SETCONST( pKeyFunc, "KEYFUNC_UNDO", KEYFUNC_UNDO ); SETCONST( pKeyFunc, "KEYFUNC_REDO", KEYFUNC_REDO ); SETCONST( pKeyFunc, "KEYFUNC_DELETE", KEYFUNC_DELETE ); SETCONST( pKeyFunc, "KEYFUNC_REPEAT", KEYFUNC_REPEAT ); SETCONST( pKeyFunc, "KEYFUNC_FIND", KEYFUNC_FIND ); SETCONST( pKeyFunc, "KEYFUNC_PROPERTIES", KEYFUNC_PROPERTIES ); SETCONST( pKeyFunc, "KEYFUNC_FRONT", KEYFUNC_FRONT ); SETCONST( pKeyFunc, "KEYFUNC_FINDBACKWARD", KEYFUNC_FINDBACKWARD ); // Variable einfuegen nVarId = aNmTb.Put( "Function", VARNAME ); pClassKeyCode->SetVariable( nVarId, pKeyFunc, NULL ); } return pClassKeyCode; } /************************************************************************* |* RscTypCont::InitClassAccelItem() *************************************************************************/ RscTop * RscTypCont::InitClassAccelItem( RscTop * pSuper, RscTop * pClassKeyCode ) { Atom nId; RscTop * pClassAccelItem; // Klasse anlegen nId = pHS->getID( "AcceleratorItem" ); pClassAccelItem = new RscClass( nId, RSC_ACCELITEM, pSuper ); aNmTb.Put( nId, CLASSNAME, pClassAccelItem ); // Variablen anlegen nId = aNmTb.Put( "Identifier", VARNAME ); pClassAccelItem->SetVariable( nId, &aIdNoZeroUShort ); nId = aNmTb.Put( "Disable", VARNAME ); pClassAccelItem->SetVariable( nId, &aBool ); nId = aNmTb.Put( "Key", VARNAME ); pClassAccelItem->SetVariable( nId, pClassKeyCode, NULL, 0, ACCELITEM_KEY ); return pClassAccelItem; } /************************************************************************* |* RscTypCont::InitClassAccelm() *************************************************************************/ RscTop * RscTypCont::InitClassAccel( RscTop * pSuper, RscTop * pClassAccelItem ) { Atom nId; RscTop * pClassAccel; // Klasse anlegen nId = pHS->getID( "Accelerator" ); pClassAccel = new RscClass( nId, RSC_ACCEL, pSuper ); pClassAccel->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType ); aNmTb.Put( nId, CLASSNAME, pClassAccel ); // Variablen anlegen nId = aNmTb.Put( "HelpText", VARNAME ); pClassAccel->SetVariable( nId, &aLangString ); { RscCont * pCont; aBaseLst.Insert( pCont = new RscCont( pHS->getID( "ContAcceleratorKey" ), RSC_NOTYPE ), LIST_APPEND ); pCont->SetTypeClass( pClassAccelItem ); nId = aNmTb.Put( "ItemList", VARNAME ); pClassAccel->SetVariable( nId, pCont ); } return pClassAccel; } /************************************************************************* |* RscTypCont::InitClassMenuItem() *************************************************************************/ RscTop * RscTypCont::InitClassMenuItem( RscTop * pSuper, RscTop * pClassBitmap, RscTop * pClassKeyCode ) { Atom nId; RscTop * pClassMenuItem; // Klasse anlegen nId = pHS->getID( "MenuItem" ); pClassMenuItem = new RscClass( nId, RSC_MENUITEM, pSuper ); aNmTb.Put( nId, CLASSNAME, pClassMenuItem ); // Variablen anlegen nId = aNmTb.Put( "Separator", VARNAME ); pClassMenuItem->SetVariable( nId, &aBool, NULL, 0, RSC_MENUITEM_SEPARATOR ); nId = aNmTb.Put( "Identifier", VARNAME ); pClassMenuItem->SetVariable( nId, &aIdNoZeroUShort, NULL, 0, RSC_MENUITEM_ID ); { RscFlag * pFlag; RscClient * pClient; Atom nVarId, nAutoCheckId, nRadioCheckId; Atom nCheckableId, nAboutId, nHelpId; aBaseLst.Insert( pFlag = new RscFlag( pHS->getID( "FlagMenuState" ), RSC_NOTYPE ), LIST_APPEND ); // Konstanten in Tabelle stellen nCheckableId = pHS->getID( "MIB_CHECKABLE" ); SETCONST( pFlag, nCheckableId, MIB_CHECKABLE ); nAutoCheckId = pHS->getID( "MIB_AUTOCHECK" ); SETCONST( pFlag, nAutoCheckId, MIB_AUTOCHECK ); nRadioCheckId = pHS->getID( "MIB_RADIOCHECK" ); SETCONST( pFlag, nRadioCheckId, MIB_RADIOCHECK ); nAboutId = pHS->getID( "MIB_ABOUT" ); SETCONST( pFlag, nAboutId, MIB_ABOUT ); nHelpId = pHS->getID( "MIB_HELP" ); SETCONST( pFlag, nHelpId, MIB_HELP ); // Variable einfuegen nVarId = aNmTb.Put( "_MenuItemFlags", VARNAME ); pClassMenuItem->SetVariable( nVarId, pFlag, NULL, VAR_HIDDEN | VAR_NOENUM, RSC_MENUITEM_STATUS ); // Clientvariablen einfuegen aBaseLst.Insert( pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE, pFlag, nCheckableId ), LIST_APPEND ); nId = aNmTb.Put( "Checkable", VARNAME ); pClassMenuItem->SetVariable( nId, pClient, NULL, VAR_NODATAINST, 0, nVarId ); aBaseLst.Insert( pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE, pFlag, nAutoCheckId ), LIST_APPEND ); nId = aNmTb.Put( "AutoCheck", VARNAME ); pClassMenuItem->SetVariable( nId, pClient, NULL, VAR_NODATAINST, 0, nVarId ); aBaseLst.Insert( pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE, pFlag, nRadioCheckId ), LIST_APPEND ); nId = aNmTb.Put( "RadioCheck", VARNAME ); pClassMenuItem->SetVariable( nId, pClient, NULL, VAR_NODATAINST, 0, nVarId ); aBaseLst.Insert( pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE, pFlag, nAboutId ), LIST_APPEND ); nId = aNmTb.Put( "About", VARNAME ); pClassMenuItem->SetVariable( nId, pClient, NULL, VAR_NODATAINST, 0, nVarId ); aBaseLst.Insert( pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE, pFlag, nHelpId ), LIST_APPEND ); nId = aNmTb.Put( "Help", VARNAME ); pClassMenuItem->SetVariable( nId, pClient, NULL, VAR_NODATAINST, 0, nVarId ); } nId = aNmTb.Put( "Text", VARNAME ); pClassMenuItem->SetVariable( nId, &aLangString, NULL, 0, RSC_MENUITEM_TEXT ); nId = aNmTb.Put( "ItemBitmap", VARNAME ); pClassMenuItem->SetVariable( nId, pClassBitmap, NULL, 0, RSC_MENUITEM_BITMAP ); nId = aNmTb.Put( "HelpText", VARNAME ); pClassMenuItem->SetVariable( nId, &aLangString, NULL, 0, RSC_MENUITEM_HELPTEXT ); nId = aNmTb.Put( "HelpID", VARNAME ); pClassMenuItem->SetVariable( nId, &aStringLiteral, NULL, 0, RSC_MENUITEM_HELPID ); nId = aNmTb.Put( "AccelKey", VARNAME ); pClassMenuItem->SetVariable( nId, pClassKeyCode, NULL, 0, RSC_MENUITEM_KEYCODE ); nId = aNmTb.Put( "Check", VARNAME ); pClassMenuItem->SetVariable( nId, &aBool, NULL, 0, RSC_MENUITEM_CHECKED ); nId = aNmTb.Put( "Disable", VARNAME ); pClassMenuItem->SetVariable( nId, &aBool, NULL, 0, RSC_MENUITEM_DISABLE ); nId = aNmTb.Put( "Command", VARNAME ); pClassMenuItem->SetVariable( nId, &aString, NULL, 0, RSC_MENUITEM_COMMAND ); return pClassMenuItem; } /************************************************************************* |* RscTypCont::InitClassMenu() *************************************************************************/ RscTop * RscTypCont::InitClassMenu( RscTop * pSuper, RscTop * pClassMenuItem ) { Atom nId; RscTop * pClassMenu; // Klasse anlegen nId = pHS->getID( "Menu" ); pClassMenu = new RscClass( nId, RSC_MENU, pSuper ); pClassMenu->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType ); aNmTb.Put( nId, CLASSNAME, pClassMenu ); // Variablen anlegen { RscCont * pCont; aBaseLst.Insert( pCont = new RscCont( pHS->getID( "ContMenuItem" ), RSC_NOTYPE ), LIST_APPEND ); pCont->SetTypeClass( pClassMenuItem ); nId = aNmTb.Put( "ItemList", VARNAME ); pClassMenu->SetVariable( nId, pCont, NULL, 0, RSC_MENU_ITEMS ); } nId = aNmTb.Put( "Text", VARNAME ); pClassMenu->SetVariable( nId, &aLangString, NULL, 0, RSC_MENU_TEXT ); nId = aNmTb.Put( "DefaultItemId", VARNAME ); pClassMenu->SetVariable( nId, &aIdUShort, NULL, 0, RSC_MENU_DEFAULTITEMID ); return pClassMenu; } /************************************************************************* |* RscTypCont::InitClassMessageBox() *************************************************************************/ RscTop * RscTypCont::InitClassMessBox( RscTop * pSuper, RscEnum * pMessButtons, RscEnum * pMessDefButton ) { Atom nId; RscTop * pClassMessBox; // Klasse anlegen nId = pHS->getID( "MessBox" ); pClassMessBox = new RscClass( nId, RSC_MESSBOX, pSuper ); pClassMessBox->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassMessBox ); // Variablen anlegen nId = aNmTb.Put( "Buttons", VARNAME ); pClassMessBox->SetVariable( nId, pMessButtons ); nId = aNmTb.Put( "DefButton", VARNAME ); pClassMessBox->SetVariable( nId, pMessDefButton ); nId = aNmTb.Put( "HelpID", VARNAME ); pClassMessBox->SetVariable( nId, &aStringLiteral ); nId = aNmTb.Put( "SysModal", VARNAME ); pClassMessBox->SetVariable( nId, &aBool ); nId = aNmTb.Put( "Title", VARNAME ); pClassMessBox->SetVariable( nId, &aLangString ); nId = aNmTb.Put( "Message", VARNAME ); pClassMessBox->SetVariable( nId, &aLangString ); nId = aNmTb.Put( "HelpText", VARNAME ); pClassMessBox->SetVariable( nId, &aLangString ); return pClassMessBox; } /************************************************************************* |* RscTypCont::InitClassSplitter() *************************************************************************/ RscTop * RscTypCont::InitClassSplitter( RscTop * pSuper ) { Atom nId; RscTop * pClassSplitter; // Klasse anlegen nId = pHS->getID( "Splitter" ); pClassSplitter = new RscClass( nId, RSC_SPLITTER, pSuper ); pClassSplitter->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassSplitter ); INS_WINBIT(pClassSplitter,HScroll); INS_WINBIT(pClassSplitter,VScroll); return pClassSplitter; } /************************************************************************* |* RscTypCont::InitClassSplitWindow() *************************************************************************/ RscTop * RscTypCont::InitClassSplitWindow( RscTop * pSuper ) { Atom nId; RscTop * pClassSplitWindow; // Klasse anlegen nId = pHS->getID( "SplitWindow" ); pClassSplitWindow = new RscClass( nId, RSC_SPLITWINDOW, pSuper ); pClassSplitWindow->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassSplitWindow ); INS_WINBIT(pClassSplitWindow,Sizeable) INS_WINBIT(pClassSplitWindow,NoSplitDraw) return pClassSplitWindow; } /************************************************************************* |* RscTypCont::InitClassTime() *************************************************************************/ RscTop * RscTypCont::InitClassTime( RscTop * pSuper ) { Atom nId; RscTop * pClassTime; // Klasse anlegen nId = pHS->getID( "Time" ); pClassTime = new RscClass( nId, RSC_TIME, pSuper ); pClassTime->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType ); aNmTb.Put( nId, CLASSNAME, pClassTime ); // Variablen anlegen nId = aNmTb.Put( "Hour", VARNAME ); pClassTime->SetVariable( nId, &a0to23Short, NULL, 0, TIME_HOUR ); nId = aNmTb.Put( "Minute", VARNAME ); pClassTime->SetVariable( nId, &a0to59Short, NULL, 0, TIME_MINUTE ); nId = aNmTb.Put( "Second", VARNAME ); pClassTime->SetVariable( nId, &a0to59Short, NULL, 0, TIME_SECOND ); nId = aNmTb.Put( "Sec100", VARNAME ); // weiss noch nich pClassTime->SetVariable( nId, &a0to99Short, NULL, 0, TIME_SEC100 ); return pClassTime; } /************************************************************************* |* RscTypCont::InitClassDate() *************************************************************************/ RscTop * RscTypCont::InitClassDate( RscTop * pSuper ) { Atom nId; RscTop * pClassDate; // Klasse anlegen nId = pHS->getID( "Date" ); pClassDate = new RscClass( nId, RSC_DATE, pSuper ); pClassDate->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType ); aNmTb.Put( nId, CLASSNAME, pClassDate ); // Variablen anlegen nId = aNmTb.Put( "Year", VARNAME ); pClassDate->SetVariable( nId, &a0to9999Short, NULL, 0, DATE_YEAR ); nId = aNmTb.Put( "Month", VARNAME ); pClassDate->SetVariable( nId, &a1to12Short, NULL, 0, DATE_MONTH ); nId = aNmTb.Put( "Day", VARNAME ); pClassDate->SetVariable( nId, &a1to31Short, NULL, 0, DATE_DAY ); return pClassDate; } /************************************************************************* |* RscTypCont::InitClassPatternFormatter() *************************************************************************/ RscTop * RscTypCont::InitClassPatternFormatter( RscTop * pSuper ) { Atom nId; RscTop * pClassPattern; // Klasse anlegen nId = pHS->getID( "PatternFormatter" ); pClassPattern = new RscClass( nId, RSC_NOTYPE, pSuper ); pClassPattern->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType ); // Variablen anlegen nId = aNmTb.Put( "StrictFormat", VARNAME ); pClassPattern->SetVariable( nId, &aBool, NULL, 0, PATTERNFORMATTER_STRICTFORMAT ); nId = aNmTb.Put( "EditMask", VARNAME ); pClassPattern->SetVariable( nId, &aLangString, NULL, 0, PATTERNFORMATTER_EDITMASK ); nId = aNmTb.Put( "LiteralMask", VARNAME ); pClassPattern->SetVariable( nId, &aLangString, NULL, 0, PATTERNFORMATTER_LITTERALMASK ); return pClassPattern; } /************************************************************************* |* RscTypCont::InitClassNumericFormatter() *************************************************************************/ RscTop * RscTypCont::InitClassNumericFormatter( RscTop * pSuper ) { Atom nId; RscTop * pClassNumeric; // Klasse anlegen nId = pHS->getID( "NumericFormatter" ); pClassNumeric = new RscClass( nId, RSC_NOTYPE, pSuper ); pClassNumeric->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType ); // Variablen anlegen nId = aNmTb.Put( "Minimum", VARNAME ); pClassNumeric->SetVariable( nId, &aIdLong, NULL, 0, NUMERICFORMATTER_MIN ); nId = aNmTb.Put( "Maximum", VARNAME ); pClassNumeric->SetVariable( nId, &aIdLong, NULL, 0, NUMERICFORMATTER_MAX ); nId = aNmTb.Put( "StrictFormat", VARNAME ); pClassNumeric->SetVariable( nId, &aBool, NULL, 0, NUMERICFORMATTER_STRICTFORMAT ); nId = aNmTb.Put( "DecimalDigits", VARNAME ); pClassNumeric->SetVariable( nId, &aUShort, NULL, 0, NUMERICFORMATTER_DECIMALDIGITS ); nId = aNmTb.Put( "Value", VARNAME ); pClassNumeric->SetVariable( nId, &aIdLong, NULL, 0, NUMERICFORMATTER_VALUE ); nId = aNmTb.Put( "NoThousandSep", VARNAME ); pClassNumeric->SetVariable( nId, &aBool, NULL, 0, NUMERICFORMATTER_NOTHOUSANDSEP ); return pClassNumeric; } /************************************************************************* |* RscTypCont::InitClassMetricFormatter() *************************************************************************/ RscTop * RscTypCont::InitClassMetricFormatter( RscTop * pSuper, RscEnum * pFieldUnits ) { Atom nId; RscTop * pClassMetric; // Klasse anlegen nId = pHS->getID( "MetricFormatter" ); pClassMetric = new RscClass( nId, RSC_NOTYPE, pSuper ); pClassMetric->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType ); // Variablen anlegen nId = aNmTb.Put( "Unit", VARNAME ); pClassMetric->SetVariable( nId, pFieldUnits, NULL, 0, METRICFORMATTER_UNIT ); nId = aNmTb.Put( "CustomUnitText", VARNAME ); pClassMetric->SetVariable( nId, &aLangString, NULL, 0, METRICFORMATTER_CUSTOMUNITTEXT ); return pClassMetric; } /************************************************************************* |* RscTypCont::InitClassCurrencyFormatter() *************************************************************************/ RscTop * RscTypCont::InitClassCurrencyFormatter ( RscTop * pSuper, RscEnum * /* pFieldUnits */) { Atom nId; RscTop * pClassCurrency; // Klasse anlegen nId = pHS->getID( "CurrencyFormatter" ); pClassCurrency = new RscClass( nId, RSC_NOTYPE, pSuper ); pClassCurrency->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType ); return pClassCurrency; } /************************************************************************* |* RscTypCont::InitClassDateFormatter() *************************************************************************/ RscTop * RscTypCont::InitClassDateFormatter( RscTop * pSuper, RscTop * pClassDate ) { Atom nId; RscTop * pClassDateF; // Klasse anlegen nId = pHS->getID( "DateFormatter" ); pClassDateF = new RscClass( nId, RSC_NOTYPE, pSuper ); pClassDateF->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType ); // Variablen anlegen nId = aNmTb.Put( "Minimum", VARNAME ); pClassDateF->SetVariable( nId, pClassDate, NULL, 0, DATEFORMATTER_MIN ); nId = aNmTb.Put( "Maximum", VARNAME ); pClassDateF->SetVariable( nId, pClassDate, NULL, 0, DATEFORMATTER_MAX ); nId = aNmTb.Put( "LongFormat", VARNAME ); pClassDateF->SetVariable( nId, &aBool, NULL, 0, DATEFORMATTER_LONGFORMAT ); nId = aNmTb.Put( "StrictFormat", VARNAME ); pClassDateF->SetVariable( nId, &aBool, NULL, 0, DATEFORMATTER_STRICTFORMAT ); nId = aNmTb.Put( "Value", VARNAME ); pClassDateF->SetVariable( nId, pClassDate, NULL, 0, DATEFORMATTER_VALUE ); return pClassDateF; } /************************************************************************* |* RscTypCont::InitClassTimeFormatter() *************************************************************************/ RscTop * RscTypCont::InitClassTimeFormatter( RscTop * pSuper, RscTop * pClassTime, RscEnum * pTimeFieldFormat ) { Atom nId; RscTop * pClassTimeF; // Klasse anlegen nId = pHS->getID( "TimeFormatter" ); pClassTimeF = new RscClass( nId, RSC_NOTYPE, pSuper ); pClassTimeF->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType ); // Variablen anlegen nId = aNmTb.Put( "Minimum", VARNAME ); pClassTimeF->SetVariable( nId, pClassTime, NULL, 0, TIMEFORMATTER_MIN ); nId = aNmTb.Put( "Maximum", VARNAME ); pClassTimeF->SetVariable( nId, pClassTime, NULL, 0, TIMEFORMATTER_MAX ); nId = aNmTb.Put( "Format", VARNAME ); pClassTimeF->SetVariable( nId, pTimeFieldFormat, NULL, 0, TIMEFORMATTER_TIMEFIELDFORMAT ); nId = aNmTb.Put( "Duration", VARNAME ); pClassTimeF->SetVariable( nId, &aBool, NULL, 0, TIMEFORMATTER_DURATION ); nId = aNmTb.Put( "StrictFormat", VARNAME ); pClassTimeF->SetVariable( nId, &aBool, NULL, 0, TIMEFORMATTER_STRICTFORMAT ); nId = aNmTb.Put( "Value", VARNAME ); pClassTimeF->SetVariable( nId, pClassTime, NULL, 0, TIMEFORMATTER_VALUE ); return pClassTimeF; } /************************************************************************* |* RscTypCont::InitClassSpinField() *************************************************************************/ RscTop * RscTypCont::InitClassSpinField( RscTop * pSuper ) { Atom nId; RscTop * pClassSpinField; // Klasse anlegen nId = pHS->getID( "SpinField" ); pClassSpinField = new RscClass( nId, RSC_SPINFIELD, pSuper ); pClassSpinField->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassSpinField ); INS_WINBIT(pClassSpinField,Repeat) INS_WINBIT(pClassSpinField,Spin) return pClassSpinField; } /************************************************************************* |* RscTypCont::InitClassPatternField() *************************************************************************/ RscTop * RscTypCont::InitClassPatternField( RscTop * pSuper ) { Atom nId; RscTop * pClassPatternField; // Klasse anlegen nId = pHS->getID( "PatternField" ); pClassPatternField = new RscClass( nId, RSC_PATTERNFIELD, pSuper ); pClassPatternField->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassPatternField ); return pClassPatternField; } /************************************************************************* |* RscTypCont::InitClassNumericField() *************************************************************************/ RscTop * RscTypCont::InitClassNumericField( RscTop * pSuper ) { Atom nId; RscTop * pClassNumericField; // Klasse anlegen nId = pHS->getID( "NumericField" ); pClassNumericField = new RscClass( nId, RSC_NUMERICFIELD, pSuper ); pClassNumericField->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassNumericField ); // Variablen anlegen nId = aNmTb.Put( "First", VARNAME ); pClassNumericField->SetVariable( nId, &aIdLong, NULL, 0, NUMERICFIELD_FIRST ); nId = aNmTb.Put( "Last", VARNAME ); pClassNumericField->SetVariable( nId, &aIdLong, NULL, 0, NUMERICFIELD_LAST ); nId = aNmTb.Put( "SpinSize", VARNAME ); pClassNumericField->SetVariable( nId, &aIdLong, NULL, 0, NUMERICFIELD_SPINSIZE ); return pClassNumericField; } /************************************************************************* |* RscTypCont::InitClassMetricField() *************************************************************************/ RscTop * RscTypCont::InitClassMetricField( RscTop * pSuper ) { Atom nId; RscTop * pClassMetricField; // Klasse anlegen nId = pHS->getID( "MetricField" ); pClassMetricField = new RscClass( nId, RSC_METRICFIELD, pSuper ); pClassMetricField->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassMetricField ); // Variablen anlegen nId = aNmTb.Put( "First", VARNAME ); pClassMetricField->SetVariable( nId, &aIdLong, NULL, 0, METRICFIELD_FIRST ); nId = aNmTb.Put( "Last", VARNAME ); pClassMetricField->SetVariable( nId, &aIdLong, NULL, 0, METRICFIELD_LAST ); nId = aNmTb.Put( "SpinSize", VARNAME ); pClassMetricField->SetVariable( nId, &aIdLong, NULL, 0, METRICFIELD_SPINSIZE ); return pClassMetricField; } /************************************************************************* |* RscTypCont::InitClassCurrencyField() *************************************************************************/ RscTop * RscTypCont::InitClassCurrencyField ( const char * pClassName, sal_uInt32 nRT, RscTop * pSuper ) { Atom nId; RscTop * pClassCurrencyField; // Klasse anlegen nId = pHS->getID( pClassName ); pClassCurrencyField = new RscClass( nId, nRT, pSuper ); pClassCurrencyField->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassCurrencyField ); // Variablen anlegen nId = aNmTb.Put( "First", VARNAME ); pClassCurrencyField->SetVariable( nId, &aIdLong, NULL, 0, CURRENCYFIELD_FIRST ); nId = aNmTb.Put( "Last", VARNAME ); pClassCurrencyField->SetVariable( nId, &aIdLong, NULL, 0, CURRENCYFIELD_LAST ); nId = aNmTb.Put( "SpinSize", VARNAME ); pClassCurrencyField->SetVariable( nId, &aIdLong, NULL, 0, CURRENCYFIELD_SPINSIZE ); return pClassCurrencyField; } /************************************************************************* |* RscTypCont::InitClassDateField() *************************************************************************/ RscTop * RscTypCont::InitClassDateField( RscTop * pSuper, RscTop * pClassDate ) { Atom nId; RscTop * pClassDateField; // Klasse anlegen nId = pHS->getID( "DateField" ); pClassDateField = new RscClass( nId, RSC_DATEFIELD, pSuper ); pClassDateField->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassDateField ); // Variablen anlegen nId = aNmTb.Put( "First", VARNAME ); pClassDateField->SetVariable( nId, pClassDate, NULL, 0, DATEFIELD_FIRST ); nId = aNmTb.Put( "Last", VARNAME ); pClassDateField->SetVariable( nId, pClassDate, NULL, 0, DATEFIELD_LAST ); return pClassDateField; } /************************************************************************* |* RscTypCont::InitClassTimeField() *************************************************************************/ RscTop * RscTypCont::InitClassTimeField( RscTop * pSuper, RscTop * pClassTime ) { Atom nId; RscTop * pClassTimeField; // Klasse anlegen nId = pHS->getID( "TimeField" ); pClassTimeField = new RscClass( nId, RSC_TIMEFIELD, pSuper ); pClassTimeField->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassTimeField ); // Variablen anlegen nId = aNmTb.Put( "First", VARNAME ); pClassTimeField->SetVariable( nId, pClassTime, NULL, 0, TIMEFIELD_FIRST ); nId = aNmTb.Put( "Last", VARNAME ); pClassTimeField->SetVariable( nId, pClassTime, NULL, 0, TIMEFIELD_LAST ); return pClassTimeField; } /************************************************************************* |* RscTypCont::InitClassPatternBox() *************************************************************************/ RscTop * RscTypCont::InitClassPatternBox( RscTop * pSuper ) { Atom nId; RscTop * pClassPatternBox; // Klasse anlegen nId = pHS->getID( "PatternBox" ); pClassPatternBox = new RscClass( nId, RSC_PATTERNBOX, pSuper ); pClassPatternBox->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassPatternBox ); return pClassPatternBox; } /************************************************************************* |* RscTypCont::InitClassNumericBox() *************************************************************************/ RscTop * RscTypCont::InitClassNumericBox( RscTop * pSuper ) { Atom nId; RscTop * pClassNumericBox; // Klasse anlegen nId = pHS->getID( "NumericBox" ); pClassNumericBox = new RscClass( nId, RSC_NUMERICBOX, pSuper ); pClassNumericBox->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassNumericBox ); // Variablen anlegen return pClassNumericBox; } /************************************************************************* |* RscTypCont::InitClassMetricBox() *************************************************************************/ RscTop * RscTypCont::InitClassMetricBox( RscTop * pSuper ) { Atom nId; RscTop * pClassMetricBox; // Klasse anlegen nId = pHS->getID( "MetricBox" ); pClassMetricBox = new RscClass( nId, RSC_METRICBOX, pSuper ); pClassMetricBox->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassMetricBox ); // Variablen anlegen return pClassMetricBox; } /************************************************************************* |* RscTypCont::InitClassCurrencyBox() *************************************************************************/ RscTop * RscTypCont::InitClassCurrencyBox ( const char * pClassName, sal_uInt32 nRT, RscTop * pSuper ) { Atom nId; RscTop * pClassCurrencyBox; // Klasse anlegen nId = pHS->getID( pClassName ); pClassCurrencyBox = new RscClass( nId, nRT, pSuper ); pClassCurrencyBox->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassCurrencyBox ); // Variablen anlegen return pClassCurrencyBox; } /************************************************************************* |* RscTypCont::InitClassDateBox() *************************************************************************/ RscTop * RscTypCont::InitClassDateBox( RscTop * pSuper, RscTop * /*pClassDate*/ ) { Atom nId; RscTop * pClassDateBox; // Klasse anlegen nId = pHS->getID( "DateBox" ); pClassDateBox = new RscClass( nId, RSC_DATEBOX, pSuper ); pClassDateBox->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassDateBox ); // Variablen anlegen return pClassDateBox; } /************************************************************************* |* RscTypCont::InitClassTimeBox() *************************************************************************/ RscTop * RscTypCont::InitClassTimeBox( RscTop * pSuper, RscTop * /*pClassTime*/ ) { Atom nId; RscTop * pClassTimeBox; // Klasse anlegen nId = pHS->getID( "TimeBox" ); pClassTimeBox = new RscClass( nId, RSC_TIMEBOX, pSuper ); pClassTimeBox->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassTimeBox ); // Variablen anlegen return pClassTimeBox; } /************************************************************************* |* RscTypCont::InitClassDockWindow() *************************************************************************/ RscTop * RscTypCont::InitClassDockingWindow( RscTop * pSuper, RscEnum * pMapUnit ) { Atom nId; RscTop * pClassDockWindow; // Klasse anlegen nId = pHS->getID( "DockingWindow" ); pClassDockWindow = new RscClass( nId, RSC_DOCKINGWINDOW, pSuper ); pClassDockWindow->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassDockWindow ); // Variablen anlegen nId = aNmTb.Put( "_FloatingPosMapMode", VARNAME ); pClassDockWindow->SetVariable( nId, pMapUnit, NULL, 0, RSC_DOCKINGWINDOW_XYMAPMODE ); nId = aNmTb.Put( "_FloatingPosX", VARNAME ); pClassDockWindow->SetVariable( nId, &aShort, NULL, 0, RSC_DOCKINGWINDOW_X ); nId = aNmTb.Put( "_FloatingPosY", VARNAME ); pClassDockWindow->SetVariable( nId, &aShort, NULL, 0, RSC_DOCKINGWINDOW_Y ); nId = aNmTb.Put( "FloatingMode", VARNAME ); pClassDockWindow->SetVariable( nId, &aBool, NULL, 0, RSC_DOCKINGWINDOW_FLOATING ); INS_WINBIT(pClassDockWindow,Moveable) INS_WINBIT(pClassDockWindow,Sizeable) INS_WINBIT(pClassDockWindow,EnableResizing) INS_WINBIT(pClassDockWindow,Closeable) INS_WINBIT(pClassDockWindow,HideWhenDeactivate); INS_WINBIT(pClassDockWindow,Zoomable); INS_WINBIT(pClassDockWindow,Dockable); return pClassDockWindow; } /************************************************************************* |* RscTypCont::InitClassToolBoxItem() *************************************************************************/ RscTop * RscTypCont::InitClassToolBoxItem( RscTop * pSuper, RscTop * pClassBitmap, RscTop * pClassImage, RscEnum * pTriState ) { Atom nId; RscTop * pClassToolBoxItem; // Klasse anlegen nId = pHS->getID( "ToolBoxItem" ); pClassToolBoxItem = new RscClass( nId, RSC_TOOLBOXITEM, pSuper ); aNmTb.Put( nId, CLASSNAME, pClassToolBoxItem ); // Variablen anlegen nId = aNmTb.Put( "Identifier", VARNAME ); pClassToolBoxItem->SetVariable( nId, &aIdNoZeroUShort, NULL, 0, RSC_TOOLBOXITEM_ID ); { RscEnum * pEnum; aBaseLst.Insert( pEnum = new RscEnum( pHS->getID( "EnumToolBoxItemType" ), RSC_NOTYPE ), LIST_APPEND ); SETCONST( pEnum, "TOOLBOXITEM_BUTTON", TOOLBOXITEM_BUTTON ); SETCONST( pEnum, "TOOLBOXITEM_SPACE", TOOLBOXITEM_SPACE ); SETCONST( pEnum, "TOOLBOXITEM_SEPARATOR", TOOLBOXITEM_SEPARATOR ); SETCONST( pEnum, "TOOLBOXITEM_BREAK", TOOLBOXITEM_BREAK ); // Variable einfuegen nId = aNmTb.Put( "Type", VARNAME ); pClassToolBoxItem->SetVariable( nId, pEnum, NULL, 0, RSC_TOOLBOXITEM_TYPE ); } { RscFlag * pFlag; RscClient * pClient; Atom l_nVarId, l_nAutoCheckId, l_nRadioCheckId, l_nCheckableId, l_nLeftId, l_nAutoSizeId, l_nDropDownId; aBaseLst.Insert( pFlag = new RscFlag( pHS->getID( "FlagToolBoxState" ), RSC_NOTYPE ), LIST_APPEND ); // Konstanten in Tabelle stellen l_nCheckableId = pHS->getID( "TIB_CHECKABLE" ); SETCONST( pFlag, l_nCheckableId, TIB_CHECKABLE ); l_nAutoCheckId = pHS->getID( "TIB_AUTOCHECK" ); SETCONST( pFlag, l_nAutoCheckId, TIB_AUTOCHECK ); l_nRadioCheckId = pHS->getID( "TIB_RADIOCHECK" ); SETCONST( pFlag, l_nRadioCheckId, TIB_RADIOCHECK ); l_nLeftId = pHS->getID( "TIB_LEFT" ); SETCONST( pFlag, l_nLeftId, TIB_LEFT ); l_nAutoSizeId = pHS->getID( "TIB_AUTOSIZE" ); SETCONST( pFlag, l_nAutoSizeId, TIB_AUTOSIZE ); l_nDropDownId = pHS->getID( "TIB_DROPDOWN" ); SETCONST( pFlag, l_nDropDownId, TIB_DROPDOWN ); // Variable einfuegen l_nVarId = aNmTb.Put( "_ToolBoxItemFlags", VARNAME ); pClassToolBoxItem->SetVariable( l_nVarId, pFlag, NULL, VAR_HIDDEN | VAR_NOENUM, RSC_TOOLBOXITEM_STATUS ); // Clientvariablen einfuegen aBaseLst.Insert( pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE, pFlag, l_nCheckableId ), LIST_APPEND ); nId = aNmTb.Put( "Checkable", VARNAME ); pClassToolBoxItem->SetVariable( nId, pClient, NULL, VAR_NODATAINST, 0, l_nVarId ); aBaseLst.Insert( pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE, pFlag, l_nAutoCheckId ), LIST_APPEND ); nId = aNmTb.Put( "AutoCheck", VARNAME ); pClassToolBoxItem->SetVariable( nId, pClient, NULL, VAR_NODATAINST, 0, l_nVarId ); aBaseLst.Insert( pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE, pFlag, l_nRadioCheckId ), LIST_APPEND ); nId = aNmTb.Put( "RadioCheck", VARNAME ); pClassToolBoxItem->SetVariable( nId, pClient, NULL, VAR_NODATAINST, 0, l_nVarId ); aBaseLst.Insert( pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE, pFlag, l_nLeftId ), LIST_APPEND ); nId = aNmTb.Put( "Left", VARNAME ); pClassToolBoxItem->SetVariable( nId, pClient, NULL, VAR_NODATAINST, 0, l_nVarId ); aBaseLst.Insert( pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE, pFlag, l_nAutoSizeId ), LIST_APPEND ); nId = aNmTb.Put( "AutoSize", VARNAME ); pClassToolBoxItem->SetVariable( nId, pClient, NULL, VAR_NODATAINST, 0, l_nVarId ); aBaseLst.Insert( pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE, pFlag, l_nDropDownId ), LIST_APPEND ); nId = aNmTb.Put( "DropDown", VARNAME ); pClassToolBoxItem->SetVariable( nId, pClient, NULL, VAR_NODATAINST, 0, l_nVarId ); } nId = aNmTb.Put( "HelpID", VARNAME ); pClassToolBoxItem->SetVariable( nId, &aStringLiteral, NULL, 0, RSC_TOOLBOXITEM_HELPID ); nId = aNmTb.Put( "Text", VARNAME ); pClassToolBoxItem->SetVariable( nId, &aLangString, NULL, 0, RSC_TOOLBOXITEM_TEXT ); nId = aNmTb.Put( "HelpText", VARNAME ); pClassToolBoxItem->SetVariable( nId, &aLangString, NULL, 0, RSC_TOOLBOXITEM_HELPTEXT ); nId = aNmTb.Put( "ItemBitmap", VARNAME ); pClassToolBoxItem->SetVariable( nId, pClassBitmap, NULL, 0, RSC_TOOLBOXITEM_BITMAP ); nId = aNmTb.Put( "ItemImage", VARNAME ); pClassToolBoxItem->SetVariable( nId, pClassImage, NULL, 0, RSC_TOOLBOXITEM_IMAGE ); nId = aNmTb.Put( "Disable", VARNAME ); pClassToolBoxItem->SetVariable( nId, &aBool, NULL, 0, RSC_TOOLBOXITEM_DISABLE ); nId = aNmTb.Put( "State", VARNAME ); pClassToolBoxItem->SetVariable( nId, pTriState, NULL, 0, RSC_TOOLBOXITEM_STATE ); nId = aNmTb.Put( "Hide", VARNAME ); pClassToolBoxItem->SetVariable( nId, &aBool, NULL, 0, RSC_TOOLBOXITEM_HIDE ); nId = aNmTb.Put( "Hide", VARNAME ); pClassToolBoxItem->SetVariable( nId, &aBool, NULL, 0, RSC_TOOLBOXITEM_HIDE ); nId = aNmTb.Put( "Command", VARNAME ); pClassToolBoxItem->SetVariable( nId, &aString, NULL, 0, RSC_TOOLBOXITEM_COMMAND ); return pClassToolBoxItem; } /************************************************************************* |* RscTypCont::InitClassToolBox() *************************************************************************/ RscTop * RscTypCont::InitClassToolBox( RscTop * pSuper, RscTop * pClassToolBoxItem, RscTop * pClassImageList ) { Atom nId; RscTop * pClassToolBox; // Klasse anlegen nId = pHS->getID( "ToolBox" ); pClassToolBox = new RscClass( nId, RSC_TOOLBOX, pSuper ); pClassToolBox->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassToolBox ); // Variablen anlegen { RscEnum * pEnum; aBaseLst.Insert( pEnum = new RscEnum( pHS->getID( "EnumButtonType" ), RSC_NOTYPE ), LIST_APPEND ); SETCONST( pEnum, "BUTTON_SYMBOL", BUTTON_SYMBOL ); SETCONST( pEnum, "BUTTON_TEXT", BUTTON_TEXT ); SETCONST( pEnum, "BUTTON_SYMBOLTEXT", BUTTON_SYMBOLTEXT ); // Variable einfuegen nId = aNmTb.Put( "ButtonType", VARNAME ); pClassToolBox->SetVariable( nId, pEnum, NULL, 0, RSC_TOOLBOX_BUTTONTYPE ); } { RscEnum * pEnum; aBaseLst.Insert( pEnum = new RscEnum( pHS->getID( "EnumToolBoxAlign" ), RSC_NOTYPE ), LIST_APPEND ); SETCONST( pEnum, "BOXALIGN_TOP", WINDOWALIGN_TOP ); SETCONST( pEnum, "BOXALIGN_LEFT", WINDOWALIGN_LEFT ); SETCONST( pEnum, "BOXALIGN_RIGHT", WINDOWALIGN_RIGHT ); SETCONST( pEnum, "BOXALIGN_BOTTOM", WINDOWALIGN_BOTTOM ); // Variable einfuegen nId = aNmTb.Put( "Align", VARNAME ); pClassToolBox->SetVariable( nId, pEnum, NULL, 0, RSC_TOOLBOX_ALIGN ); } nId = aNmTb.Put( "LineCount", VARNAME ); pClassToolBox->SetVariable( nId, &aIdNoZeroUShort, NULL, 0, RSC_TOOLBOX_LINECOUNT ); nId = aNmTb.Put( "FloatingLines", VARNAME ); pClassToolBox->SetVariable( nId, &aUShort, NULL, 0, RSC_TOOLBOX_FLOATLINES ); nId = aNmTb.Put( "Customize", VARNAME ); pClassToolBox->SetVariable( nId, &aBool, NULL, 0, RSC_TOOLBOX_CUSTOMIZE ); nId = aNmTb.Put( "MenuStrings", VARNAME ); pClassToolBox->SetVariable( nId, &aBool, NULL, 0, RSC_TOOLBOX_MENUSTRINGS ); nId = aNmTb.Put( "ItemImageList", VARNAME ); pClassToolBox->SetVariable( nId, pClassImageList, NULL, 0, RSC_TOOLBOX_ITEMIMAGELIST ); { RscLangArray* pLA; RscCont * pCont; aBaseLst.Insert( pCont = new RscCont( pHS->getID( "ContToolBoxItem" ), RSC_NOTYPE ), LIST_APPEND ); pCont->SetTypeClass( pClassToolBoxItem ); aBaseLst.Insert( pLA = new RscLangArray( pHS->getID( "LangContToolBoxItem" ), RSC_NOTYPE, pCont, &aLangType ), LIST_APPEND ); nId = aNmTb.Put( "ItemList", VARNAME ); pClassToolBox->SetVariable( nId, pLA, NULL, 0, RSC_TOOLBOX_ITEMLIST ); } INS_WINBIT(pClassToolBox,Scroll) INS_WINBIT(pClassToolBox,LineSpacing) INS_WINBIT(pClassToolBox,RectStyle) INS_WINBIT(pClassToolBox,Tabstop) return pClassToolBox; } /************************************************************************* |* RscTypCont::InitClassStatusBar() *************************************************************************/ RscTop * RscTypCont::InitClassStatusBar( RscTop * pSuper ) { Atom nId; RscTop * pClassStatusBar; // Klasse anlegen nId = pHS->getID( "StatusBar" ); pClassStatusBar = new RscClass( nId, RSC_STATUSBAR, pSuper ); pClassStatusBar->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassStatusBar ); // Variablen anlegen INS_WINBIT(pClassStatusBar,Left) INS_WINBIT(pClassStatusBar,Right) return pClassStatusBar; } /************************************************************************* |* RscTypCont::InitClassMoreButton() *************************************************************************/ RscTop * RscTypCont::InitClassMoreButton( RscTop * pSuper, RscEnum * pMapUnit ) { Atom nId; RscTop * pClassMoreButton; // Klasse anlegen nId = pHS->getID( "MoreButton" ); pClassMoreButton = new RscClass( nId, RSC_MOREBUTTON, pSuper ); pClassMoreButton->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassMoreButton ); // Variablen anlegen nId = aNmTb.Put( "State", VARNAME ); pClassMoreButton->SetVariable( nId, &aBool, NULL, 0, RSC_MOREBUTTON_STATE ); nId = aNmTb.Put( "MapUnit", VARNAME ); pClassMoreButton->SetVariable( nId, pMapUnit, NULL, 0, RSC_MOREBUTTON_MAPUNIT ); nId = aNmTb.Put( "Delta", VARNAME ); pClassMoreButton->SetVariable( nId, &aUShort, NULL, 0, RSC_MOREBUTTON_DELTA ); return pClassMoreButton; } /************************************************************************* |* RscTypCont::InitClassFloatingWindow() *************************************************************************/ RscTop * RscTypCont::InitClassFloatingWindow( RscTop * pSuper, RscEnum * pMapUnit ) { Atom nId; RscTop * pClassFloatingWindow; // Klasse anlegen nId = pHS->getID( "FloatingWindow" ); pClassFloatingWindow = new RscClass( nId, RSC_FLOATINGWINDOW, pSuper ); pClassFloatingWindow->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType ); aNmTb.Put( nId, CLASSNAME, pClassFloatingWindow ); // Variablen anlegen nId = aNmTb.Put( "_ZoomInMapMode", VARNAME ); pClassFloatingWindow->SetVariable( nId, pMapUnit, NULL, 0, RSC_FLOATINGWINDOW_WHMAPMODE ); nId = aNmTb.Put( "_ZoomInWidth", VARNAME ); pClassFloatingWindow->SetVariable( nId, &aShort, NULL, 0, RSC_FLOATINGWINDOW_WIDTH ); nId = aNmTb.Put( "_ZoomInHeight", VARNAME ); pClassFloatingWindow->SetVariable( nId, &aShort, NULL, 0, RSC_FLOATINGWINDOW_HEIGHT ); nId = aNmTb.Put( "ZoomIn", VARNAME ); pClassFloatingWindow->SetVariable( nId, &aBool, NULL, 0, RSC_FLOATINGWINDOW_ZOOMIN ); INS_WINBIT(pClassFloatingWindow,Zoomable) INS_WINBIT(pClassFloatingWindow,HideWhenDeactivate) INS_WINBIT(pClassFloatingWindow,EnableResizing) return pClassFloatingWindow; } /************************************************************************* |* RscTypCont::InitClassTabControlItem() *************************************************************************/ RscTop * RscTypCont::InitClassTabControlItem( RscTop * pSuper, RscTop * /*pClassTabPage*/ ) { Atom nId; RscTop * pClassTabControlItem; // Klasse anlegen nId = pHS->getID( "PageItem" ); pClassTabControlItem = new RscClass( nId, RSC_TABCONTROLITEM, pSuper ); aNmTb.Put( nId, CLASSNAME, pClassTabControlItem ); // Variablen anlegen nId = aNmTb.Put( "Identifier", VARNAME ); pClassTabControlItem->SetVariable( nId, &aIdNoZeroUShort, NULL, 0, RSC_TABCONTROLITEM_ID ); nId = aNmTb.Put( "Text", VARNAME ); pClassTabControlItem->SetVariable( nId, &aLangString, NULL, 0, RSC_TABCONTROLITEM_TEXT ); nId = aNmTb.Put( "PageResID", VARNAME ); pClassTabControlItem->SetVariable( nId, &aIdLong, NULL, 0, RSC_TABCONTROLITEM_PAGERESID ); return pClassTabControlItem; } /************************************************************************* |* RscTypCont::InitClassTabControl() *************************************************************************/ RscTop * RscTypCont::InitClassTabControl( RscTop * pSuper, RscTop * pClassTabControlItem ) { Atom nId; RscTop * pClassTabControl; // Klasse anlegen nId = pHS->getID( "TabControl" ); pClassTabControl = new RscClass( nId, RSC_TABCONTROL, pSuper ); pClassTabControl->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType ); aNmTb.Put( nId, CLASSNAME, pClassTabControl ); // Variablen anlegen { RscCont * pCont; aBaseLst.Insert( pCont = new RscCont( pHS->getID( "ContTabControlItem" ), RSC_NOTYPE ), LIST_APPEND ); pCont->SetTypeClass( pClassTabControlItem ); nId = aNmTb.Put( "PageList", VARNAME ); pClassTabControl->SetVariable( nId, pCont, NULL, 0, RSC_TABCONTROL_ITEMLIST ); INS_WINBIT( pClassTabControl, DropDown ); } return pClassTabControl; } /************************************************************************* |* RscTypCont::InitClassSfxFamilyStyleItem() *************************************************************************/ RscTop * RscTypCont::InitClassSfxStyleFamilyItem( RscTop * pSuper, RscTop * pClassBitmap, RscTop * pClassImage, RscArray * pStrLst ) { Atom nId; RscTop * pClassSfxFamilyStyleItem; // Klasse anlegen nId = pHS->getID( "SfxStyleFamilyItem" ); pClassSfxFamilyStyleItem = new RscClass( nId, RSC_SFX_STYLE_FAMILY_ITEM, pSuper ); aNmTb.Put( nId, CLASSNAME, pClassSfxFamilyStyleItem ); nId = aNmTb.Put( "FilterList", VARNAME ); pClassSfxFamilyStyleItem->SetVariable( nId, pStrLst, NULL, 0, RSC_SFX_STYLE_ITEM_LIST ); nId = aNmTb.Put( "StyleBitmap", VARNAME ); pClassSfxFamilyStyleItem->SetVariable( nId, pClassBitmap, NULL, 0, RSC_SFX_STYLE_ITEM_BITMAP ); nId = aNmTb.Put( "Text", VARNAME ); pClassSfxFamilyStyleItem->SetVariable( nId, &aLangString, NULL, 0, RSC_SFX_STYLE_ITEM_TEXT ); nId = aNmTb.Put( "HelpText", VARNAME ); pClassSfxFamilyStyleItem->SetVariable( nId, &aLangString, NULL, 0, RSC_SFX_STYLE_ITEM_HELPTEXT ); { RscEnum * pSfxStyleFamily; pSfxStyleFamily = new RscEnum( pHS->getID( "StyleFamily" ), RSC_NOTYPE ); SETCONST( pSfxStyleFamily, "SFX_STYLE_FAMILY_PARA", SFX_STYLE_FAMILY_PARA ); SETCONST( pSfxStyleFamily, "SFX_STYLE_FAMILY_CHAR", SFX_STYLE_FAMILY_CHAR ); SETCONST( pSfxStyleFamily, "SFX_STYLE_FAMILY_FRAME",SFX_STYLE_FAMILY_FRAME); SETCONST( pSfxStyleFamily, "SFX_STYLE_FAMILY_PAGE", SFX_STYLE_FAMILY_PAGE ); SETCONST( pSfxStyleFamily, "SFX_STYLE_FAMILY_PSEUDO", SFX_STYLE_FAMILY_PSEUDO ); aBaseLst.Insert( pSfxStyleFamily ); nId = aNmTb.Put( "StyleFamily", VARNAME ); pClassSfxFamilyStyleItem->SetVariable( nId, pSfxStyleFamily, NULL, 0, RSC_SFX_STYLE_ITEM_STYLEFAMILY ); } nId = aNmTb.Put( "StyleImage", VARNAME ); pClassSfxFamilyStyleItem->SetVariable( nId, pClassImage, NULL, 0, RSC_SFX_STYLE_ITEM_IMAGE ); return pClassSfxFamilyStyleItem; } /************************************************************************* |* RscTypCont::InitClassSfxTemplateDialogm() *************************************************************************/ RscTop * RscTypCont::InitClassSfxTemplateDialog( RscTop * pSuper, RscTop * pClassFamilyStyleItem ) { Atom nId; RscTop * pClassSfxTemplateDialog; // Klasse anlegen nId = pHS->getID( "SfxStyleFamilies" ); pClassSfxTemplateDialog = new RscClass( nId, RSC_SFX_STYLE_FAMILIES, pSuper ); aNmTb.Put( nId, CLASSNAME, pClassSfxTemplateDialog ); // Variablen anlegen { RscCont * pCont; aBaseLst.Insert( pCont = new RscCont( pHS->getID( "ContFamilyStyleItem" ), RSC_NOTYPE ), LIST_APPEND ); pCont->SetTypeClass( pClassFamilyStyleItem ); nId = aNmTb.Put( "StyleFamilyList", VARNAME ); pClassSfxTemplateDialog->SetVariable( nId, pCont ); } return pClassSfxTemplateDialog; } /************************************************************************* |* RscTypCont::InitClassSfxSlotInfo() *************************************************************************/ RscTop * RscTypCont::InitClassSfxSlotInfo( RscTop * pSuper ) { Atom nId; RscTop * pClassSfxSlotInfo; // Klasse anlegen nId = pHS->getID( "SfxSlotInfo" ); pClassSfxSlotInfo = new RscClass( nId, RSC_SFX_SLOT_INFO, pSuper ); aNmTb.Put( nId, CLASSNAME, pClassSfxSlotInfo ); nId = aNmTb.Put( "SlotName", VARNAME ); pClassSfxSlotInfo->SetVariable( nId, &aLangString, NULL, 0, RSC_SFX_SLOT_INFO_SLOTNAME ); nId = aNmTb.Put( "HelpText", VARNAME ); pClassSfxSlotInfo->SetVariable( nId, &aLangString, NULL, 0, RSC_SFX_SLOT_INFO_HELPTEXT ); return pClassSfxSlotInfo; }