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