Pencil2D Animation
Download Community News Docs Contribute
  • Overview
  • Articles
  • Code
  •  
  • Class List
  • Class Index
  • Class Hierarchy
  • Class Members
  • File List
Loading...
Searching...
No Matches
  • core_lib
  • src
  • interface
editor.h
1/*
2
3Pencil2D - Traditional Animation Software
4Copyright (C) 2005-2007 Patrick Corrieri & Pascal Naidon
5Copyright (C) 2012-2020 Matthew Chiawen Chang
6
7This program is free software; you can redistribute it and/or
8modify it under the terms of the GNU General Public License
9as published by the Free Software Foundation; version 2 of the License.
10
11This program is distributed in the hope that it will be useful,
12but WITHOUT ANY WARRANTY; without even the implied warranty of
13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14GNU General Public License for more details.
15
16*/
17
18#ifndef EDITOR_H
19#define EDITOR_H
20
21#include <functional>
22#include <memory>
23#include <QObject>
24#include "pencilerror.h"
25#include "pencildef.h"
26#include "importimageconfig.h"
27
28#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
29Q_MOC_INCLUDE("colormanager.h")
30Q_MOC_INCLUDE("toolmanager.h")
31Q_MOC_INCLUDE("layermanager.h")
32Q_MOC_INCLUDE("playbackmanager.h")
33Q_MOC_INCLUDE("viewmanager.h")
34Q_MOC_INCLUDE("preferencemanager.h")
35Q_MOC_INCLUDE("selectionmanager.h")
36Q_MOC_INCLUDE("soundmanager.h")
37Q_MOC_INCLUDE("overlaymanager.h")
38Q_MOC_INCLUDE("clipboardmanager.h")
39Q_MOC_INCLUDE("undoredomanager.h")
40#endif
41
42class QClipboard;
43class QTemporaryDir;
44class Object;
45class KeyFrame;
46class BitmapImage;
47class VectorImage;
48class LayerCamera;
49class MainWindow2;
50class BaseManager;
51class ColorManager;
52class ToolManager;
53class LayerManager;
54class PlaybackManager;
55class ViewManager;
56class PreferenceManager;
57class SelectionManager;
58class SoundManager;
59class OverlayManager;
60class ClipboardManager;
61class UndoRedoManager;
62class ScribbleArea;
63class TimeLine;
64class UndoRedoCommand;
65class ActiveFramePool;
66class Layer;
67
68enum class SETTING;
69
70class Editor : public QObject
71{
72 Q_OBJECT
73
74 Q_PROPERTY(ColorManager* color READ color)
75 Q_PROPERTY(ToolManager* tools READ tools)
76 Q_PROPERTY(LayerManager* layers READ layers)
77 Q_PROPERTY(PlaybackManager* playback READ playback)
78 Q_PROPERTY(ViewManager* view READ view)
79 Q_PROPERTY(PreferenceManager* preference READ preference)
80 Q_PROPERTY(SoundManager* sound READ sound)
81 Q_PROPERTY(SelectionManager* select READ select)
82 Q_PROPERTY(OverlayManager* overlays READ overlays)
83 Q_PROPERTY(ClipboardManager* clipboards READ clipboards)
84 Q_PROPERTY(UndoRedoManager* undoRedo READ undoRedo)
85
86
87public:
88 explicit Editor(QObject* parent = nullptr);
89 ~Editor() override;
90
91 bool init();
92
93 /************************************************************************/
94 /* Managers */
95 /************************************************************************/
96 ColorManager* color() const { return mColorManager; }
97 ToolManager* tools() const { return mToolManager; }
98 LayerManager* layers() const { return mLayerManager; }
99 PlaybackManager* playback() const { return mPlaybackManager; }
100 ViewManager* view() const { return mViewManager; }
101 PreferenceManager* preference() const { return mPreferenceManager; }
102 SoundManager* sound() const { return mSoundManager; }
103 SelectionManager* select() const { return mSelectionManager; }
104 OverlayManager* overlays() const { return mOverlayManager; }
105 ClipboardManager* clipboards() const { return mClipboardManager; }
106 UndoRedoManager* undoRedo() const { return mUndoRedoManager; }
107
108 Object* object() const { return mObject.get(); }
109 Status openObject(const QString& strFilePath, const std::function<void(int)>& progressChanged, const std::function<void(int)>& progressRangeChanged);
110 Status setObject(Object* object);
111 void updateObject();
112 void prepareSave();
113
114 void setScribbleArea(ScribbleArea* pScirbbleArea) { mScribbleArea = pScirbbleArea; }
115 ScribbleArea* getScribbleArea() { return mScribbleArea; }
116
117 int currentFrame() const;
118 int fps();
119 void setFps(int fps);
120
121 int currentLayerIndex() const { return mCurrentLayerIndex; }
122 void setCurrentLayerIndex(int i);
123
124 void scrubTo(int frameNumber);
125
129 void setLayerVisibility(LayerVisibility visibility);
130 LayerVisibility layerVisibility();
131
132 qreal viewScaleInversed();
133 void deselectAll() const;
134 void selectAll() const;
135
136 void clipboardChanged();
137
138signals:
139
141 void scrubbed(int frameNumber);
142
144 void frameModified(int frameNumber);
145
147 void framesModified();
148 void selectedFramesChanged();
149
150 void updateTimeLine() const;
151 void updateTimeLineCached();
152 void updateLayerCount();
153
154 void objectLoaded();
155
156 void fpsChanged(int fps);
157
158 void needSave();
159 void needDisplayInfo(const QString& title, const QString& body);
160 void needDisplayInfoNoTitle(const QString& body);
161
162 void canCopyChanged(bool enabled);
163 void canPasteChanged(bool enabled);
164
165public: //slots
166
170 void updateFrame();
171
172 void setModified(int layerNumber, int frameNumber);
173
174 void clearCurrentFrame();
175
176 Status importImage(const QString& filePath, ImportImageConfig importConfig);
177 Status importAnimatedImage(const QString& filePath, int frameSpacing, const std::function<void (int)>& progressChanged, const std::function<bool ()>& wasCanceled);
178
179 void scrubNextKeyFrame();
180 void scrubPreviousKeyFrame();
181 void scrubForward();
182 void scrubBackward();
183
190 KeyFrame* addNewKey();
200 KeyFrame* addKeyFrame(int layerNumber, int frameIndex);
201 void removeKey();
202
203 void switchVisibilityOfLayer(int layerNumber);
204 void swapLayers(int i, int j);
205 bool canSwapLayers(int layerIndexLeft, int layerIndexRight) const;
206
207 void backup(const QString& undoText);
208 bool backup(int layerNumber, int frameNumber, const QString& undoText);
209
210 void onCurrentLayerWillChange(int index);
211
212 void copy();
213 void copyAndCut();
214 void pasteFromPreviousFrame();
215 void paste();
216
217 bool canCopy() const;
218 bool canPaste() const;
219
220 void increaseLayerVisibilityIndex();
221 void decreaseLayerVisibilityIndex();
222 void flipSelection(bool flipVertical);
223 void repositionImage(QPoint transform, int frame);
224
225 void clearTemporary();
226 void addTemporaryDir(QTemporaryDir* dir);
227
228 void settingUpdated(SETTING);
229
230 void dontAskAutoSave(bool b) { mAutosaveNeverAskAgain = b; }
231 bool autoSaveNeverAskAgain() const { return mAutosaveNeverAskAgain; }
232 void resetAutoSaveCounter();
233
234private:
235 Status importBitmapImage(const QString&, const QTransform& importTransform);
236 Status importVectorImage(const QString&);
237
238 void pasteToCanvas(BitmapImage* bitmapImage, int frameNumber);
239 void pasteToCanvas(VectorImage* vectorImage, int frameNumber);
240 void pasteToFrames();
241
242 bool canCopyBitmapImage(BitmapImage* bitmapImage) const;
243 bool canCopyFrames(const Layer* layer) const;
244 bool canCopyVectorImage(const VectorImage* vectorImage) const;
245
246 // the object to be edited by the editor
247 std::unique_ptr<Object> mObject;
248
249 int mFrame = 1; // current frame number.
250 int mCurrentLayerIndex = 0; // the current layer to be edited/displayed
251
252 ScribbleArea* mScribbleArea = nullptr;
253
254 ColorManager* mColorManager = nullptr;
255 ToolManager* mToolManager = nullptr;
256 LayerManager* mLayerManager = nullptr;
257 PlaybackManager* mPlaybackManager = nullptr;
258 ViewManager* mViewManager = nullptr;
259 PreferenceManager* mPreferenceManager = nullptr;
260 SoundManager* mSoundManager = nullptr;
261 SelectionManager* mSelectionManager = nullptr;
262 OverlayManager* mOverlayManager = nullptr;
263 ClipboardManager* mClipboardManager = nullptr;
264 UndoRedoManager* mUndoRedoManager = nullptr;
265
266 std::vector< BaseManager* > mAllManagers;
267
268 bool mIsAutosave = true;
269 int mAutosaveNumber = 12;
270 int mAutosaveCounter = 0;
271 bool mAutosaveNeverAskAgain = false;
272
273 void makeConnections();
274
275 QList<QTemporaryDir*> mTemporaryDirs;
276
277 void updateAutoSaveCounter();
278};
279
280#endif
ActiveFramePool
ActiveFramePool implemented a LRU cache to keep tracking the most recent accessed key frames A key fr...
Definition: activeframepool.h:34
BaseManager
Definition: basemanager.h:29
BitmapImage
Definition: bitmapimage.h:28
ClipboardManager
Definition: clipboardmanager.h:31
ColorManager
Definition: colormanager.h:27
Editor
Definition: editor.h:71
Editor::framesModified
void framesModified()
This should be emitted after modifying multiple frames.
Editor::addNewKey
KeyFrame * addNewKey()
Attempts to create a new keyframe at the current frame and layer.
Definition: editor.cpp:903
Editor::frameModified
void frameModified(int frameNumber)
This should be emitted after modifying the frame content.
Editor::updateFrame
void updateFrame()
Will call update() and update the canvas Only call this directly If you need the cache to be intact a...
Definition: editor.cpp:850
Editor::scrubbed
void scrubbed(int frameNumber)
This should be emitted after scrubbing.
Editor::setLayerVisibility
void setLayerVisibility(LayerVisibility visibility)
The visibility value should match any of the VISIBILITY enum values.
Definition: editor.cpp:428
Editor::addKeyFrame
KeyFrame * addKeyFrame(int layerNumber, int frameIndex)
Attempts to create a new keyframe at the given position and layer.
Definition: editor.cpp:908
KeyFrame
Definition: keyframe.h:30
LayerCamera
Definition: layercamera.h:30
Layer
Definition: layer.h:33
LayerManager
Definition: layermanager.h:31
MainWindow2
Definition: mainwindow2.h:57
Object
Definition: object.h:42
OverlayManager
Definition: overlaymanager.h:32
PlaybackManager
Definition: playbackmanager.h:30
PreferenceManager
Definition: preferencemanager.h:28
ScribbleArea
Definition: scribblearea.h:51
SelectionManager
Definition: selectionmanager.h:33
SoundManager
Definition: soundmanager.h:30
Status
Definition: pencilerror.h:40
TimeLine
Definition: timeline.h:32
ToolManager
Definition: toolmanager.h:30
UndoRedoCommand
Definition: undoredocommand.h:38
UndoRedoManager
Definition: undoredomanager.h:91
VectorImage
Definition: vectorimage.h:32
ViewManager
Definition: viewmanager.h:26
QClipboard
QList
QObject
QObject::Q_OBJECT
Q_OBJECTQ_OBJECT
QObject::Q_PROPERTY
Q_PROPERTY(...)
QObject::parent
QObject * parent() const const
QPoint
QString
QTemporaryDir
QTransform
ImportImageConfig
Definition: importimageconfig.h:22
Generated on Thu May 8 2025 04:47:53 for Pencil2D by doxygen 1.9.6 based on revision 4513250b1d5b1a3676ec0e67b06b7a885ceaae39