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