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