summaryrefslogtreecommitdiffstats
path: root/sw/inc/hints.hxx
blob: 9c37399f68f66b19fb48faddca47eb5b7bd2fd1c (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
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
/* -*- 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_SW_INC_HINTS_HXX
#define INCLUDED_SW_INC_HINTS_HXX

#include "swatrset.hxx"
#include "swtypes.hxx"
#include <vcl/vclptr.hxx>

class SwFormat;
class OutputDevice;
class SwTable;
class SwNode;
class SwNodes;
class SwPageFrame;
class SwFrame;
class SwHistory;
class SwTextNode;
class SwTextFormatColl;
class SwFrameFormat;
class SwTableBox;
class SwTableBoxFormat;
class SwTableLine;
class SwTableLineFormat;
class SwTableBox;

// Base class for all Message-Hints:
// "Overhead" of SfxPoolItem is handled here
class SwMsgPoolItem : public SfxPoolItem
{
public:
    SwMsgPoolItem( sal_uInt16 nWhich );

    // "Overhead" of SfxPoolItem
    virtual bool            operator==( const SfxPoolItem& ) const override;
    virtual SwMsgPoolItem*  Clone( SfxItemPool* pPool = nullptr ) const override;
};

// SwPtrMsgPoolItem (old SwObjectDying!)

class SwPtrMsgPoolItem final : public SwMsgPoolItem
{
public:
    void * pObject;

    SwPtrMsgPoolItem( sal_uInt16 nId, void * pObj )
        : SwMsgPoolItem( nId ), pObject( pObj )
    {}
};

/*
 * SwFormatChg is sent when a format has changed to another format. 2 Hints are always sent
 * the old and the new format
 */
class SwFormatChg final : public SwMsgPoolItem
{
public:
    SwFormat *pChangedFormat;
    SwFormatChg( SwFormat *pFormat );
};

class SwInsText final : public SwMsgPoolItem
{
public:
    sal_Int32 nPos;
    sal_Int32 nLen;
    bool isInsideFieldmarkCommand;
    bool isInsideFieldmarkResult;

    SwInsText(sal_Int32 nP, sal_Int32 nL, bool isInFMCommand, bool isInFMResult);
};

class SwDelChr final : public SwMsgPoolItem
{
public:
    sal_Int32 nPos;

    SwDelChr( sal_Int32 nP );
};

class SwDelText final : public SwMsgPoolItem
{
public:
    sal_Int32 nStart;
    sal_Int32 nLen;

    SwDelText( sal_Int32 nS, sal_Int32 nL );
};

namespace sw {

/// text is moved into pDestNode
class MoveText final : public SfxHint
{
public:
    SwTextNode * pDestNode;
    sal_Int32 nDestStart;
    sal_Int32 nSourceStart;
    sal_Int32 nLen;

    MoveText(SwTextNode *pD, sal_Int32 nD, sal_Int32 nS, sal_Int32 nL);
};

/// new delete redline is created
class RedlineDelText final : public SfxHint
{
public:
    sal_Int32 nStart;
    sal_Int32 nLen;

    RedlineDelText(sal_Int32 nS, sal_Int32 nL);
};

/// delete redline is removed
class RedlineUnDelText final : public SfxHint
{
public:
    sal_Int32 nStart;
    sal_Int32 nLen;

    RedlineUnDelText(sal_Int32 nS, sal_Int32 nL);
};

class CondCollCondChg final : public SfxHint
{
public:
    const SwTextFormatColl& m_rColl;
    CondCollCondChg(const SwTextFormatColl& rColl) : m_rColl(rColl) {};
};

class GrfRereadAndInCacheHint final : public SfxHint
{
};

class PreGraphicArrivedHint final : public SfxHint
{
};

class PostGraphicArrivedHint final : public SfxHint
{
};

class MoveTableLineHint final : public SfxHint
{
public:
    const SwFrameFormat& m_rNewFormat;
    const SwTableLine& m_rTableLine;
    MoveTableLineHint(const SwFrameFormat& rNewFormat, const SwTableLine& rTableLine): m_rNewFormat(rNewFormat), m_rTableLine(rTableLine) {};
};

class MoveTableBoxHint final : public SfxHint
{
public:
    const SwFrameFormat& m_rNewFormat;
    const SwTableBox& m_rTableBox;
    MoveTableBoxHint(const SwFrameFormat& rNewFormat, const SwTableBox& rTableBox): m_rNewFormat(rNewFormat), m_rTableBox(rTableBox) {};
};

class DocumentDyingHint final : public SfxHint
{
};

class TableLineFormatChanged final : public SfxHint
{
public:
    const SwTableLineFormat& m_rNewFormat;
    const SwTableLine& m_rTabLine;
    TableLineFormatChanged(const SwTableLineFormat& rNewFormat, const SwTableLine& rTabLine) : m_rNewFormat(rNewFormat), m_rTabLine(rTabLine) {};
};
class TableBoxFormatChanged final : public SfxHint
{
public:
    const SwTableBoxFormat& m_rNewFormat;
    const SwTableBox& m_rTableBox;
    TableBoxFormatChanged(const SwTableBoxFormat& rNewFormat, const SwTableBox& rTableBox) : m_rNewFormat(rNewFormat), m_rTableBox(rTableBox) {};
};
}

class SwUpdateAttr final : public SwMsgPoolItem
{
private:
    sal_Int32 m_nStart;
    sal_Int32 m_nEnd;
    sal_uInt16 m_nWhichAttr;
    std::vector<sal_uInt16> m_aWhichFmtAttrs; // attributes changed inside RES_TXTATR_AUTOFMT

public:
    SwUpdateAttr( sal_Int32 nS, sal_Int32 nE, sal_uInt16 nW );
    SwUpdateAttr( sal_Int32 nS, sal_Int32 nE, sal_uInt16 nW, std::vector<sal_uInt16> aW );

    sal_Int32 getStart() const
    {
        return m_nStart;
    }

    sal_Int32 getEnd() const
    {
        return m_nEnd;
    }

    sal_uInt16 getWhichAttr() const
    {
        return m_nWhichAttr;
    }

    const std::vector<sal_uInt16>& getFmtAttrs() const
    {
        return m_aWhichFmtAttrs;
    }
};

/** SwRefMarkFieldUpdate is sent when the referencemarks should be updated.
     To determine Page- / chapternumbers the current frame has to be asked.
      For this we need the current outputdevice */
class SwRefMarkFieldUpdate final : public SwMsgPoolItem
{
    VclPtr<OutputDevice> pOut; ///< pointer to the current output device
public:
    /** Is sent if reference marks should be updated.

        To get the page/chapter number, the frame has to be asked. For that we need
        the current OutputDevice.
    */
    SwRefMarkFieldUpdate( OutputDevice* );
};

/** SwDocPosUpdate is sent to signal that only the frames from or to a specified document-global position
   have to be updated. At the moment this is only needed when updating pagenumber fields. */
class SwDocPosUpdate final : public SwMsgPoolItem
{
public:
    const SwTwips nDocPos;
    SwDocPosUpdate( const SwTwips nDocPos );
};

/// SwTableFormulaUpdate is sent when the table has to be newly calculated or when a table itself is merged or split
enum TableFormulaUpdateFlags { TBL_CALC = 0,
                         TBL_BOXNAME,
                         TBL_BOXPTR,
                         TBL_RELBOXNAME,
                         TBL_MERGETBL,
                         TBL_SPLITTBL
                       };
class SwTableFormulaUpdate final : public SwMsgPoolItem
{
public:
    const SwTable* m_pTable;         ///< Pointer to the current table
    union {
        const SwTable* pDelTable;  ///< Merge: Pointer to the table to be removed
        const OUString* pNewTableNm; ///< Split: the name of the new table
    } m_aData;
    SwHistory* m_pHistory;
    sal_uInt16 m_nSplitLine;       ///< Split: from this BaseLine on will be split
    TableFormulaUpdateFlags m_eFlags;
    bool m_bModified : 1;
    bool m_bBehindSplitLine : 1;

    /** Is sent if a table should be recalculated */
    SwTableFormulaUpdate( const SwTable* );
};

class SwAutoFormatGetDocNode final : public SwMsgPoolItem
{
public:
    const SwNodes* pNodes;

    SwAutoFormatGetDocNode( const SwNodes* pNds );
};

/*
 * SwAttrSetChg is sent when something has changed in the SwAttrSet rTheChgdSet.
 * 2 Hints are always sent, the old and the new items in the rTheChgdSet.
 */
class SwAttrSetChg final : public SwMsgPoolItem
{
    bool m_bDelSet;
    SwAttrSet* m_pChgSet;           ///< what has changed
    const SwAttrSet* m_pTheChgdSet; ///< is only used to compare
public:
    SwAttrSetChg( const SwAttrSet& rTheSet, SwAttrSet& rSet );
    SwAttrSetChg( const SwAttrSetChg& );
    virtual ~SwAttrSetChg() override;

    /// What has changed
    const SwAttrSet* GetChgSet() const     { return m_pChgSet; }
          SwAttrSet* GetChgSet()           { return m_pChgSet; }

    /// Where it has changed
    const SwAttrSet* GetTheChgdSet() const { return m_pTheChgdSet; }

    sal_uInt16 Count() const { return m_pChgSet->Count(); }
    void ClearItem( sal_uInt16 nWhichL )
#ifdef DBG_UTIL
        ;
#else
    { m_pChgSet->ClearItem( nWhichL ); }
#endif
};

class SwVirtPageNumInfo final : public SwMsgPoolItem
{
    const SwPageFrame *m_pPage;
    const SwPageFrame *m_pOrigPage;
    const SwFrame     *m_pFrame;
    /** Multiple attributes can be attached to a single paragraph / table
     The frame, in the end, has to decide which attribute takes effect and which physical page it involves */
public:
    SwVirtPageNumInfo( const SwPageFrame *pPg );

    const SwPageFrame *GetPage() const          { return m_pPage;    }
    const SwPageFrame *GetOrigPage() const      { return m_pOrigPage;}
    const SwFrame *GetFrame() const             { return m_pFrame; }
    void  SetInfo( const SwPageFrame *pPg,
                   const SwFrame *pF )    { m_pFrame = pF; m_pPage = pPg; }
};

class SwFindNearestNode final : public SwMsgPoolItem
{
    const SwNode *m_pNode, *m_pFound;
public:
    SwFindNearestNode( const SwNode& rNd );
    void CheckNode( const SwNode& rNd );

    const SwNode* GetFoundNode() const { return m_pFound; }
};

class SwStringMsgPoolItem final : public SwMsgPoolItem
{
    OUString m_sStr;
public:

    const OUString& GetString() const { return m_sStr; }

    SwStringMsgPoolItem( sal_uInt16 nId, const OUString& rStr )
        : SwMsgPoolItem( nId ), m_sStr( rStr )
    {}
};
#endif

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