Pencil2D Animation
Download Community News Docs Contribute

core_lib/src/interface/editor.h Source File

  • Main Page
  • Related Pages
  • Classes
  • Files
  •  
  • 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
27#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
28Q_MOC_INCLUDE("colormanager.h")
29Q_MOC_INCLUDE("toolmanager.h")
30Q_MOC_INCLUDE("layermanager.h")
31Q_MOC_INCLUDE("playbackmanager.h")
32Q_MOC_INCLUDE("viewmanager.h")
33Q_MOC_INCLUDE("preferencemanager.h")
34Q_MOC_INCLUDE("selectionmanager.h")
35Q_MOC_INCLUDE("soundmanager.h")
36Q_MOC_INCLUDE("overlaymanager.h")
37Q_MOC_INCLUDE("clipboardmanager.h")
38#endif
39
40class QClipboard;
41class QTemporaryDir;
42class Object;
43class KeyFrame;
44class BitmapImage;
45class VectorImage;
46class LayerCamera;
47class MainWindow2;
48class BaseManager;
49class ColorManager;
50class ToolManager;
51class LayerManager;
52class PlaybackManager;
53class ViewManager;
54class PreferenceManager;
55class SelectionManager;
56class SoundManager;
57class OverlayManager;
58class ClipboardManager;
59class ScribbleArea;
60class TimeLine;
61class BackupElement;
62class ActiveFramePool;
63class Layer;
64
65enum class SETTING;
66
67class Editor : public QObject
68{
69 Q_OBJECT
70
71 Q_PROPERTY(ColorManager* color READ color)
72 Q_PROPERTY(ToolManager* tools READ tools)
73 Q_PROPERTY(LayerManager* layers READ layers)
74 Q_PROPERTY(PlaybackManager* playback READ playback)
75 Q_PROPERTY(ViewManager* view READ view)
76 Q_PROPERTY(PreferenceManager* preference READ preference)
77 Q_PROPERTY(SoundManager* sound READ sound)
78 Q_PROPERTY(SelectionManager* select READ select)
79 Q_PROPERTY(OverlayManager* overlays READ overlays)
80 Q_PROPERTY(ClipboardManager* clipboards READ clipboards)
81
82public:
83 explicit Editor(QObject* parent = nullptr);
84 ~Editor() override;
85
86 bool init();
87
88 /************************************************************************/
89 /* Managers */
90 /************************************************************************/
91 ColorManager* color() const { return mColorManager; }
92 ToolManager* tools() const { return mToolManager; }
93 LayerManager* layers() const { return mLayerManager; }
94 PlaybackManager* playback() const { return mPlaybackManager; }
95 ViewManager* view() const { return mViewManager; }
96 PreferenceManager* preference() const { return mPreferenceManager; }
97 SoundManager* sound() const { return mSoundManager; }
98 SelectionManager* select() const { return mSelectionManager; }
99 OverlayManager* overlays() const { return mOverlayManager; }
100 ClipboardManager* clipboards() const { return mClipboardManager; }
101
102 Object* object() const { return mObject.get(); }
103 Status openObject(const QString& strFilePath, const std::function<void(int)>& progressChanged, const std::function<void(int)>& progressRangeChanged);
104 Status setObject(Object* object);
105 void updateObject();
106 void prepareSave();
107
108 void setScribbleArea(ScribbleArea* pScirbbleArea) { mScribbleArea = pScirbbleArea; }
109 ScribbleArea* getScribbleArea() { return mScribbleArea; }
110
111 int currentFrame() const;
112 int fps();
113 void setFps(int fps);
114
115 int currentLayerIndex() const { return mCurrentLayerIndex; }
116 void setCurrentLayerIndex(int i);
117
118 void scrubTo(int frameNumber);
119
123 void setLayerVisibility(LayerVisibility visibility);
124 LayerVisibility layerVisibility();
125
126 qreal viewScaleInversed();
127 void deselectAll() const;
128 void selectAll() const;
129
130 void clipboardChanged();
131
132 // backup
133 int mBackupIndex;
134 BackupElement* currentBackup();
135 QList<BackupElement*> mBackupList;
136
137signals:
138
140 void scrubbed(int frameNumber);
141
143 void frameModified(int frameNumber);
144
146 void framesModified();
147 void selectedFramesChanged();
148
149 void updateTimeLine() const;
150 void updateTimeLineCached();
151 void updateLayerCount();
152 void updateBackup();
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
171 void updateCurrentFrame();
172
176 void updateFrame(int frameNumber);
177
178 void setModified(int layerNumber, int frameNumber);
179
180 void clearCurrentFrame();
181
182 Status importImage(const QString& filePath);
183 Status importGIF(const QString& filePath, int numOfImages = 0);
184 void restoreKey();
185
186 void scrubNextKeyFrame();
187 void scrubPreviousKeyFrame();
188 void scrubForward();
189 void scrubBackward();
190
191 KeyFrame* addNewKey();
192 void removeKey();
193
194 void switchVisibilityOfLayer(int layerNumber);
195 void swapLayers(int i, int j);
196 bool canSwapLayers(int layerIndexLeft, int layerIndexRight) const;
197
198 void backup(const QString& undoText);
199 bool backup(int layerNumber, int frameNumber, const QString& undoText);
210 void sanitizeBackupElementsAfterLayerDeletion(int layerIndex);
211
212 void onCurrentLayerWillChange(int index);
213 void undo();
214 void redo();
215
216 void copy();
217 void copyAndCut();
218 void pasteFromPreviousFrame();
219 void paste();
220
221 bool canCopy() const;
222 bool canPaste() const;
223
224 void increaseLayerVisibilityIndex();
225 void decreaseLayerVisibilityIndex();
226 void flipSelection(bool flipVertical);
227 void repositionImage(QPoint transform, int frame);
228
229 void clearTemporary();
230 void addTemporaryDir(QTemporaryDir* dir);
231
232 void settingUpdated(SETTING);
233
234 void dontAskAutoSave(bool b) { mAutosaveNeverAskAgain = b; }
235 bool autoSaveNeverAskAgain() const { return mAutosaveNeverAskAgain; }
236 void resetAutoSaveCounter();
237
238private:
239 Status importBitmapImage(const QString&, int space = 0);
240 Status importVectorImage(const QString&);
241
242 void pasteToCanvas(BitmapImage* bitmapImage, int frameNumber);
243 void pasteToCanvas(VectorImage* vectorImage, int frameNumber);
244 void pasteToFrames();
245
246 bool canCopyBitmapImage(BitmapImage* bitmapImage) const;
247 bool canCopyFrames(const Layer* layer) const;
248 bool canCopyVectorImage(const VectorImage* vectorImage) const;
249
250 // the object to be edited by the editor
251 std::unique_ptr<Object> mObject;
252
253 int mFrame = 1; // current frame number.
254 int mCurrentLayerIndex = 0; // the current layer to be edited/displayed
255
256 ScribbleArea* mScribbleArea = nullptr;
257
258 ColorManager* mColorManager = nullptr;
259 ToolManager* mToolManager = nullptr;
260 LayerManager* mLayerManager = nullptr;
261 PlaybackManager* mPlaybackManager = nullptr;
262 ViewManager* mViewManager = nullptr;
263 PreferenceManager* mPreferenceManager = nullptr;
264 SoundManager* mSoundManager = nullptr;
265 SelectionManager* mSelectionManager = nullptr;
266 OverlayManager* mOverlayManager = nullptr;
267 ClipboardManager* mClipboardManager = nullptr;
268
269 std::vector< BaseManager* > mAllManagers;
270
271 bool mIsAutosave = true;
272 int mAutosaveNumber = 12;
273 int mAutosaveCounter = 0;
274 bool mAutosaveNeverAskAgain = false;
275
276 void makeConnections();
277 KeyFrame* addKeyFrame(int layerNumber, int frameNumber);
278
279 QList<QTemporaryDir*> mTemporaryDirs;
280
281 // backup
282 void clearUndoStack();
283 void updateAutoSaveCounter();
284 int mLastModifiedFrame = -1;
285 int mLastModifiedLayer = -1;
286};
287
288#endif
ActiveFramePool
ActiveFramePool implemented a LRU cache to keep tracking the most recent accessed key frames A key fr...
Definition: activeframepool.h:34
BackupElement
Definition: backupelement.h:29
BaseManager
Definition: basemanager.h:29
BitmapImage
Definition: bitmapimage.h:27
ClipboardManager
Definition: clipboardmanager.h:31
ColorManager
Definition: colormanager.h:27
Editor
Definition: editor.h:68
Editor::updateFrame
void updateFrame(int frameNumber)
Will call update() and update the canvas Only call this directly If you need the cache to be intact a...
Definition: editor.cpp:1112
Editor::framesModified
void framesModified()
This should be emitted after modifying multiple frames.
Editor::updateCurrentFrame
void updateCurrentFrame()
Will call update() and update the canvas Only call this directly If you need the cache to be intact a...
Definition: editor.cpp:1117
Editor::frameModified
void frameModified(int frameNumber)
This should be emitted after modifying the frame content.
Editor::scrubbed
void scrubbed(int frameNumber)
This should be emitted after scrubbing.
Editor::sanitizeBackupElementsAfterLayerDeletion
void sanitizeBackupElementsAfterLayerDeletion(int layerIndex)
Restores integrity of the backup elements after a layer has been deleted.
Definition: editor.cpp:331
Editor::setLayerVisibility
void setLayerVisibility(LayerVisibility visibility)
The visibility value should match any of the VISIBILITY enum values.
Definition: editor.cpp:759
KeyFrame
Definition: keyframe.h:30
LayerCamera
Definition: layercamera.h:30
Layer
Definition: layer.h:38
LayerManager
Definition: layermanager.h:31
MainWindow2
Definition: mainwindow2.h:58
Object
Definition: object.h:42
OverlayManager
Definition: overlaymanager.h:32
PlaybackManager
Definition: playbackmanager.h:30
PreferenceManager
Definition: preferencemanager.h:28
ScribbleArea
Definition: scribblearea.h:52
SelectionManager
Definition: selectionmanager.h:33
SoundManager
Definition: soundmanager.h:30
Status
Definition: pencilerror.h:40
TimeLine
Definition: timeline.h:31
ToolManager
Definition: toolmanager.h:30
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
Generated on Sun Sep 24 2023 19:39:34 for Pencil2D by doxygen 1.9.6 based on revision 1395c86cb17dafbb32de44cbabe1f4c58636468d