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