Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*************************************************************************
3 : *
4 : * The Contents of this file are made available subject to the terms of
5 : * either of the following licenses
6 : *
7 : * - GNU Lesser General Public License Version 2.1
8 : * - Sun Industry Standards Source License Version 1.1
9 : *
10 : * Sun Microsystems Inc., October, 2000
11 : *
12 : * GNU Lesser General Public License Version 2.1
13 : * =============================================
14 : * Copyright 2000 by Sun Microsystems, Inc.
15 : * 901 San Antonio Road, Palo Alto, CA 94303, USA
16 : *
17 : * This library is free software; you can redistribute it and/or
18 : * modify it under the terms of the GNU Lesser General Public
19 : * License version 2.1, as published by the Free Software Foundation.
20 : *
21 : * This library is distributed in the hope that it will be useful,
22 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
24 : * Lesser General Public License for more details.
25 : *
26 : * You should have received a copy of the GNU Lesser General Public
27 : * License along with this library; if not, write to the Free Software
28 : * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
29 : * MA 02111-1307 USA
30 : *
31 : *
32 : * Sun Industry Standards Source License Version 1.1
33 : * =================================================
34 : * The contents of this file are subject to the Sun Industry Standards
35 : * Source License Version 1.1 (the "License"); You may not use this file
36 : * except in compliance with the License. You may obtain a copy of the
37 : * License at http://www.openoffice.org/license.html.
38 : *
39 : * Software provided under this License is provided on an "AS IS" basis,
40 : * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
41 : * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
42 : * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
43 : * See the License for the specific provisions governing your rights and
44 : * obligations concerning the Software.
45 : *
46 : * The Initial Developer of the Original Code is: IBM Corporation
47 : *
48 : * Copyright: 2008 by IBM Corporation
49 : *
50 : * All Rights Reserved.
51 : *
52 : * Contributor(s): _______________________________________
53 : *
54 : *
55 : ************************************************************************/
56 : #include "first.hxx"
57 : #include "assert.h"
58 : #include <stdio.h>
59 : #include <sot/storinfo.hxx>
60 : namespace OpenStormBento
61 : {
62 :
63 : // String definitions
64 : const char gsBenMagicBytes[] = BEN_MAGIC_BYTES;
65 :
66 : /**
67 : * New bento container from file stream
68 : * @param pointer to length of bento file
69 : * @param pointer to pointer of Bento Container object
70 : * @return error code
71 : */
72 8 : sal_uLong BenOpenContainer(LwpSvStream * pStream, pLtcBenContainer * ppContainer)
73 : {
74 : BenError Err;
75 :
76 8 : *ppContainer = NULL;
77 :
78 8 : if (NULL == pStream)
79 : {
80 0 : return BenErr_ContainerWithNoObjects;
81 : }
82 :
83 8 : pLtcBenContainer pContainer = new LtcBenContainer(pStream);
84 8 : if ((Err = pContainer->Open()) != BenErr_OK) // delete two inputs
85 : {
86 0 : delete pContainer;
87 0 : return BenErr_InvalidTOC;
88 : }
89 :
90 8 : *ppContainer = pContainer;
91 8 : return BenErr_OK;
92 : }
93 : BenError
94 8 : LtcBenContainer::Close()
95 : {
96 8 : return BenErr_OK;
97 : }
98 :
99 16 : LtcBenContainer::~LtcBenContainer()
100 : {
101 8 : Close();
102 8 : }
103 :
104 : BenError
105 8 : LtcBenContainer::Open() // delete two inputs
106 : {
107 : BenError Err;
108 8 : CBenTOCReader TOCReader(this);
109 8 : if ((Err = TOCReader.ReadLabelAndTOC()) != BenErr_OK)
110 : {
111 0 : return Err;
112 : }
113 8 : return BenErr_OK;
114 : }
115 :
116 : BenError
117 16 : LtcBenContainer::RegisterPropertyName(const char * sPropertyName,
118 : pCBenPropertyName * ppPropertyName)
119 : {
120 : pCUtListElmt pPrevNamedObjectListElmt;
121 : pCBenNamedObject pNamedObject = FindNamedObject(&cNamedObjects,
122 16 : sPropertyName, &pPrevNamedObjectListElmt);
123 :
124 16 : if (pNamedObject != NULL)
125 : {
126 0 : if (! pNamedObject->IsPropertyName())
127 0 : return BenErr_NameConflict;
128 0 : else *ppPropertyName = static_cast<pCBenPropertyName>(pNamedObject);
129 : }
130 : else
131 : {
132 : pCUtListElmt pPrevObject;
133 16 : if (FindID(&cObjects, cNextAvailObjectID, &pPrevObject) != NULL)
134 0 : return BenErr_DuplicateObjectID;
135 :
136 : *ppPropertyName = new CBenPropertyName(this, cNextAvailObjectID,
137 16 : static_cast<pCBenObject>(pPrevObject), sPropertyName, pPrevNamedObjectListElmt);
138 16 : ++cNextAvailObjectID;
139 : }
140 :
141 16 : return BenErr_OK;
142 : }
143 :
144 : pCBenObject
145 824 : LtcBenContainer::GetNextObject(pCBenObject pCurrObject)
146 : {
147 824 : return static_cast<pCBenObject>(cObjects.GetNextOrNULL(pCurrObject));
148 : }
149 :
150 : pCBenObject
151 16 : LtcBenContainer::FindNextObjectWithProperty(pCBenObject pCurrObject,
152 : BenObjectID PropertyID)
153 : {
154 840 : while ((pCurrObject = GetNextObject(pCurrObject)) != NULL)
155 808 : if (pCurrObject->UseProperty(PropertyID) != NULL)
156 0 : return pCurrObject;
157 :
158 16 : return NULL;
159 : }
160 :
161 : /**
162 : * Construction
163 : * @param Bento file stream pointer
164 : * @return
165 : */
166 8 : LtcBenContainer::LtcBenContainer(LwpSvStream * pStream)
167 8 : : cNextAvailObjectID(0)
168 : {
169 8 : cpStream = pStream;
170 8 : pStream->Seek(STREAM_SEEK_TO_END);
171 8 : m_ulLength = pStream->Tell();
172 8 : pStream->Seek(STREAM_SEEK_TO_BEGIN);
173 8 : }
174 :
175 : /**
176 : * Read buffer fro bento file with specified buffer
177 : * @date 07/05/2004
178 : * @param buffer pointer
179 : * @param buffer size
180 : * @param number of bytes read
181 : * @return BenError
182 : */
183 0 : BenError LtcBenContainer::Read(BenDataPtr pBuffer, unsigned long MaxSize,
184 : unsigned long * pAmtRead)
185 : {
186 0 : *pAmtRead = cpStream->Read(pBuffer, MaxSize);
187 0 : return BenErr_OK;
188 : }
189 : /**
190 : * Read buffer from bento file with specified size
191 : * @date 07/05/2004
192 : * @param buffer pointer
193 : * @param number of bytes to be read
194 : * @return BenError
195 : */
196 124 : BenError LtcBenContainer::ReadKnownSize(BenDataPtr pBuffer, unsigned long Amt)
197 : {
198 : sal_uLong ulLength;
199 124 : ulLength = cpStream->Read(pBuffer, Amt);
200 124 : if(ulLength == Amt)
201 : {
202 124 : return BenErr_OK;
203 : }
204 0 : return BenErr_ReadPastEndOfContainer;
205 : }
206 : /**
207 : * Seek to position from the beginning of the bento file
208 : * @date 07/05/2004
209 : * @param position in container file from beginning
210 : * @return BenError
211 : */
212 116 : BenError LtcBenContainer::SeekToPosition(BenContainerPos Pos)
213 : {
214 116 : cpStream->Seek(Pos);
215 116 : return BenErr_OK;
216 : }
217 : /**
218 : * Seek to position compare to end of bento file
219 : * @date 07/05/2004
220 : * @param position in container file from end
221 : * @return BenError
222 : */
223 8 : BenError LtcBenContainer::SeekFromEnd(long Offset)
224 : {
225 8 : cpStream->Seek(STREAM_SEEK_TO_END);
226 8 : cpStream->SeekRel(Offset);
227 :
228 8 : return BenErr_OK;
229 : }
230 : /**
231 : * Find the next value stream with property name
232 : * @date 07/05/2004
233 : * @param string of property name
234 : * @param current value stream pointer with the property name
235 : * @return next value stream pointer with the property names
236 : */
237 16 : LtcUtBenValueStream * LtcBenContainer::FindNextValueStreamWithPropertyName(const char * sPropertyName, LtcUtBenValueStream * pCurrentValueStream)
238 : {
239 : CBenPropertyName * pPropertyName;
240 16 : RegisterPropertyName(sPropertyName, &pPropertyName); // Get property name object
241 :
242 16 : if (NULL == pPropertyName)
243 0 : return NULL; // Property not exist
244 :
245 : // Get current object
246 16 : CBenObject * pObj = NULL;
247 16 : if (pCurrentValueStream != NULL)
248 : {
249 0 : pObj = pCurrentValueStream->GetValue()->GetProperty()->GetBenObject();
250 : }
251 :
252 16 : pObj =FindNextObjectWithProperty(pObj, pPropertyName->GetID()); // Get next object with same property name
253 16 : if (NULL == pObj)
254 16 : return NULL;
255 :
256 : CBenValue * pValue;
257 : LtcUtBenValueStream * pValueStream;
258 :
259 0 : pValue = pObj->UseValue(pPropertyName->GetID());
260 :
261 0 : pValueStream = new LtcUtBenValueStream(pValue);
262 :
263 0 : return pValueStream;
264 : }
265 :
266 : /**
267 : * Find the unique value stream with property name
268 : * @date 07/05/2004
269 : * @param string of property name
270 : * @return the only value stream pointer with the property names
271 : */
272 16 : LtcUtBenValueStream * LtcBenContainer::FindValueStreamWithPropertyName(const char * sPropertyName)
273 : {
274 16 : return FindNextValueStreamWithPropertyName(sPropertyName, NULL);
275 : }
276 : /**
277 : * <description>
278 : * @date 07/05/2004
279 : * @param pointer to length of bento file
280 : * @return BenError
281 : */
282 8 : BenError LtcBenContainer::GetSize(sal_uLong * pLength)
283 : {
284 8 : *pLength = m_ulLength;
285 8 : return BenErr_OK;
286 : }
287 :
288 0 : sal_uInt32 GetSvStreamSize(SvStream * pStream)
289 : {
290 0 : sal_uInt32 nCurPos = pStream->Tell();
291 0 : pStream->Seek(STREAM_SEEK_TO_END);
292 0 : sal_uInt32 ulLength = pStream->Tell();
293 0 : pStream->Seek(nCurPos);
294 :
295 0 : return ulLength;
296 : }
297 :
298 : /**
299 : * Find hazily according to object ID
300 : * @date 01/31/2005
301 : * @param pObjectname - format as "GrXX,XXXXXXXX" wherein XX is high part of object ID, and XXXXXXXX is low part
302 : * @return the value stream pointers with the property names
303 : */
304 8 : BenError LtcBenContainer::CreateGraphicStream(SvStream * &pStream, const char *pObjectName)
305 : {
306 8 : if (!pObjectName)
307 : {
308 0 : pStream = NULL;
309 0 : return BenErr_NamedObjectError;
310 : }
311 : // construct the string of property name
312 8 : char sSName[64]="";
313 8 : char sDName[64]="";
314 :
315 8 : sprintf(sSName, "%s-S", pObjectName);
316 8 : sprintf(sDName, "%s-D", pObjectName);
317 :
318 : /* traverse the found properties and construct the stream vectors */
319 8 : SvMemoryStream * pMemStream = NULL;
320 : // get S&D's stream and merge them together
321 8 : SvStream *pD = NULL, *pS = NULL;
322 :
323 8 : pS = FindValueStreamWithPropertyName(sSName);
324 8 : pD = FindValueStreamWithPropertyName(sDName);
325 :
326 8 : sal_uInt32 nDLen = 0;
327 8 : if(pD)
328 : {
329 0 : nDLen = GetSvStreamSize(pD);
330 : }
331 8 : sal_uInt32 nLen = nDLen;
332 8 : if(pS)
333 : {
334 0 : nLen += GetSvStreamSize(pS) ;
335 : }
336 :
337 : OSL_ENSURE(nLen > 0, "expected a non-0 length");
338 : // the 'D' stream is NULL or it has invalid length
339 8 : if (nLen <= 0)
340 : {
341 8 : pStream = NULL;
342 8 : return BenErr_NamedObjectError;
343 : }
344 :
345 0 : char * pBuf = new char[nLen];
346 : assert(pBuf != NULL);
347 0 : char * pPointer = pBuf;
348 0 : if(pD)
349 : {
350 0 : pD->Read(pPointer, nDLen);
351 0 : delete pD;
352 : }
353 0 : pPointer += nDLen;
354 0 : if(pS)
355 : {
356 0 : pS->Read(pPointer, nLen - nDLen);
357 0 : delete pS;
358 : }
359 :
360 0 : pMemStream = new SvMemoryStream(pBuf, nLen, STREAM_READ);
361 : assert(pMemStream != NULL);
362 :
363 0 : pStream = pMemStream;
364 0 : return BenErr_OK;
365 : }
366 :
367 : }// end namespace OpenStormBento
368 :
369 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
