forked from LibreSprite/LibreSprite
-
Notifications
You must be signed in to change notification settings - Fork 0
/
document.h
213 lines (159 loc) · 6.61 KB
/
document.h
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
// Aseprite
// Copyright (C) 2001-2016 David Capello
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
#pragma once
#include "app/extra_cel.h"
#include "app/file/format_options.h"
#include "app/transformation.h"
#include "base/disable_copying.h"
#include "base/mutex.h"
#include "base/observable.h"
#include "doc/blend_mode.h"
#include "doc/color.h"
#include "doc/document.h"
#include "doc/frame.h"
#include "doc/pixel_format.h"
#include "gfx/rect.h"
#include <string>
namespace doc {
class Cel;
class Layer;
class Mask;
class MaskBoundaries;
class Sprite;
}
namespace gfx {
class Region;
}
namespace app {
class DocumentApi;
class DocumentUndo;
class Transaction;
using namespace doc;
enum DuplicateType {
DuplicateExactCopy,
DuplicateWithFlattenLayers,
};
// An application document. It is the class used to contain one file
// opened and being edited by the user (a sprite).
class Document : public doc::Document {
public:
enum LockType {
ReadLock,
WriteLock
};
Document(Sprite* sprite);
~Document();
// Returns a high-level API: observable and undoable methods.
DocumentApi getApi(Transaction& transaction);
//////////////////////////////////////////////////////////////////////
// Main properties
const DocumentUndo* undoHistory() const { return m_undo.get(); }
DocumentUndo* undoHistory() { return m_undo.get(); }
color_t bgColor() const;
color_t bgColor(Layer* layer) const;
//////////////////////////////////////////////////////////////////////
// Notifications
void notifyGeneralUpdate();
void notifySpritePixelsModified(Sprite* sprite, const gfx::Region& region, frame_t frame);
void notifyExposeSpritePixels(Sprite* sprite, const gfx::Region& region);
void notifyLayerMergedDown(Layer* srcLayer, Layer* targetLayer);
void notifyCelMoved(Layer* fromLayer, frame_t fromFrame, Layer* toLayer, frame_t toFrame);
void notifyCelCopied(Layer* fromLayer, frame_t fromFrame, Layer* toLayer, frame_t toFrame);
void notifySelectionChanged();
//////////////////////////////////////////////////////////////////////
// File related properties
bool isModified() const;
bool isAssociatedToFile() const;
void markAsSaved();
// You can use this to indicate that we've destroyed (or we cannot
// trust) the file associated with the document (e.g. when we
// cancel a Save operation in the middle). So it's impossible to
// back to the saved state using the UndoHistory.
void impossibleToBackToSavedState();
// Returns true if it does make sense to create a backup in this
// document. For example, it doesn't make sense to create a backup
// for an unmodified document.
bool needsBackup() const;
//////////////////////////////////////////////////////////////////////
// Loaded options from file
void setFormatOptions(const base::SharedPtr<FormatOptions>& format_options);
base::SharedPtr<FormatOptions> getFormatOptions() { return m_format_options; }
//////////////////////////////////////////////////////////////////////
// Boundaries
void generateMaskBoundaries(const Mask* mask = nullptr);
const MaskBoundaries* getMaskBoundaries() const {
return m_maskBoundaries.get();
}
//////////////////////////////////////////////////////////////////////
// Extra Cel (it is used to draw pen preview, pixels in movement, etc.)
ExtraCelRef extraCel() const { return m_extraCel; }
void setExtraCel(const ExtraCelRef& extraCel) { m_extraCel = extraCel; }
//////////////////////////////////////////////////////////////////////
// Mask
// Returns the current mask, it can be empty. The mask could be not
// empty but hidden to the user if the setMaskVisible(false) was
// used called before.
Mask* mask() const { return m_mask.get(); }
// Sets the current mask. The new mask will be visible by default,
// so you don't need to call setMaskVisible(true).
void setMask(const Mask* mask);
// Returns true only when the mask is not empty, and was not yet
// hidden using setMaskVisible (e.g. when the user "deselect the
// mask").
bool isMaskVisible() const;
// Changes the visibility state of the mask (it is useful only if
// the getMask() is not empty and the user can see that the mask is
// being hidden and shown to him).
void setMaskVisible(bool visible);
//////////////////////////////////////////////////////////////////////
// Transformation
Transformation getTransformation() const;
void setTransformation(const Transformation& transform);
void resetTransformation();
//////////////////////////////////////////////////////////////////////
// Copying
void copyLayerContent(const Layer* sourceLayer, Document* destDoc, Layer* destLayer) const;
Document* duplicate(DuplicateType type) const;
//////////////////////////////////////////////////////////////////////
// Multi-threading ("sprite wrappers" use this)
// Locks the sprite to read or write on it, returning true if the
// sprite can be accessed in the desired mode.
bool lock(LockType lockType, int timeout);
// If you've locked the sprite to read, using this method you can
// raise your access level to write it.
bool lockToWrite(int timeout);
// If you've locked the sprite to write, using this method you can
// your access level to only read it.
void unlockToRead();
void unlock();
protected:
virtual void onContextChanged() override;
private:
// Undo and redo information about the document.
std::unique_ptr<DocumentUndo> m_undo;
// True if this sprite is associated to a file in the file-system.
bool m_associated_to_file;
// Selected mask region boundaries
std::unique_ptr<doc::MaskBoundaries> m_maskBoundaries;
// Mutex to modify the 'locked' flag.
base::mutex m_mutex;
// True if some thread is writing the sprite.
bool m_write_lock;
// Greater than zero when one or more threads are reading the sprite.
int m_read_locks;
// Data to save the file in the same format that it was loaded
base::SharedPtr<FormatOptions> m_format_options;
// Extra cel used to draw extra stuff (e.g. editor's pen preview, pixels in movement, etc.)
ExtraCelRef m_extraCel;
// Current mask.
std::unique_ptr<Mask> m_mask;
bool m_maskVisible;
// Current transformation.
Transformation m_transformation;
DISABLE_COPYING(Document);
};
} // namespace app