summaryrefslogtreecommitdiff
path: root/include/sot/storage.hxx
blob: d2e56c6caf0e7d377030c26bf3c1ab43d321f036 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */

#ifndef INCLUDED_SOT_STORAGE_HXX
#define INCLUDED_SOT_STORAGE_HXX

#include <com/sun/star/uno/Any.hxx>
#include <com/sun/star/uno/Reference.h>
#include <com/sun/star/embed/XStorage.hpp>
#include <sot/object.hxx>
#include <tools/stream.hxx>
#include <tools/errcode.hxx>
#include <sot/storinfo.hxx>
#include <sot/sotdllapi.h>

enum class SotClipboardFormatId : sal_uLong;

class SotStorage;
class BaseStorageStream;
class SOT_DLLPUBLIC SotStorageStream : virtual public SotObject, public SvStream
{
friend class SotStorage;
    BaseStorageStream * pOwnStm; // pointer to the own stream
protected:
    virtual sal_uLong       GetData( void* pData, sal_uLong nSize ) override;
    virtual sal_uLong       PutData( const void* pData, sal_uLong nSize ) override;
    virtual sal_uInt64      SeekPos(sal_uInt64 nPos) override;
    virtual void        FlushData() override;
                        virtual ~SotStorageStream();
public:
                        SotStorageStream( const OUString &,
                                          StreamMode = StreamMode::STD_READWRITE );
                        SotStorageStream( BaseStorageStream *pStm );

    virtual void        ResetError() override;

    virtual void        SetSize( sal_uInt64 nNewSize ) override;
    sal_uInt32          GetSize() const;
    void                CopyTo( SotStorageStream * pDestStm );
    bool                Commit();
    bool                SetProperty( const OUString& rName, const css::uno::Any& rValue );
    virtual sal_uInt64 remainingSize() override;
};

class  BaseStorage;
class SOT_DLLPUBLIC SotStorage : virtual public SotObject
{
friend class SotStorageStream;

    BaseStorage *   m_pOwnStg;   // target storage
    SvStream *      m_pStorStm;  // only for SDSTORAGES
    ErrCode         m_nError;
    OUString        m_aName;     // name of the storage
    bool            m_bIsRoot;   // e.g.: File Storage
    bool            m_bDelStm;
    OString         m_aKey;      // aKey.Len != 0  -> encryption
    long            m_nVersion;

protected:
                        virtual ~SotStorage();
   void                 CreateStorage( bool bUCBStorage, StreamMode );
public:
                        SotStorage( const OUString &,
                                    StreamMode = StreamMode::STD_READWRITE );
                        SotStorage( bool bUCBStorage, const OUString &,
                                    StreamMode = StreamMode::STD_READWRITE );
                        SotStorage( BaseStorage * );
                        SotStorage( SvStream & rStm );
                        SotStorage( bool bUCBStorage, SvStream & rStm );
                        SotStorage( SvStream * pStm, bool bDelete );

    SvMemoryStream *    CreateMemoryStream();

    static bool         IsStorageFile( const OUString & rFileName );
    static bool         IsStorageFile( SvStream* pStream );

    const OUString&     GetName() const;

    bool                Validate();

    const OString&      GetKey() const { return m_aKey;}

    void                SetVersion( long nVers )
                        {
                            m_nVersion = nVers;
                        }
    long                GetVersion() const
                        {
                            return m_nVersion;
                        }

    ErrCode             GetError() const { return ERRCODE_TOERROR(m_nError); }
    void                SetError( ErrCode nErrorCode )
                        {
                            if( m_nError == SVSTREAM_OK )
                                m_nError = nErrorCode;
                        }

    void                SignAsRoot( bool b = true ) { m_bIsRoot = b; }

                        // own data sector
    void                SetClass( const SvGlobalName & rClass,
                                  SotClipboardFormatId bOriginalClipFormat,
                                  const OUString & rUserTypeName );
    SvGlobalName        GetClassName(); // type of data in the storage
    SotClipboardFormatId GetFormat();
    OUString            GetUserName();

                        // list of all elements
    void                FillInfoList( SvStorageInfoList * ) const;
    bool                CopyTo( SotStorage * pDestStg );
    bool                Commit();

                        // create stream with connection to Storage,
                        // more or less a Parent-Child relationship
    SotStorageStream *  OpenSotStream( const OUString & rEleName,
                                       StreamMode = StreamMode::STD_READWRITE );
    SotStorage *        OpenSotStorage( const OUString & rEleName,
                                        StreamMode = StreamMode::STD_READWRITE,
                                        bool transacted = true );
                        // query whether Storage or Stream
    bool                IsStream( const OUString & rEleName ) const;
    bool                IsStorage( const OUString & rEleName ) const;
    bool                IsContained( const OUString & rEleName ) const;
                        // remove element
    bool                Remove( const OUString & rEleName );
    bool                CopyTo( const OUString & rEleName, SotStorage * pDest,
                                const OUString & rNewName );

    bool                IsOLEStorage() const;
    static bool         IsOLEStorage( const OUString & rFileName );
    static bool         IsOLEStorage( SvStream* pStream );

    static SotStorage*  OpenOLEStorage( const css::uno::Reference < css::embed::XStorage >& xStorage,
                                        const OUString& rEleName, StreamMode = StreamMode::STD_READWRITE );
    static SotClipboardFormatId  GetFormatID( const css::uno::Reference < css::embed::XStorage >& xStorage );
    static sal_Int32    GetVersion( const css::uno::Reference < css::embed::XStorage >& xStorage );
};

#endif // _SVSTOR_HXX

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */