Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 :
21 : #include <stdlib.h>
22 : #include <stdio.h>
23 :
24 : #include <tools/rc.h>
25 : #include <tools/wintypes.hxx>
26 :
27 : #include <rsctree.hxx>
28 : #include <rsctop.hxx>
29 : #include <rscrange.hxx>
30 : #include <rscconst.hxx>
31 : #include <rscflag.hxx>
32 : #include <rscstr.hxx>
33 : #include <rsccont.hxx>
34 : #include <rscmgr.hxx>
35 : #include <rscclass.hxx>
36 : #include <rsckey.hxx>
37 : #include <rscdb.hxx>
38 : #include <rsclex.hxx>
39 : #include <rscyacc.hxx>
40 :
41 : #define INS_WINBIT( pClass, WinBit ) \
42 : InsWinBit( pClass, #WinBit, n##WinBit##Id );
43 :
44 451 : void RscTypCont::Init()
45 : {
46 : RscEnum * pFieldUnits;
47 : RscEnum * pTimeFieldFormat;
48 : RscEnum * pColor;
49 : RscEnum * pMapUnit;
50 : RscEnum * pKey;
51 : RscEnum * pTriState;
52 : RscEnum * pMessButtons;
53 : RscEnum * pMessDefButton;
54 : RscTupel * pGeometry;
55 : RscArray * pLangGeometry;
56 : RscCont * pStringList;
57 : RscArray * pLangStringList;
58 : RscTupel * pStringTupel;
59 : RscTupel * pStringLongTupel;
60 : RscCont * pStringTupelList;
61 : RscCont * pStringLongTupelList;
62 : RscArray * pLangStringLongTupelList;
63 :
64 : RscTop * pClassMgr;
65 : RscTop * pClassString;
66 : RscTop * pClassStringArray;
67 : RscTop * pClassBitmap;
68 : RscTop * pClassColor;
69 : RscTop * pClassImage;
70 : RscTop * pClassImageList;
71 : RscTop * pClassWindow;
72 : RscTop * pClassSystemWindow;
73 : RscTop * pClassWorkWindow;
74 : RscTop * pClassDialog;
75 : RscTop * pClassModalDialog;
76 : RscTop * pClassModelessDialog;
77 : RscTop * pClassControl;
78 : RscTop * pClassButton;
79 : RscTop * pClassCheckBox;
80 : RscTop * pClassPushButton;
81 : RscTop * pClassOKButton;
82 : RscTop * pClassCancelButton;
83 : RscTop * pClassHelpButton;
84 : RscTop * pClassRadioButton;
85 : RscTop * pClassImageButton;
86 : RscTop * pClassTriStateBox;
87 : RscTop * pClassEdit;
88 : RscTop * pClassMultiLineEdit;
89 : RscTop * pClassScrollBar;
90 : RscTop * pClassListBox;
91 : RscTop * pClassMultiListBox;
92 : RscTop * pClassComboBox;
93 : RscTop * pClassFixedText;
94 : RscTop * pClassFixedBitmap;
95 : RscTop * pClassFixedImage;
96 : RscTop * pClassGroupBox;
97 : RscTop * pClassKeyCode;
98 : RscTop * pLangClassKeyCode;
99 : RscTop * pClassAccelItem;
100 : RscTop * pClassAccel;
101 : RscTop * pClassMenuItem;
102 : RscTop * pClassMenu;
103 : RscTop * pClassMenuButton;
104 : RscTop * pClassMessBox;
105 : RscTop * pClassInfoBox;
106 : RscTop * pClassWarningBox;
107 : RscTop * pClassErrorBox;
108 : RscTop * pClassQueryBox;
109 : RscTop * pClassSplitter;
110 : RscTop * pClassSplitWindow;
111 : RscTop * pClassSpinButton;
112 : RscTop * pClassTime;
113 : RscTop * pClassDate;
114 : RscTop * pClassSpinField;
115 : RscTop * pClassPatternField;
116 : RscTop * pClassNumericField;
117 : RscTop * pClassMetricField;
118 : RscTop * pClassDateField;
119 : RscTop * pClassTimeField;
120 : RscTop * pClassPatternBox;
121 : RscTop * pClassNumericBox;
122 : RscTop * pClassDockingWindow;
123 : RscTop * pClassToolBoxItem;
124 : RscTop * pClassToolBox;
125 : RscTop * pClassStatusBar;
126 : RscTop * pClassFloatingWindow;
127 : RscTop * pClassTabPage;
128 : RscTop * pClassTabDialog;
129 : RscTop * pClassTabControlItem;
130 : RscTop * pClassTabControl;
131 : RscTop * pClassFixedLine;
132 : RscTop * pClassScrollBarBox;
133 : RscTop * pClassSfxStyleFamilyItem;
134 : RscTop * pClassSfxTemplateDialog;
135 : RscTop * pClassSfxSlotInfo;
136 :
137 : Atom nId;
138 :
139 451 : aNmTb.SetSort( false );
140 : {
141 451 : aNmTb.Put( "LINE", LINE, (long)0 );
142 451 : aNmTb.Put( "NOT", NOT, (long)0 );
143 451 : aNmTb.Put( "DEFINE", DEFINE, (long)0 );
144 451 : aNmTb.Put( "INCLUDE", INCLUDE, (long)0 );
145 451 : aNmTb.Put( "DEFAULT", DEFAULT, (long)0 );
146 451 : aNmTb.Put( "class", CLASS, (long)0 );
147 451 : aNmTb.Put( "extendable", EXTENDABLE, (long)0 );
148 451 : aNmTb.Put( "writeifset", WRITEIFSET, (long)0 );
149 :
150 : /* Werte fuer Aufzaehlungstypen */
151 451 : aNmTb.Put( "TRUE", BOOLEAN, (long)sal_True );
152 451 : aNmTb.Put( "FALSE", BOOLEAN, (long)sal_False );
153 :
154 451 : aNmTb.Put( "XSCALE", XSCALE , (long)0 );
155 451 : aNmTb.Put( "YSCALE", YSCALE , (long)0 );
156 451 : aNmTb.Put( "RGB", RGB , (long)0 );
157 451 : aNmTb.Put( "POSSIZE", GEOMETRY, (long)0 );
158 451 : aNmTb.Put( "POS", POSITION, (long)0 );
159 451 : aNmTb.Put( "SIZE", DIMENSION, (long)0 );
160 451 : aNmTb.Put( "ZoomInOutputSize", INZOOMOUTPUTSIZE,(long)0 );
161 451 : aNmTb.Put( "FloatingPos", FLOATINGPOS, (long)0 );
162 : }
163 : {
164 451 : aShort.SetRange( -32768, 32767 );
165 :
166 451 : aUShort.SetRange( 0, 0xFFFF );
167 :
168 451 : aLong.SetRange( SAL_MIN_INT32, SAL_MAX_INT32 );
169 451 : aEnumLong.SetRange( SAL_MIN_INT32, SAL_MAX_INT32 );
170 :
171 451 : aIdUShort.SetRange( 0, 0xFFFF );
172 :
173 451 : aIdNoZeroUShort.SetRange( 1, 0xFFFF );
174 :
175 451 : aNoZeroShort.SetRange( -32768, 32767 );
176 451 : aNoZeroShort.SetOutRange( 0 );
177 :
178 451 : a1to12Short.SetRange( 1, 12 );
179 451 : a0to23Short.SetRange( 0, 23 );
180 451 : a1to31Short.SetRange( 1, 31 );
181 451 : a0to59Short.SetRange( 0, 59 );
182 451 : a0to99Short.SetRange( 0, 99 );
183 451 : a0to9999Short.SetRange( 0, 9999 );
184 :
185 451 : aIdLong.SetRange( SAL_MIN_INT32, SAL_MAX_INT32 );
186 : }
187 : {
188 : // Variablenname fuer WinBits
189 451 : nWinBitVarId = aNmTb.Put( "_WinBits", VARNAME );
190 :
191 : // Windows
192 451 : nBorderId = pHS->getID( "WB_BORDER" );
193 451 : aWinBits.SetConstant( nBorderId, sal::static_int_cast<sal_Int32>(WB_BORDER) );
194 451 : nHideId = pHS->getID( "WB_HIDE" );
195 451 : aWinBits.SetConstant( nHideId, sal::static_int_cast<sal_Int32>(WB_HIDE) );
196 451 : nClipChildrenId = pHS->getID( "WB_CLIPCHILDREN" );
197 451 : aWinBits.SetConstant( nClipChildrenId, sal::static_int_cast<sal_Int32>(WB_CLIPCHILDREN) );
198 451 : nSizeableId = pHS->getID( "WB_SIZEABLE" );
199 451 : aWinBits.SetConstant( nSizeableId, sal::static_int_cast<sal_Int32>(WB_SIZEABLE) );
200 451 : nMoveableId = pHS->getID( "WB_MOVEABLE" );
201 451 : aWinBits.SetConstant( nMoveableId, sal::static_int_cast<sal_Int32>(WB_MOVEABLE) );
202 451 : nMinimizeId = pHS->getID( "WB_MINABLE" );
203 451 : aWinBits.SetConstant( nMinimizeId, 0 /*WB_MINABLE*/ );
204 451 : nMaximizeId = pHS->getID( "WB_MAXABLE" );
205 451 : aWinBits.SetConstant( nMaximizeId, 0 /*WB_MAXABLE*/ );
206 451 : nCloseableId = pHS->getID( "WB_CLOSEABLE" );
207 451 : aWinBits.SetConstant( nCloseableId, sal::static_int_cast<sal_Int32>(WB_CLOSEABLE) );
208 451 : nAppId = pHS->getID( "WB_APP" );
209 451 : aWinBits.SetConstant( nAppId, sal::static_int_cast<sal_Int32>(WB_APP) );
210 451 : nTabstopId = pHS->getID( "WB_TABSTOP" );
211 451 : aWinBits.SetConstant( nTabstopId, sal::static_int_cast<sal_Int32>(WB_TABSTOP) );
212 451 : nGroupId = pHS->getID( "WB_GROUP" );
213 451 : aWinBits.SetConstant( nGroupId, sal::static_int_cast<sal_Int32>(WB_GROUP) );
214 451 : nSysmodalId = pHS->getID( "WB_SYSMODAL" );
215 451 : aWinBits.SetConstant( nSysmodalId, 0 /*WB_SYSMODAL*/ );
216 : }
217 : {
218 451 : nLeftId = pHS->getID( "WB_LEFT" );
219 451 : aWinBits.SetConstant( nLeftId, sal::static_int_cast<sal_Int32>(WB_LEFT) );
220 451 : nCenterId = pHS->getID( "WB_CENTER" );
221 451 : aWinBits.SetConstant( nCenterId, sal::static_int_cast<sal_Int32>(WB_CENTER) );
222 451 : nRightId = pHS->getID( "WB_RIGHT" );
223 451 : aWinBits.SetConstant( nRightId, sal::static_int_cast<sal_Int32>(WB_RIGHT) );
224 451 : nTopId = pHS->getID( "WB_TOP" );
225 451 : aWinBits.SetConstant( nTopId, sal::static_int_cast<sal_Int32>(WB_TOP) );
226 451 : nVCenterId = pHS->getID( "WB_VCENTER" );
227 451 : aWinBits.SetConstant( nVCenterId, sal::static_int_cast<sal_Int32>(WB_VCENTER) );
228 451 : nBottomId = pHS->getID( "WB_BOTTOM" );
229 451 : aWinBits.SetConstant( nBottomId, sal::static_int_cast<sal_Int32>(WB_BOTTOM) );
230 451 : nHScrollId = pHS->getID( "WB_HSCROLL" );
231 451 : aWinBits.SetConstant( nHScrollId, sal::static_int_cast<sal_Int32>(WB_HSCROLL) );
232 451 : nVScrollId = pHS->getID( "WB_VSCROLL" );
233 451 : aWinBits.SetConstant( nVScrollId, sal::static_int_cast<sal_Int32>(WB_VSCROLL) );
234 451 : nSortId = pHS->getID( "WB_SORT" );
235 451 : aWinBits.SetConstant( nSortId, sal::static_int_cast<sal_Int32>(WB_SORT) );
236 451 : nDefaultId = pHS->getID( "WB_DEFBUTTON" );
237 451 : aWinBits.SetConstant( nDefaultId, sal::static_int_cast<sal_Int32>(WB_DEFBUTTON) );
238 451 : nRepeatId = pHS->getID( "WB_REPEAT" );
239 451 : aWinBits.SetConstant( nRepeatId, sal::static_int_cast<sal_Int32>(WB_REPEAT) );
240 451 : nSVLookId = pHS->getID( "WB_SVLOOK" );
241 451 : aWinBits.SetConstant( nSVLookId, sal::static_int_cast<sal_Int32>(WB_3DLOOK) );
242 451 : nDropDownId = pHS->getID( "WB_DROPDOWN" );
243 451 : aWinBits.SetConstant( nDropDownId, sal::static_int_cast<sal_Int32>(WB_DROPDOWN) );
244 451 : nPassWordId = pHS->getID( "WB_PASSWORD" );
245 451 : aWinBits.SetConstant( nPassWordId, sal::static_int_cast<sal_Int32>(WB_PASSWORD) );
246 451 : nReadOnlyId = pHS->getID( "WB_READONLY" );
247 451 : aWinBits.SetConstant( nReadOnlyId, sal::static_int_cast<sal_Int32>(WB_READONLY) );
248 451 : nAutoSizeId = pHS->getID( "WB_AUTOSIZE" );
249 451 : aWinBits.SetConstant( nAutoSizeId, sal::static_int_cast<sal_Int32>(WB_AUTOSIZE) );
250 451 : nSpinId = pHS->getID( "WB_SPIN" );
251 451 : aWinBits.SetConstant( nSpinId, sal::static_int_cast<sal_Int32>(WB_SPIN) );
252 451 : nTabControlId = pHS->getID( "WB_DIALOGCONTROL" );
253 451 : aWinBits.SetConstant( nTabControlId, sal::static_int_cast<sal_Int32>(WB_DIALOGCONTROL) );
254 451 : nSimpleModeId = pHS->getID( "WB_SIMPLEMODE" );
255 451 : aWinBits.SetConstant( nSimpleModeId, sal::static_int_cast<sal_Int32>(WB_SIMPLEMODE) );
256 451 : nDragId = pHS->getID( "WB_DRAG" );
257 451 : aWinBits.SetConstant( nDragId, sal::static_int_cast<sal_Int32>(WB_DRAG) );
258 451 : nScrollId = pHS->getID( "WB_SCROLL" );
259 451 : aWinBits.SetConstant( nScrollId, sal::static_int_cast<sal_Int32>(WB_SCROLL) );
260 451 : nZoomableId = pHS->getID( "WB_ZOOMABLE" );
261 451 : aWinBits.SetConstant( nZoomableId, sal::static_int_cast<sal_Int32>(WB_ROLLABLE) );
262 451 : nHideWhenDeactivateId = pHS->getID( "WB_HIDEWHENDEACTIVATE" );
263 451 : aWinBits.SetConstant( nHideWhenDeactivateId, 0 /*WB_HIDEWHENDEACTIVATE*/ );
264 451 : nAutoHScrollId = pHS->getID( "WB_AUTOHSCROLL" );
265 451 : aWinBits.SetConstant( nAutoHScrollId, sal::static_int_cast<sal_Int32>(WB_AUTOHSCROLL) );
266 451 : nAutoVScrollId = pHS->getID( "WB_AUTOVSCROLL" );
267 451 : aWinBits.SetConstant( nAutoVScrollId, sal::static_int_cast<sal_Int32>(WB_AUTOVSCROLL) );
268 451 : nDDExtraWidthId = pHS->getID( "WB_DDEXTRAWIDTH" );
269 451 : aWinBits.SetConstant( nDDExtraWidthId, 0 /*WB_DDEXTRAWIDTH*/ );
270 451 : nWordBreakId = pHS->getID( "WB_WORDBREAK" );
271 451 : aWinBits.SetConstant( nWordBreakId, sal::static_int_cast<sal_Int32>(WB_WORDBREAK) );
272 451 : nLeftLabelId = pHS->getID( "WB_LEFTLABEL" );
273 451 : aWinBits.SetConstant( nLeftLabelId, 0 /*WB_LEFTLABEL*/ );
274 451 : nHasLinesId = pHS->getID( "WB_HASLINES" );
275 451 : aWinBits.SetConstant( nHasLinesId, sal::static_int_cast<sal_Int32>(WB_HASLINES) );
276 451 : nHasButtonsId = pHS->getID( "WB_HASBUTTONS" );
277 451 : aWinBits.SetConstant( nHasButtonsId, sal::static_int_cast<sal_Int32>(WB_HASBUTTONS) );
278 451 : nRectStyleId = pHS->getID( "WB_RECTSTYLE" );
279 451 : aWinBits.SetConstant( nRectStyleId, sal::static_int_cast<sal_Int32>(WB_RECTSTYLE) );
280 451 : nLineSpacingId = pHS->getID( "WB_LINESPACING" );
281 451 : aWinBits.SetConstant( nLineSpacingId, sal::static_int_cast<sal_Int32>(WB_LINESPACING) );
282 451 : nSmallStyleId = pHS->getID( "WB_SMALLSTYLE" );
283 451 : aWinBits.SetConstant( nSmallStyleId, sal::static_int_cast<sal_Int32>(WB_SMALLSTYLE) );
284 451 : nEnableResizingId = pHS->getID( "WB_ENABLERESIZING" );
285 451 : aWinBits.SetConstant( nEnableResizingId, 0 /*WB_ENABLERESIZING*/ );
286 451 : nDockableId = pHS->getID( "WB_DOCKABLE" );
287 451 : aWinBits.SetConstant( nDockableId, sal::static_int_cast<sal_Int32>(WB_DOCKABLE) );
288 451 : nScaleId = pHS->getID( "WB_SCALE" );
289 451 : aWinBits.SetConstant( nScaleId, sal::static_int_cast<sal_Int32>(WB_SCALE) );
290 451 : nIgnoreTabId = pHS->getID( "WB_IGNORETAB" );
291 451 : aWinBits.SetConstant( nIgnoreTabId, sal::static_int_cast<sal_Int32>(WB_IGNORETAB) );
292 451 : nNoSplitDrawId = pHS->getID( "WB_NOSPLITDRAW" );
293 451 : aWinBits.SetConstant( nNoSplitDrawId, sal::static_int_cast<sal_Int32>(WB_NOSPLITDRAW) );
294 451 : nTopImageId = pHS->getID( "WB_TOPIMAGE" );
295 451 : aWinBits.SetConstant( nTopImageId, sal::static_int_cast<sal_Int32>(WB_TOPIMAGE) );
296 451 : nNoLabelId = pHS->getID( "WB_NOLABEL" );
297 451 : aWinBits.SetConstant( nNoLabelId, sal::static_int_cast<sal_Int32>(WB_NOLABEL) );
298 451 : nVertId = pHS->getID( "WB_VERT" );
299 451 : aWinBits.SetConstant( nVertId, sal::static_int_cast<sal_Int32>(WB_VERT) );
300 451 : nSysWinId = pHS->getID( "WB_SYSTEMWINDOW" );
301 451 : aWinBits.SetConstant( nSysWinId, sal::static_int_cast<sal_Int32>(WB_SYSTEMWINDOW) );
302 451 : nStdPopupId = pHS->getID( "WB_STDPOPUP" );
303 451 : aWinBits.SetConstant( nStdPopupId, sal::static_int_cast<sal_Int32>(WB_STDPOPUP) );
304 : }
305 : {
306 451 : InitLangType();
307 451 : aBaseLst.push_back( pFieldUnits = InitFieldUnitsType() );
308 451 : aBaseLst.push_back( pTimeFieldFormat = InitTimeFieldFormat() );
309 451 : aBaseLst.push_back( pColor = InitColor() );
310 451 : aBaseLst.push_back( pMapUnit = InitMapUnit() );
311 451 : aBaseLst.push_back( pKey = InitKey() );
312 451 : aBaseLst.push_back( pTriState = InitTriState() );
313 451 : aBaseLst.push_back( pMessButtons = InitMessButtons() );
314 451 : aBaseLst.push_back( pMessDefButton = InitMessDefButton() );
315 :
316 451 : aBaseLst.push_back( pGeometry = InitGeometry() );
317 451 : aBaseLst.push_back( pLangGeometry = InitLangGeometry( pGeometry ) );
318 451 : aBaseLst.push_back( pStringList = InitStringList() );
319 451 : aBaseLst.push_back( pLangStringList = InitLangStringList( pStringList ) );
320 451 : aBaseLst.push_back( pStringTupel = InitStringTupel() );
321 451 : aBaseLst.push_back( pStringTupelList = InitStringTupelList( pStringTupel ) );
322 451 : aBaseLst.push_back( InitLangStringTupelList( pStringTupelList ) );
323 451 : aBaseLst.push_back( pStringLongTupel = InitStringLongTupel() );
324 451 : aBaseLst.push_back( pStringLongTupelList = InitStringLongTupelList( pStringLongTupel ) );
325 451 : aBaseLst.push_back( pLangStringLongTupelList = InitLangStringLongTupelList( pStringLongTupelList ) );
326 : }
327 : {
328 451 : pRoot = pClassMgr = InitClassMgr();
329 :
330 902 : aVersion.pClass = new RscClass( pHS->getID( "VersionControl" ),
331 451 : RSC_VERSIONCONTROL, pClassMgr );
332 451 : aVersion = aVersion.pClass->Create( NULL, RSCINST() );
333 :
334 451 : pClassString = InitClassString( pClassMgr );
335 451 : pRoot->Insert( pClassString );
336 :
337 : // String als Referenzklasse des Basisstrings einsetzen
338 451 : aString.SetRefClass( pClassString );
339 :
340 : // Klasse anlegen
341 451 : nId = pHS->getID( "StringArray" );
342 451 : pClassStringArray = new RscClass( nId, RSC_STRINGARRAY, pClassMgr );
343 451 : pClassStringArray->SetCallPar( *pStdPar1, *pStdPar2, *pStdParType );
344 451 : aNmTb.Put( nId, CLASSNAME, pClassStringArray );
345 451 : pRoot->Insert( pClassStringArray );
346 :
347 : // Variablen anlegen
348 451 : nId = aNmTb.Put( "ItemList", VARNAME );
349 451 : pClassStringArray->SetVariable( nId, pLangStringLongTupelList );
350 :
351 451 : pClassBitmap = InitClassBitmap( pClassMgr );
352 451 : pRoot->Insert( pClassBitmap );
353 :
354 : }
355 : {
356 451 : pClassColor = InitClassColor( pClassMgr, pColor );
357 451 : pRoot->Insert( pClassColor );
358 :
359 451 : pClassImage = InitClassImage( pClassMgr, pClassBitmap, pClassColor );
360 451 : pRoot->Insert( pClassImage );
361 :
362 : pClassImageList = InitClassImageList( pClassMgr,
363 451 : pClassColor, pStringLongTupelList );
364 451 : pRoot->Insert( pClassImageList );
365 :
366 : pClassWindow = InitClassWindow( pClassMgr, pMapUnit,
367 451 : pLangGeometry );
368 451 : pRoot->Insert( pClassWindow );
369 : }
370 : {
371 :
372 451 : pClassSystemWindow = InitClassSystemWindow( pClassWindow );
373 : //aBaseLst.Insert( pClassSystemWindow, LIST_APPEND );
374 451 : pRoot->Insert( pClassSystemWindow );
375 :
376 451 : pClassWorkWindow = InitClassWorkWindow( pClassSystemWindow );
377 451 : pRoot->Insert( pClassWorkWindow );
378 :
379 : // Klasse anlegen
380 902 : pClassDialog = new RscClass( pHS->getID( "Dialog" ),
381 451 : RSC_DIALOG, pClassSystemWindow );
382 451 : pClassDialog->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
383 451 : aBaseLst.push_back( pClassDialog );
384 :
385 : // Klasse anlegen
386 451 : pClassModalDialog = InitClassModalDialog( pClassDialog );
387 451 : pRoot->Insert( pClassModalDialog );
388 :
389 : // Klasse anlegen
390 451 : pClassModelessDialog = InitClassModelessDialog( pClassDialog );
391 451 : pRoot->Insert( pClassModelessDialog );
392 : }
393 : {
394 451 : pClassControl = InitClassControl( pClassWindow );
395 451 : pRoot->Insert( pClassControl );
396 :
397 : // Klasse anlegen
398 451 : nId = pHS->getID( "Button" );
399 451 : pClassButton = new RscClass( nId, RSC_BUTTON, pClassControl );
400 451 : pClassButton->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
401 451 : aNmTb.Put( nId, CLASSNAME, pClassButton );
402 451 : pRoot->Insert( pClassButton );
403 :
404 451 : pClassCheckBox = InitClassCheckBox( pClassButton );
405 451 : pRoot->Insert( pClassCheckBox );
406 :
407 : // Klasse anlegen
408 451 : pClassPushButton = InitClassPushButton( pClassButton );
409 451 : pRoot->Insert( pClassPushButton );
410 :
411 : // Klasse anlegen
412 451 : nId = pHS->getID( "HelpButton" );
413 : pClassHelpButton = new RscClass( nId, RSC_HELPBUTTON,
414 451 : pClassPushButton );
415 451 : pClassHelpButton->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
416 451 : aNmTb.Put( nId, CLASSNAME, pClassHelpButton );
417 451 : pRoot->Insert( pClassHelpButton );
418 :
419 : // Klasse anlegen
420 451 : nId = pHS->getID( "OKButton" );
421 : pClassOKButton = new RscClass( nId, RSC_OKBUTTON,
422 451 : pClassPushButton );
423 451 : pClassOKButton->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
424 451 : aNmTb.Put( nId, CLASSNAME, pClassOKButton );
425 451 : pRoot->Insert( pClassOKButton );
426 :
427 : // Klasse anlegen
428 451 : nId = pHS->getID( "CancelButton" );
429 : pClassCancelButton = new RscClass( nId, RSC_CANCELBUTTON,
430 451 : pClassPushButton );
431 451 : pClassCancelButton->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
432 451 : aNmTb.Put( nId, CLASSNAME, pClassCancelButton );
433 451 : pRoot->Insert( pClassCancelButton );
434 : }
435 : {
436 451 : pClassRadioButton = InitClassRadioButton( pClassButton );
437 451 : pRoot->Insert( pClassRadioButton );
438 :
439 451 : pClassTriStateBox = InitClassTriStateBox( pClassControl, pTriState );
440 451 : pRoot->Insert( pClassTriStateBox );
441 :
442 : pClassImageButton = InitClassImageButton( pClassPushButton,
443 451 : pClassImage, pTriState );
444 451 : pRoot->Insert( pClassImageButton );
445 :
446 451 : pClassEdit = InitClassEdit( pClassControl );
447 451 : pRoot->Insert( pClassEdit );
448 :
449 451 : pClassMultiLineEdit = InitClassMultiLineEdit( pClassEdit );
450 451 : pRoot->Insert( pClassMultiLineEdit );
451 :
452 451 : pClassScrollBar = InitClassScrollBar( pClassControl );
453 451 : pRoot->Insert( pClassScrollBar );
454 :
455 : }
456 : {
457 451 : pClassListBox = InitClassListBox( pClassControl, pLangStringLongTupelList );
458 451 : pRoot->Insert( pClassListBox );
459 :
460 451 : pClassMultiListBox = InitClassMultiListBox( pClassListBox);
461 451 : pRoot->Insert( pClassMultiListBox );
462 :
463 451 : pClassComboBox = InitClassComboBox( pClassEdit, pLangStringList );
464 451 : pRoot->Insert( pClassComboBox );
465 :
466 451 : pClassFixedText = InitClassFixedText( pClassControl );
467 451 : pRoot->Insert( pClassFixedText );
468 :
469 451 : pClassFixedBitmap = InitClassFixedBitmap( pClassControl, pClassBitmap );
470 451 : pRoot->Insert( pClassFixedBitmap );
471 :
472 451 : pClassFixedImage = InitClassFixedImage( pClassControl, pClassImage );
473 451 : pRoot->Insert( pClassFixedImage );
474 :
475 : // Klasse anlegen
476 451 : nId = pHS->getID( "GroupBox" );
477 451 : pClassGroupBox = new RscClass( nId, RSC_GROUPBOX, pClassControl );
478 451 : pClassGroupBox->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
479 451 : aNmTb.Put( nId, CLASSNAME, pClassGroupBox );
480 451 : pRoot->Insert( pClassGroupBox );
481 :
482 451 : pClassKeyCode = InitClassKeyCode( pClassMgr, pKey );
483 451 : pRoot->Insert( pClassKeyCode );
484 : {
485 902 : pLangClassKeyCode = new RscClassArray( pHS->getID( "LangKeyCode" ),
486 451 : RSC_KEYCODE, pClassKeyCode, &aLangType );
487 451 : aBaseLst.push_back( pLangClassKeyCode );
488 : }
489 :
490 451 : pClassAccelItem = InitClassAccelItem( pClassMgr, pLangClassKeyCode );
491 451 : pRoot->Insert( pClassAccelItem );
492 : }
493 : {
494 451 : pClassAccel = InitClassAccel( pClassMgr, pClassAccelItem );
495 451 : pRoot->Insert( pClassAccel );
496 451 : nAcceleratorType = pClassAccel->GetId();
497 :
498 : // pClassAccel ist erst hier definiert
499 451 : nId = aNmTb.Put( "SubAccelerator", VARNAME );
500 : pClassAccelItem->SetVariable( nId, pClassAccel, NULL, VAR_SVDYNAMIC,
501 451 : ACCELITEM_ACCEL );
502 :
503 : pClassMenuItem = InitClassMenuItem( pClassMgr, pClassBitmap,
504 451 : pLangClassKeyCode );
505 451 : pRoot->Insert( pClassMenuItem );
506 :
507 451 : pClassMenu = InitClassMenu( pClassMgr, pClassMenuItem );
508 451 : pRoot->Insert( pClassMenu );
509 :
510 : // pClassMenu ist erst hier definiert
511 451 : nId = aNmTb.Put( "SubMenu", VARNAME );
512 : pClassMenuItem->SetVariable( nId, pClassMenu, NULL, VAR_SVDYNAMIC,
513 451 : RSC_MENUITEM_MENU );
514 :
515 451 : pClassMenuButton = InitClassMenuButton( pClassControl, pClassMenu );
516 451 : pRoot->Insert( pClassMenuButton );
517 :
518 : pClassMessBox = InitClassMessBox( pClassMgr, pMessButtons,
519 451 : pMessDefButton );
520 451 : pRoot->Insert( pClassMessBox );
521 :
522 : // Klasse anlegen
523 451 : nId = pHS->getID( "InfoBox" );
524 451 : pClassInfoBox = new RscClass( nId, RSC_INFOBOX, pClassMessBox );
525 451 : pClassInfoBox->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
526 451 : aNmTb.Put( nId, CLASSNAME, pClassInfoBox );
527 451 : pRoot->Insert( pClassInfoBox );
528 :
529 : // Klasse anlegen
530 451 : nId = pHS->getID( "WarningBox" );
531 451 : pClassWarningBox = new RscClass( nId, RSC_WARNINGBOX, pClassMessBox );
532 451 : pClassWarningBox->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
533 451 : aNmTb.Put( nId, CLASSNAME, pClassWarningBox );
534 451 : pRoot->Insert( pClassWarningBox );
535 :
536 : // Klasse anlegen
537 451 : nId = pHS->getID( "ErrorBox" );
538 451 : pClassErrorBox = new RscClass( nId, RSC_ERRORBOX, pClassMessBox );
539 451 : pClassErrorBox->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
540 451 : aNmTb.Put( nId, CLASSNAME, pClassErrorBox );
541 451 : pRoot->Insert( pClassErrorBox );
542 :
543 : // Klasse anlegen
544 451 : nId = pHS->getID( "QueryBox" );
545 451 : pClassQueryBox = new RscClass( nId, RSC_QUERYBOX, pClassMessBox );
546 451 : pClassQueryBox->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
547 451 : aNmTb.Put( nId, CLASSNAME, pClassQueryBox );
548 451 : pRoot->Insert( pClassQueryBox );
549 : }
550 : {
551 451 : pClassSplitter = InitClassSplitter( pClassWindow );
552 451 : pRoot->Insert( pClassSplitter );
553 :
554 451 : pClassSplitWindow = InitClassSplitWindow( pClassWindow );
555 451 : pRoot->Insert( pClassSplitWindow );
556 :
557 : // Klasse anlegen
558 451 : nId = pHS->getID( "SpinButton" );
559 451 : pClassSpinButton = new RscClass( nId, RSC_SPINBUTTON, pClassControl );
560 451 : pClassSpinButton->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
561 451 : aNmTb.Put( nId, CLASSNAME, pClassSpinButton );
562 : {
563 : RscClient * pClient;
564 :
565 : // Clientvariablen einfuegen
566 : // Sysmodal
567 : aBaseLst.push_back(
568 1353 : pClient = new RscClient( pHS->getID( "sal_Bool" ), RSC_NOTYPE, &aWinBits, nRepeatId )
569 902 : );
570 451 : nId = aNmTb.Put( "Repeat", VARNAME );
571 : pClassSpinButton->SetVariable( nId, pClient, NULL,
572 451 : VAR_NODATAINST, 0, nWinBitVarId );
573 : }
574 451 : pRoot->Insert( pClassSpinButton );
575 : }
576 : {
577 451 : pClassTime = InitClassTime( pClassMgr );
578 451 : pRoot->Insert( pClassTime );
579 :
580 451 : pClassDate = InitClassDate( pClassMgr );
581 451 : pRoot->Insert( pClassDate );
582 : }
583 : {
584 451 : pClassSpinField = InitClassSpinField( pClassEdit );
585 451 : pRoot->Insert( pClassSpinField );
586 : }
587 : {
588 : { // Mehrfachvererbung von Hand
589 451 : RscTop * pClassTmp = InitClassPatternFormatter( pClassSpinField );
590 451 : aBaseLst.push_back( pClassTmp );
591 :
592 451 : pClassPatternField = InitClassPatternField( pClassTmp );
593 451 : pRoot->Insert( pClassPatternField );
594 : }
595 : { // Mehrfachvererbung von Hand
596 451 : RscTop * pClassTmp = InitClassNumericFormatter( pClassSpinField );
597 451 : aBaseLst.push_back( pClassTmp );
598 :
599 451 : pClassNumericField = InitClassNumericField( pClassTmp );
600 451 : pRoot->Insert( pClassNumericField );
601 : }
602 : { // Mehrfachvererbung von Hand
603 451 : RscTop * pClassTmp = InitClassNumericFormatter( pClassSpinField );
604 451 : aBaseLst.push_back( pClassTmp );
605 451 : pClassTmp = InitClassMetricFormatter( pClassTmp, pFieldUnits );
606 451 : aBaseLst.push_back( pClassTmp );
607 :
608 451 : pClassMetricField = InitClassMetricField( pClassTmp );
609 451 : pRoot->Insert( pClassMetricField );
610 : }
611 : { // Mehrfachvererbung von Hand
612 451 : RscTop * pClassTmp = InitClassDateFormatter( pClassSpinField, pClassDate );
613 451 : aBaseLst.push_back( pClassTmp );
614 :
615 451 : pClassDateField = InitClassDateField( pClassTmp, pClassDate );
616 451 : pRoot->Insert( pClassDateField );
617 : }
618 : { // Mehrfachvererbung von Hand
619 : RscTop * pClassTmp = InitClassTimeFormatter( pClassSpinField, pClassTime,
620 451 : pTimeFieldFormat );
621 451 : aBaseLst.push_back( pClassTmp );
622 :
623 451 : pClassTimeField = InitClassTimeField( pClassTmp, pClassTime );
624 451 : pRoot->Insert( pClassTimeField );
625 : }
626 : { // Mehrfachvererbung von Hand
627 451 : RscTop * pClassTmp = InitClassPatternFormatter( pClassComboBox );
628 451 : aBaseLst.push_back( pClassTmp );
629 :
630 451 : pClassPatternBox = InitClassPatternBox( pClassTmp );
631 451 : pRoot->Insert( pClassPatternBox );
632 : }
633 : { // Mehrfachvererbung von Hand
634 451 : RscTop * pClassTmp = InitClassNumericFormatter( pClassComboBox );
635 451 : aBaseLst.push_back( pClassTmp );
636 :
637 451 : pClassNumericBox = InitClassNumericBox( pClassTmp );
638 451 : pRoot->Insert( pClassNumericBox );
639 : }
640 : }
641 : {
642 451 : pClassDockingWindow = InitClassDockingWindow( pClassWindow, pMapUnit );
643 451 : pRoot->Insert( pClassDockingWindow );
644 :
645 : pClassToolBoxItem = InitClassToolBoxItem( pClassMgr, pClassBitmap,
646 451 : pClassImage, pTriState );
647 451 : pRoot->Insert( pClassToolBoxItem );
648 :
649 : pClassToolBox = InitClassToolBox( pClassDockingWindow, pClassToolBoxItem,
650 451 : pClassImageList );
651 451 : pRoot->Insert( pClassToolBox );
652 :
653 451 : pClassStatusBar = InitClassStatusBar( pClassWindow );
654 451 : pRoot->Insert( pClassStatusBar );
655 :
656 : pClassFloatingWindow = InitClassFloatingWindow( pClassSystemWindow,
657 451 : pMapUnit );
658 451 : pRoot->Insert( pClassFloatingWindow );
659 :
660 : // Klasse anlegen
661 451 : nId = pHS->getID( "TabPage" );
662 : pClassTabPage =
663 451 : new RscClass( nId, RSC_TABPAGE, pClassWindow );
664 451 : pClassTabPage->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
665 451 : aNmTb.Put( nId, CLASSNAME, pClassTabPage );
666 451 : pRoot->Insert( pClassTabPage );
667 :
668 : // Klasse anlegen
669 451 : nId = pHS->getID( "TabDialog" );
670 : pClassTabDialog =
671 451 : new RscClass( nId, RSC_TABDIALOG, pClassModalDialog );
672 451 : pClassTabDialog->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
673 451 : aNmTb.Put( nId, CLASSNAME, pClassTabDialog );
674 451 : pRoot->Insert( pClassTabDialog );
675 :
676 451 : pClassTabControlItem = InitClassTabControlItem( pClassMgr );
677 451 : pRoot->Insert( pClassTabControlItem );
678 :
679 : pClassTabControl = InitClassTabControl( pClassControl,
680 451 : pClassTabControlItem );
681 451 : pRoot->Insert( pClassTabControl );
682 :
683 : // Klasse anlegen
684 451 : nId = pHS->getID( "FixedLine" );
685 : pClassFixedLine =
686 451 : new RscClass( nId, RSC_FIXEDLINE, pClassControl );
687 451 : pClassFixedLine->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
688 :
689 451 : INS_WINBIT(pClassFixedLine,Vert)
690 :
691 451 : aNmTb.Put( nId, CLASSNAME, pClassFixedLine );
692 451 : pRoot->Insert( pClassFixedLine );
693 :
694 : // Klasse anlegen
695 451 : nId = pHS->getID( "ScrollBarBox" );
696 : pClassScrollBarBox =
697 451 : new RscClass( nId, RSC_SCROLLBARBOX, pClassWindow );
698 451 : pClassScrollBarBox->SetCallPar( *pWinPar1, *pWinPar2, *pWinParType );
699 451 : aNmTb.Put( nId, CLASSNAME, pClassScrollBarBox );
700 451 : pRoot->Insert( pClassScrollBarBox );
701 451 : INS_WINBIT(pClassScrollBarBox,Sizeable)
702 :
703 : pClassSfxStyleFamilyItem = InitClassSfxStyleFamilyItem( pClassMgr,
704 : pClassBitmap,
705 : pClassImage,
706 451 : pLangStringLongTupelList );
707 451 : pRoot->Insert( pClassSfxStyleFamilyItem );
708 :
709 : pClassSfxTemplateDialog = InitClassSfxTemplateDialog( pClassMgr,
710 451 : pClassSfxStyleFamilyItem );
711 451 : pRoot->Insert( pClassSfxTemplateDialog );
712 :
713 451 : pClassSfxSlotInfo = InitClassSfxSlotInfo( pClassMgr );
714 451 : pRoot->Insert( pClassSfxSlotInfo );
715 : }
716 :
717 451 : aNmTb.SetSort();
718 451 : }
719 :
720 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
