Pencil2D Animation
Download Community News Docs Contribute
  • Overview
  • Articles
  • Code
  •  
  • Class List
  • Class Index
  • Class Hierarchy
  • Class Members
  • File List
Loading...
Searching...
No Matches
  • app
  • src
mainwindow2.cpp
1/*
2
3Pencil2D - Traditional Animation Software
4Copyright (C) 2005-2007 Patrick Corrieri & Pascal Naidon
5Copyright (C) 2008-2009 Mj Mendoza IV
6Copyright (C) 2012-2020 Matthew Chiawen Chang
7
8This program is free software; you can redistribute it and/or
9modify it under the terms of the GNU General Public License
10as published by the Free Software Foundation; version 2 of the License.
11
12This program is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for more details.
16
17*/
18
19#include "mainwindow2.h"
20#include "ui_mainwindow2.h"
21
22// Qt headers
23#include <QActionGroup>
24#include <QDir>
25#include <QList>
26#include <QMenu>
27#include <QFile>
28#include <QMessageBox>
29#include <QProgressDialog>
30#include <QTabletEvent>
31#include <QStandardPaths>
32#include <QDateTime>
33#include <QLabel>
34#include <QClipboard>
35#include <QToolBar>
36#include <QToolButton>
37
38// core_lib headers
39#include "pencildef.h"
40#include "pencilsettings.h"
41#include "object.h"
42#include "editor.h"
43
44#include "filemanager.h"
45#include "colormanager.h"
46#include "layermanager.h"
47#include "toolmanager.h"
48#include "playbackmanager.h"
49#include "selectionmanager.h"
50#include "soundmanager.h"
51#include "viewmanager.h"
52#include "selectionmanager.h"
53#include "undoredomanager.h"
54
55#include "actioncommands.h"
56#include "fileformat.h" //contains constants used by Pencil File Format
57#include "util.h"
58#include "undoredocommand.h"
59
60// app headers
61#include "colorbox.h"
62#include "colorinspector.h"
63#include "colorpalettewidget.h"
64#include "tooloptionwidget.h"
65#include "preferencesdialog.h"
66#include "timeline.h"
67#include "toolbox.h"
68#include "onionskinwidget.h"
69#include "pegbaralignmentdialog.h"
70#include "repositionframesdialog.h"
71
72#include "errordialog.h"
73#include "filedialog.h"
74#include "importimageseqdialog.h"
75#include "importlayersdialog.h"
76#include "importpositiondialog.h"
77#include "layeropacitydialog.h"
78#include "recentfilemenu.h"
79#include "shortcutfilter.h"
80#include "app_util.h"
81#include "presetdialog.h"
82#include "pegbaralignmentdialog.h"
83
84
85#ifdef GIT_TIMESTAMP
86#define BUILD_DATE S__GIT_TIMESTAMP
87#else
88#define BUILD_DATE __DATE__
89#endif
90
91#if defined(PENCIL2D_RELEASE_BUILD)
92#define PENCIL_WINDOW_TITLE QString("[*]Pencil2D v%1").arg(APP_VERSION)
93#elif defined(PENCIL2D_NIGHTLY_BUILD)
94#define PENCIL_WINDOW_TITLE QString("[*]Pencil2D Nightly Build %1").arg(BUILD_DATE)
95#else
96#define PENCIL_WINDOW_TITLE QString("[*]Pencil2D Development Build %1").arg(BUILD_DATE)
97#endif
98
99
100
101MainWindow2::MainWindow2(QWidget* parent) :
102 QMainWindow(parent),
103 ui(new Ui::MainWindow2)
104{
105 ui->setupUi(this);
106
107 // Initialize order
108 // 1. editor 2. object 3. scribble area 4. other widgets
109 mEditor = new Editor(this);
110 mEditor->setScribbleArea(ui->scribbleArea);
111 mEditor->init();
112
113 newObject();
114
115 ui->scribbleArea->setEditor(mEditor);
116 ui->scribbleArea->init();
117
118 ui->statusBar->setEditor(mEditor);
119 ui->statusBar->updateZoomStatus();
120 ui->statusBar->setVisible(mEditor->preference()->isOn(SETTING::SHOW_STATUS_BAR));
121
122 mCommands = new ActionCommands(this);
123 mCommands->setCore(mEditor);
124
125 createDockWidgets();
126 createMenus();
127 createToolbars();
128 setupKeyboardShortcuts();
129
130 readSettings();
131
132 selectionChanged();
133 currentLayerChanged();
134
135 connect(mEditor, &Editor::needSave, this, &MainWindow2::autoSave);
136
137 mEditor->tools()->setDefaultTool();
138 ui->background->init(mEditor->preference());
139
140 setWindowTitle(PENCIL_WINDOW_TITLE);
141}
142
143MainWindow2::~MainWindow2()
144{
145 delete ui;
146}
147
148void MainWindow2::createDockWidgets()
149{
150 mTimeLine = new TimeLine(this);
151 mTimeLine->setObjectName("TimeLine");
152
153 mColorBox = new ColorBox(this);
154 mColorBox->setToolTip(tr("color palette:<br>use <b>(C)</b><br>toggle at cursor"));
155 mColorBox->setObjectName("ColorWheel");
156
157 mColorInspector = new ColorInspector(this);
158 mColorInspector->setToolTip(tr("Color inspector"));
159 mColorInspector->setObjectName("Color Inspector");
160
161 mColorPalette = new ColorPaletteWidget(this);
162 mColorPalette->setCore(mEditor);
163 mColorPalette->setObjectName("ColorPalette");
164
165 mOnionSkinWidget = new OnionSkinWidget(this);
166 mOnionSkinWidget->setObjectName("Onion Skin");
167
168 mToolOptions = new ToolOptionWidget(this);
169 mToolOptions->setObjectName("ToolOption");
170
171 mToolBox = new ToolBoxWidget(this);
172 mToolBox->setObjectName("ToolBox");
173
174 mDockWidgets
175 << mTimeLine
176 << mColorBox
177 << mColorInspector
178 << mColorPalette
179 << mOnionSkinWidget
180 << mToolOptions
181 << mToolBox;
182
183 mStartIcon = QIcon(":icons/controls/play.png");
184 mStopIcon = QIcon(":icons/controls/stop.png");
185
186 for (BaseDockWidget* pWidget : mDockWidgets)
187 {
188 pWidget->setAllowedAreas(Qt::AllDockWidgetAreas);
189 pWidget->setFeatures(QDockWidget::DockWidgetFeature::DockWidgetClosable |
190 QDockWidget::DockWidgetFeature::DockWidgetMovable |
191 QDockWidget::DockWidgetFeature::DockWidgetFloatable);
192 pWidget->setFocusPolicy(Qt::NoFocus);
193
194 pWidget->setEditor(mEditor);
195 pWidget->initUI();
196 qDebug() << "Init Dock widget: " << pWidget->objectName();
197 }
198
199 addDockWidget(Qt::RightDockWidgetArea, mColorBox);
200 addDockWidget(Qt::RightDockWidgetArea, mColorInspector);
201 addDockWidget(Qt::RightDockWidgetArea, mColorPalette);
202 addDockWidget(Qt::LeftDockWidgetArea, mToolBox);
203 addDockWidget(Qt::LeftDockWidgetArea, mToolOptions);
204 addDockWidget(Qt::LeftDockWidgetArea, mOnionSkinWidget);
205 addDockWidget(Qt::BottomDockWidgetArea, mTimeLine);
206 setDockNestingEnabled(true);
207
208 /*
209 mPreview = new PreviewWidget( this );
210 mPreview->setImage( mScribbleArea->mBufferImg );
211 mPreview->setFeatures( QDockWidget::DockWidgetFloatable );
212 mPreview->setFocusPolicy( Qt::NoFocus );
213 addDockWidget( Qt::RightDockWidgetArea, mPreview );
214 */
215
216 makeConnections(mEditor, ui->scribbleArea);
217 makeConnections(mEditor);
218 makeConnections(mEditor, mTimeLine);
219 makeConnections(mEditor, mColorBox);
220 makeConnections(mEditor, mColorInspector);
221 makeConnections(mEditor, mColorPalette);
222 makeConnections(mEditor, mToolOptions);
223 makeConnections(mEditor, ui->statusBar);
224
225 for (BaseDockWidget* w : mDockWidgets)
226 {
227 w->setFloating(false);
228 w->show();
229 w->updateUI();
230 }
231}
232
233void MainWindow2::createMenus()
234{
235 //--- File Menu ---
236 connect(ui->actionNew, &QAction::triggered, this, &MainWindow2::newDocument);
237 connect(ui->actionOpen, &QAction::triggered, this, &MainWindow2::openDocument);
238 connect(ui->actionSave_as, &QAction::triggered, this, &MainWindow2::saveAsNewDocument);
239 connect(ui->actionSave, &QAction::triggered, this, &MainWindow2::saveDocument);
240 connect(ui->actionExit, &QAction::triggered, this, &MainWindow2::close);
241
242 //--- Export Menu ---
243 connect(ui->actionExport_Image, &QAction::triggered, mCommands, &ActionCommands::exportImage);
244 connect(ui->actionExport_ImageSeq, &QAction::triggered, mCommands, &ActionCommands::exportImageSequence);
245 connect(ui->actionExport_Movie, &QAction::triggered, mCommands, &ActionCommands::exportMovie);
246 connect(ui->actionExport_Animated_GIF, &QAction::triggered, mCommands, &ActionCommands::exportGif);
247
248 connect(ui->actionExport_Palette, &QAction::triggered, this, &MainWindow2::exportPalette);
249
250 //--- Import Menu ---
251 //connect( ui->actionExport_Svg_Image, &QAction::triggered, editor, &Editor::saveSvg );
252 connect(ui->actionImport_Image, &QAction::triggered, this, &MainWindow2::importImage);
253 connect(ui->actionImport_ImageSeq, &QAction::triggered, this, &MainWindow2::importImageSequence);
254 connect(ui->actionImport_ImageSeqNum, &QAction::triggered, this, &MainWindow2::importPredefinedImageSet);
255 connect(ui->actionImportLayers_from_pclx, &QAction::triggered, this, &MainWindow2::importLayers);
256 connect(ui->actionImport_MovieVideo, &QAction::triggered, this, &MainWindow2::importMovieVideo);
257 connect(ui->actionImport_AnimatedImage, &QAction::triggered, this, &MainWindow2::importAnimatedImage);
258
259 connect(ui->actionImport_Sound, &QAction::triggered, [=] { mCommands->importSound(FileType::SOUND); });
260 connect(ui->actionImport_MovieAudio, &QAction::triggered, [=] { mCommands->importSound(FileType::MOVIE); });
261
262 connect(ui->actionImport_Append_Palette, &QAction::triggered, this, &MainWindow2::importPalette);
263 connect(ui->actionImport_Replace_Palette, &QAction::triggered, this, &MainWindow2::openPalette);
264
265 //--- Edit Menu ---
266 replaceUndoRedoActions();
267 connect(ui->actionCut, &QAction::triggered, mEditor, &Editor::copyAndCut);
268 connect(ui->actionCopy, &QAction::triggered, mEditor, &Editor::copy);
269 connect(ui->actionPaste_Previous, &QAction::triggered, mEditor, &Editor::pasteFromPreviousFrame);
270 connect(ui->actionPaste, &QAction::triggered, mEditor, &Editor::paste);
271 connect(ui->actionClearFrame, &QAction::triggered, mEditor, &Editor::clearCurrentFrame);
272 connect(mEditor->select(), &SelectionManager::selectionChanged, this, &MainWindow2::selectionChanged);
273 connect(ui->actionFlip_X, &QAction::triggered, mCommands, &ActionCommands::flipSelectionX);
274 connect(ui->actionFlip_Y, &QAction::triggered, mCommands, &ActionCommands::flipSelectionY);
275 connect(ui->actionPegbarAlignment, &QAction::triggered, this, &MainWindow2::openPegAlignDialog);
276 connect(ui->actionSelect_All, &QAction::triggered, mCommands, &ActionCommands::selectAll);
277 connect(ui->actionDeselect_All, &QAction::triggered, mCommands, &ActionCommands::deselectAll);
278 connect(ui->actionReposition_Selected_Frames, &QAction::triggered, this, &MainWindow2::openRepositionDialog);
279 connect(ui->actionPreference, &QAction::triggered, [=] { preferences(); });
280
281 //--- Layer Menu ---
282 connect(ui->actionNew_Bitmap_Layer, &QAction::triggered, mCommands, &ActionCommands::addNewBitmapLayer);
283 connect(ui->actionNew_Vector_Layer, &QAction::triggered, mCommands, &ActionCommands::addNewVectorLayer);
284 connect(ui->actionNew_Sound_Layer, &QAction::triggered, mCommands, &ActionCommands::addNewSoundLayer);
285 connect(ui->actionNew_Camera_Layer, &QAction::triggered, mCommands, &ActionCommands::addNewCameraLayer);
286 connect(ui->actionDelete_Current_Layer, &QAction::triggered, mCommands, &ActionCommands::deleteCurrentLayer);
287 connect(ui->actionChangeLineColorCurrent_keyframe, &QAction::triggered, mCommands, &ActionCommands::changeKeyframeLineColor);
288 connect(ui->actionChangeLineColorAll_keyframes_on_layer, &QAction::triggered, mCommands, &ActionCommands::changeallKeyframeLineColor);
289 connect(ui->actionChangeLayerOpacity, &QAction::triggered, this, &MainWindow2::openLayerOpacityDialog);
290
291 QList<QAction*> visibilityActions = ui->menuLayer_Visibility->actions();
292 auto visibilityGroup = new QActionGroup(this);
293 visibilityGroup->setExclusive(true);
294 for (int i = 0; i < visibilityActions.size(); i++) {
295 QAction* action = visibilityActions[i];
296 visibilityGroup->addAction(action);
297 connect(action, &QAction::triggered, [=] { mCommands->setLayerVisibilityIndex(i); });
298 }
299 visibilityActions[mEditor->preference()->getInt(SETTING::LAYER_VISIBILITY)]->setChecked(true);
300 connect(mEditor->preference(), &PreferenceManager::optionChanged, [=](SETTING e) {
301 if (e == SETTING::LAYER_VISIBILITY) {
302 visibilityActions[mEditor->preference()->getInt(SETTING::LAYER_VISIBILITY)]->setChecked(true);
303 }
304 });
305
306 // --- View Menu ---
307 connect(ui->actionZoom_In, &QAction::triggered, mCommands, &ActionCommands::ZoomIn);
308 connect(ui->actionZoom_Out, &QAction::triggered, mCommands, &ActionCommands::ZoomOut);
309 connect(ui->actionRotate_Clockwise, &QAction::triggered, mCommands, &ActionCommands::rotateClockwise);
310 connect(ui->actionRotate_Anticlockwise, &QAction::triggered, mCommands, &ActionCommands::rotateCounterClockwise);
311 connect(ui->actionReset_Rotation, &QAction::triggered, mEditor->view(), &ViewManager::resetRotation);
312 connect(ui->actionReset_View, &QAction::triggered, mEditor->view(), &ViewManager::resetView);
313 connect(ui->actionCenter_View, &QAction::triggered, mEditor->view(), &ViewManager::centerView);
314 connect(ui->actionZoom400, &QAction::triggered, mEditor->view(), &ViewManager::scale400);
315 connect(ui->actionZoom300, &QAction::triggered, mEditor->view(), &ViewManager::scale300);
316 connect(ui->actionZoom200, &QAction::triggered, mEditor->view(), &ViewManager::scale200);
317 connect(ui->actionZoom100, &QAction::triggered, mEditor->view(), &ViewManager::scale100);
318 connect(ui->actionZoom50, &QAction::triggered, mEditor->view(), &ViewManager::scale50);
319 connect(ui->actionZoom33, &QAction::triggered, mEditor->view(), &ViewManager::scale33);
320 connect(ui->actionZoom25, &QAction::triggered, mEditor->view(), &ViewManager::scale25);
321 connect(ui->actionHorizontal_Flip, &QAction::triggered, mEditor->view(), &ViewManager::flipHorizontal);
322 connect(ui->actionVertical_Flip, &QAction::triggered, mEditor->view(), &ViewManager::flipVertical);
323 connect(mEditor->view(), &ViewManager::viewFlipped, this, &MainWindow2::viewFlipped);
324
325 PreferenceManager* prefs = mEditor->preference();
326 connect(ui->actionStatusBar, &QAction::triggered, ui->statusBar, &QStatusBar::setVisible);
327 bindPreferenceSetting(ui->actionStatusBar, prefs, SETTING::SHOW_STATUS_BAR);
328 bindPreferenceSetting(ui->actionThreePointPerspective, prefs, SETTING::OVERLAY_PERSPECTIVE3);
329 bindPreferenceSetting(ui->actionTwoPointPerspective, prefs, SETTING::OVERLAY_PERSPECTIVE2);
330 bindPreferenceSetting(ui->actionOnePointPerspective, prefs, SETTING::OVERLAY_PERSPECTIVE1);
331 bindPreferenceSetting(ui->actionSafeAreas, prefs, SETTING::OVERLAY_SAFE);
332 bindPreferenceSetting(ui->actionGoldenRatio, prefs, SETTING::OVERLAY_GOLDEN);
333 bindPreferenceSetting(ui->actionThirds, prefs, SETTING::OVERLAY_THIRDS);
334 bindPreferenceSetting(ui->actionCenter, prefs, SETTING::OVERLAY_CENTER);
335 bindPreferenceSetting(ui->actionGrid, prefs, SETTING::GRID);
336 bindPreferenceSetting(ui->actionShowOutlinesOnly, prefs, SETTING::OUTLINES);
337 bindPreferenceSetting(ui->actionShowInvisibleLines, prefs, SETTING::INVISIBLE_LINES);
338 bindPreferenceSetting(ui->actionOnionPrev, prefs, SETTING::PREV_ONION);
339 bindPreferenceSetting(ui->actionOnionNext, prefs, SETTING::NEXT_ONION);
340
341 bool enableSafeArea = (prefs->isOn(SETTING::ACTION_SAFE_ON) || prefs->isOn(SETTING::TITLE_SAFE_ON));
342 ui->actionSafeAreas->setEnabled(enableSafeArea);
343
344 auto perspectiveLinesAngleGroup = new QActionGroup(this);
345 perspectiveLinesAngleGroup->setExclusive(true);
346 perspectiveLinesAngleGroup->addAction(ui->action2Degrees);
347 perspectiveLinesAngleGroup->addAction(ui->action3Degrees);
348 perspectiveLinesAngleGroup->addAction(ui->action5Degrees);
349 perspectiveLinesAngleGroup->addAction(ui->action7_5Degrees);
350 perspectiveLinesAngleGroup->addAction(ui->action10Degrees);
351 perspectiveLinesAngleGroup->addAction(ui->action15Degrees);
352 perspectiveLinesAngleGroup->addAction(ui->action20Degrees);
353 perspectiveLinesAngleGroup->addAction(ui->action30Degrees);
354 connect(perspectiveLinesAngleGroup, &QActionGroup::triggered, this, [&](QAction* action) {
355 if (action == ui->action2Degrees) mEditor->preference()->set(SETTING::OVERLAY_ANGLE, 2);
356 else if (action == ui->action3Degrees) mEditor->preference()->set(SETTING::OVERLAY_ANGLE, 3);
357 else if (action == ui->action5Degrees) mEditor->preference()->set(SETTING::OVERLAY_ANGLE, 5);
358 else if (action == ui->action7_5Degrees) mEditor->preference()->set(SETTING::OVERLAY_ANGLE, 7);
359 else if (action == ui->action10Degrees) mEditor->preference()->set(SETTING::OVERLAY_ANGLE, 10);
360 else if (action == ui->action15Degrees) mEditor->preference()->set(SETTING::OVERLAY_ANGLE, 15);
361 else if (action == ui->action20Degrees) mEditor->preference()->set(SETTING::OVERLAY_ANGLE, 20);
362 else if (action == ui->action30Degrees) mEditor->preference()->set(SETTING::OVERLAY_ANGLE, 30);
363 else Q_UNREACHABLE();
364 emit mEditor->view()->viewChanged();
365 });
366
367 switch (prefs->getInt(SETTING::OVERLAY_ANGLE)) {
368 case 2: ui->action2Degrees->setChecked(true); break;
369 case 3: ui->action3Degrees->setChecked(true); break;
370 case 5: ui->action5Degrees->setChecked(true); break;
371 case 7: ui->action7_5Degrees->setChecked(true); break;
372 case 10: ui->action10Degrees->setChecked(true); break;
373 case 15: ui->action15Degrees->setChecked(true); break;
374 case 20: ui->action20Degrees->setChecked(true); break;
375 case 30: ui->action30Degrees->setChecked(true); break;
376 }
377
378 //--- Animation Menu ---
379 PlaybackManager* pPlaybackManager = mEditor->playback();
380 connect(ui->actionPlay, &QAction::triggered, mCommands, &ActionCommands::PlayStop);
381
382 connect(ui->actionLoop, &QAction::triggered, pPlaybackManager, &PlaybackManager::setLooping);
383 connect(ui->actionLoopControl, &QAction::triggered, pPlaybackManager, &PlaybackManager::enableRangedPlayback);
384 connect(pPlaybackManager, &PlaybackManager::loopStateChanged, ui->actionLoop, &QAction::setChecked);
385 connect(pPlaybackManager, &PlaybackManager::loopStateChanged, mTimeLine, &TimeLine::setLoop);
386 connect(pPlaybackManager, &PlaybackManager::rangedPlaybackStateChanged, ui->actionLoopControl, &QAction::setChecked);
387 connect(pPlaybackManager, &PlaybackManager::rangedPlaybackStateChanged, mTimeLine, &TimeLine::setRangeState);
388 connect(pPlaybackManager, &PlaybackManager::playStateChanged, mTimeLine, &TimeLine::setPlaying);
389 connect(pPlaybackManager, &PlaybackManager::playStateChanged, this, &MainWindow2::changePlayState);
390 connect(pPlaybackManager, &PlaybackManager::playStateChanged, ui->scribbleArea, &ScribbleArea::onPlayStateChanged);
391 connect(ui->actionFlip_inbetween, &QAction::triggered, pPlaybackManager, &PlaybackManager::playFlipInBetween);
392 connect(ui->actionFlip_rolling, &QAction::triggered, pPlaybackManager, &PlaybackManager::playFlipRoll);
393
394 connect(ui->actionAdd_Frame, &QAction::triggered, mCommands, &ActionCommands::insertKeyFrameAtCurrentPosition);
395 connect(ui->actionRemove_Frame, &QAction::triggered, mCommands, &ActionCommands::removeKey);
396 connect(ui->actionAdd_Frame_Exposure, &QAction::triggered, mCommands, &ActionCommands::addExposureToSelectedFrames);
397 connect(ui->actionSubtract_Frame_Exposure, &QAction::triggered, mCommands, &ActionCommands::subtractExposureFromSelectedFrames);
398 connect(ui->actionNext_Frame, &QAction::triggered, mCommands, &ActionCommands::GotoNextFrame);
399 connect(ui->actionPrevious_Frame, &QAction::triggered, mCommands, &ActionCommands::GotoPrevFrame);
400 connect(ui->actionNext_KeyFrame, &QAction::triggered, mCommands, &ActionCommands::GotoNextKeyFrame);
401 connect(ui->actionPrev_KeyFrame, &QAction::triggered, mCommands, &ActionCommands::GotoPrevKeyFrame);
402 connect(ui->actionDuplicate_Frame, &QAction::triggered, mCommands, &ActionCommands::duplicateKey);
403 connect(ui->actionMove_Frame_Forward, &QAction::triggered, mCommands, &ActionCommands::moveFrameForward);
404 connect(ui->actionMove_Frame_Backward, &QAction::triggered, mCommands, &ActionCommands::moveFrameBackward);
405
406 connect(ui->actionReverse_Frames_Order, &QAction::triggered, mCommands, &ActionCommands::reverseSelectedFrames);
407 connect(ui->actionRemove_Frames, &QAction::triggered, mCommands, &ActionCommands::removeSelectedFrames);
408
409 //--- Tool Menu ---
410 connect(ui->actionMove, &QAction::triggered, mToolBox, &ToolBoxWidget::moveOn);
411 connect(ui->actionSelect, &QAction::triggered, mToolBox, &ToolBoxWidget::selectOn);
412 connect(ui->actionBrush, &QAction::triggered, mToolBox, &ToolBoxWidget::brushOn);
413 connect(ui->actionPolyline, &QAction::triggered, mToolBox, &ToolBoxWidget::polylineOn);
414 connect(ui->actionSmudge, &QAction::triggered, mToolBox, &ToolBoxWidget::smudgeOn);
415 connect(ui->actionPen, &QAction::triggered, mToolBox, &ToolBoxWidget::penOn);
416 connect(ui->actionHand, &QAction::triggered, mToolBox, &ToolBoxWidget::handOn);
417 connect(ui->actionPencil, &QAction::triggered, mToolBox, &ToolBoxWidget::pencilOn);
418 connect(ui->actionBucket, &QAction::triggered, mToolBox, &ToolBoxWidget::bucketOn);
419 connect(ui->actionEyedropper, &QAction::triggered, mToolBox, &ToolBoxWidget::eyedropperOn);
420 connect(ui->actionEraser, &QAction::triggered, mToolBox, &ToolBoxWidget::eraserOn);
421 connect(ui->actionResetToolsDefault, &QAction::triggered, mEditor->tools(), &ToolManager::resetAllTools);
422
423 //--- Window Menu ---
424 QMenu* winMenu = ui->menuWindows;
425 const std::vector<QAction*> actions
426 {
427 mToolBox->toggleViewAction(),
428 mToolOptions->toggleViewAction(),
429 mColorBox->toggleViewAction(),
430 mColorPalette->toggleViewAction(),
431 mTimeLine->toggleViewAction(),
432 mColorInspector->toggleViewAction(),
433 mOnionSkinWidget->toggleViewAction()
434 };
435
436 for (QAction* action : actions)
437 {
438 action->setMenuRole(QAction::NoRole);
439 winMenu->insertAction(ui->menuToolbars->menuAction(), action);
440 }
441 winMenu->insertSeparator(ui->menuToolbars->menuAction());
442 connect(ui->actionResetWindows, &QAction::triggered, this, &MainWindow2::resetAndDockAllSubWidgets);
443 connect(ui->actionLockWindows, &QAction::toggled, this, &MainWindow2::lockWidgets);
444 bindPreferenceSetting(ui->actionLockWindows, prefs, SETTING::LAYOUT_LOCK);
445
446 //--- Help Menu ---
447 connect(ui->actionHelp, &QAction::triggered, mCommands, &ActionCommands::help);
448 connect(ui->actionQuick_Guide, &QAction::triggered, mCommands, &ActionCommands::quickGuide);
449 connect(ui->actionWebsite, &QAction::triggered, mCommands, &ActionCommands::website);
450 connect(ui->actionForum, &QAction::triggered, mCommands, &ActionCommands::forum);
451 connect(ui->actionDiscord, &QAction::triggered, mCommands, &ActionCommands::discord);
452 connect(ui->actionCheck_for_Updates, &QAction::triggered, mCommands, &ActionCommands::checkForUpdates);
453 connect(ui->actionReport_Bug, &QAction::triggered, mCommands, &ActionCommands::reportbug);
454 connect(ui->actionOpen_Temporary_Directory, &QAction::triggered, mCommands, &ActionCommands::openTemporaryDirectory);
455 connect(ui->actionAbout, &QAction::triggered, mCommands, &ActionCommands::about);
456
457 //--- Menus ---
458 mRecentFileMenu = new RecentFileMenu(tr("Open Recent"), this);
459 mRecentFileMenu->loadFromDisk();
460 ui->menuFile->insertMenu(ui->actionSave, mRecentFileMenu);
461
462 connect(mRecentFileMenu, &RecentFileMenu::loadRecentFile, this, &MainWindow2::openFile);
463}
464
465void MainWindow2::replaceUndoRedoActions()
466{
467 ui->menuEdit->removeAction(ui->actionUndo);
468 ui->menuEdit->removeAction(ui->actionRedo);
469 ui->actionUndo = mEditor->undoRedo()->createUndoAction(this, ui->actionUndo->icon());
470 ui->actionRedo = mEditor->undoRedo()->createRedoAction(this, ui->actionRedo->icon());
471 ui->menuEdit->insertAction(ui->actionCut, ui->actionUndo);
472 ui->menuEdit->insertAction(ui->actionCut, ui->actionRedo);
473}
474
475void MainWindow2::setOpacity(int opacity)
476{
477 mEditor->preference()->set(SETTING::WINDOW_OPACITY, 100 - opacity);
478 setWindowOpacity(opacity / 100.0);
479}
480
481void MainWindow2::updateSaveState()
482{
483 const bool hasUnsavedChanges = mEditor->undoRedo()->hasUnsavedChanges();
484 setWindowModified(hasUnsavedChanges);
485 ui->statusBar->updateModifiedStatus(hasUnsavedChanges);
486}
487
488void MainWindow2::updateBackupActionState()
489{
490 mEditor->undoRedo()->updateUndoAction(ui->actionUndo);
491 mEditor->undoRedo()->updateRedoAction(ui->actionRedo);
492}
493
494void MainWindow2::openPegAlignDialog()
495{
496 if (mPegAlign != nullptr)
497 {
498 QMessageBox::information(this, nullptr,
499 tr("Dialog is already open!"),
500 QMessageBox::Ok);
501 return;
502 }
503
504 mPegAlign = new PegBarAlignmentDialog(mEditor, this);
505 mPegAlign->setAttribute(Qt::WA_DeleteOnClose);
506
507 Qt::WindowFlags flags = mPegAlign->windowFlags();
508 flags |= Qt::WindowStaysOnTopHint;
509 flags &= (~Qt::WindowContextHelpButtonHint);
510 mPegAlign->setWindowFlags(flags);
511 mPegAlign->show();
512 connect(mPegAlign, &PegBarAlignmentDialog::finished, [=]
513 {
514 mPegAlign = nullptr;
515 });
516}
517
518void MainWindow2::openLayerOpacityDialog()
519{
520 if (mLayerOpacityDialog != nullptr)
521 {
522 QMessageBox::information(this, nullptr,
523 tr("Dialog is already open!"),
524 QMessageBox::Ok);
525 return;
526 }
527 mLayerOpacityDialog = new LayerOpacityDialog(this);
528 mLayerOpacityDialog->setAttribute(Qt::WA_DeleteOnClose);
529 mLayerOpacityDialog->setCore(mEditor);
530 mLayerOpacityDialog->initUI();
531 mLayerOpacityDialog->setWindowFlags(mLayerOpacityDialog->windowFlags() | Qt::WindowStaysOnTopHint);
532 mLayerOpacityDialog->show();
533
534 connect(mLayerOpacityDialog, &LayerOpacityDialog::finished, [=]
535 {
536 mLayerOpacityDialog = nullptr;
537 });
538}
539
540void MainWindow2::openRepositionDialog()
541{
542 if (mEditor->layers()->currentLayer()->getSelectedFramesByPos().count() < 2)
543 {
544 QMessageBox::information(this, nullptr,
545 tr("Please select at least 2 frames!"),
546 QMessageBox::Ok);
547 return;
548 }
549 if (mReposDialog != nullptr)
550 {
551 return;
552 }
553
554 mReposDialog = new RepositionFramesDialog(this);
555 mReposDialog->setAttribute(Qt::WA_DeleteOnClose);
556 mReposDialog->setWindowFlags(mReposDialog->windowFlags() | Qt::WindowStaysOnTopHint);
557 hideQuestionMark(*mReposDialog);
558 mReposDialog->setCore(mEditor);
559 mReposDialog->initUI();
560 mEditor->tools()->setCurrentTool(ToolType::MOVE);
561 connect(mReposDialog, &RepositionFramesDialog::finished, this, &MainWindow2::closeRepositionDialog);
562 mReposDialog->show();
563}
564
565void MainWindow2::closeRepositionDialog()
566{
567 selectionChanged();
568 mReposDialog = nullptr;
569}
570
571void MainWindow2::currentLayerChanged()
572{
573 bool isBitmap = (mEditor->layers()->currentLayer()->type() == Layer::BITMAP);
574 ui->menuChange_line_color->setEnabled(isBitmap);
575
576 bool isVector = (mEditor->layers()->currentLayer()->type() == Layer::VECTOR);
577 ui->actionShowInvisibleLines->setEnabled(isVector);
578 ui->actionShowOutlinesOnly->setEnabled(isVector);
579}
580
581void MainWindow2::selectionChanged()
582{
583 bool somethingSelected = mEditor->select()->somethingSelected();
584 ui->menuSelection->setEnabled(somethingSelected);
585}
586
587void MainWindow2::viewFlipped()
588{
589 ui->actionHorizontal_Flip->setChecked(mEditor->view()->isFlipHorizontal());
590 ui->actionVertical_Flip->setChecked(mEditor->view()->isFlipVertical());
591}
592
593void MainWindow2::closeEvent(QCloseEvent* event)
594{
595 if (m2ndCloseEvent)
596 {
597 // https://bugreports.qt.io/browse/QTBUG-43344
598 event->accept();
599 return;
600 }
601
602 if (!maybeSave())
603 {
604 event->ignore();
605 return;
606 }
607 writeSettings();
608 event->accept();
609 m2ndCloseEvent = true;
610}
611
612void MainWindow2::tabletEvent(QTabletEvent* event)
613{
614 event->ignore();
615}
616
617void MainWindow2::newDocument()
618{
619 if (maybeSave() && !tryLoadPreset())
620 {
621 newObject();
622 }
623}
624
625void MainWindow2::openDocument()
626{
627 if (!maybeSave())
628 {
629 return;
630 }
631 QString fileName = FileDialog::getOpenFileName(this, FileType::ANIMATION);
632 if (!fileName.isEmpty())
633 {
634 openObject(fileName);
635 }
636}
637
638bool MainWindow2::saveAsNewDocument()
639{
640 QString fileName = FileDialog::getSaveFileName(this, FileType::ANIMATION);
641 if (fileName.isEmpty())
642 {
643 return false;
644 }
645 return saveObject(fileName);
646}
647
648void MainWindow2::openStartupFile(const QString& filename)
649{
650 if (tryRecoverUnsavedProject())
651 {
652 return;
653 }
654
655 if (!filename.isEmpty() && openObject(filename))
656 {
657 return;
658 }
659
660 loadMostRecent() || tryLoadPreset();
661}
662
663void MainWindow2::openFile(const QString& filename)
664{
665 if (maybeSave())
666 {
667 openObject(filename);
668 }
669}
670
671bool MainWindow2::openObject(const QString& strFilePath)
672{
673 QProgressDialog progress(tr("Opening document..."), tr("Abort"), 0, 100, this);
674 hideQuestionMark(progress);
675 progress.setWindowModality(Qt::WindowModal);
676 progress.show();
677
678 Status s = mEditor->openObject(strFilePath, [&progress](int p)
679 {
680 progress.setValue(p);
681 QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
682 }, [&progress](int max)
683 {
684 progress.setRange(0, max);
685 });
686
687 if (!s.ok())
688 {
689 ErrorDialog errorDialog(s.title(), s.description(), s.details().str());
690 errorDialog.exec();
691 emptyDocumentWhenErrorOccurred();
692 return false;
693 }
694
695 QSettings settings(PENCIL2D, PENCIL2D);
696 settings.setValue(LAST_PCLX_PATH, mEditor->object()->filePath());
697
698 // Add to recent file list, but only if we are
699 if (!mEditor->object()->filePath().isEmpty())
700 {
701 mRecentFileMenu->addRecentFile(mEditor->object()->filePath());
702 mRecentFileMenu->saveToDisk();
703 }
704
705 closeDialogs();
706
707 setWindowTitle(mEditor->object()->filePath().prepend("[*]"));
708 setWindowModified(false);
709 ui->statusBar->updateModifiedStatus(false);
710
711 progress.setValue(progress.maximum());
712
713 updateSaveState();
714 updateBackupActionState();
715
716 if (!QFileInfo(strFilePath).isWritable())
717 {
718 QMessageBox::warning(this, tr("Warning"),
719 tr("This program does not currently have permission to write to the file you have selected. "
720 "Please make sure you have write permission for this file before attempting to save it. "
721 "Alternatively, you can use the Save As... menu option to save to a writable location."),
722 QMessageBox::Ok);
723 }
724
725 return true;
726}
727
728bool MainWindow2::saveObject(QString strSavedFileName)
729{
730 QProgressDialog progress(tr("Saving document..."), tr("Abort"), 0, 100, this);
731 hideQuestionMark(progress);
732 progress.setWindowModality(Qt::WindowModal);
733 progress.show();
734
735 mEditor->prepareSave();
736
737 FileManager fm(this);
738
739 connect(&fm, &FileManager::progressChanged, [&progress](int p)
740 {
741 progress.setValue(p);
742 QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
743 });
744 connect(&fm, &FileManager::progressRangeChanged, [&progress](int max)
745 {
746 progress.setRange(0, max + 3);
747 });
748
749 Status st = fm.save(mEditor->object(), strSavedFileName);
750
751
752 if (!st.ok())
753 {
754#if QT_VERSION >= QT_VERSION_CHECK(5, 4, 0)
755 QDir errorLogFolder(QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation));
756#else
757 QDir errorLogFolder(QStandardPaths::writableLocation(QStandardPaths::DataLocation));
758#endif
759 errorLogFolder.mkpath("./logs");
760 errorLogFolder.cd("logs");
761
762 QDateTime dt = QDateTime::currentDateTime();
763 dt.setTimeSpec(Qt::UTC);
764 QFile eLog(errorLogFolder.absoluteFilePath(QString("error-%1.txt").arg(dt.toString(Qt::ISODate))));
765 if (eLog.open(QIODevice::WriteOnly | QIODevice::Text))
766 {
767 QTextStream out(&eLog);
768 out << st.details().str();
769 }
770 eLog.close();
771
772 ErrorDialog errorDialog(st.title(),
773 st.description().append(tr("<br><br>An error has occurred and your file may not have saved successfully."
774 "\nIf you believe that this error is an issue with Pencil2D, please create a new issue at:"
775 "<br><a href='https://github.com/pencil2d/pencil/issues'>https://github.com/pencil2d/pencil/issues</a><br>"
776 "Please be sure to include the following details in your issue:")), st.details().html());
777 errorDialog.exec();
778 return false;
779 }
780
781 mEditor->object()->setFilePath(strSavedFileName);
782 mEditor->object()->setModified(false);
783
784 mEditor->clearTemporary();
785
786 QSettings settings(PENCIL2D, PENCIL2D);
787 settings.setValue(LAST_PCLX_PATH, strSavedFileName);
788
789 mRecentFileMenu->addRecentFile(strSavedFileName);
790 mRecentFileMenu->saveToDisk();
791
792 mTimeLine->updateContent();
793
794 setWindowTitle(strSavedFileName.prepend("[*]"));
795 updateSaveState();
796
797 progress.setValue(progress.maximum());
798
799 mEditor->resetAutoSaveCounter();
800
801 return true;
802}
803
804bool MainWindow2::saveDocument()
805{
806 if (!mEditor->object()->filePath().isEmpty())
807 return saveObject(mEditor->object()->filePath());
808 else
809 return saveAsNewDocument();
810}
811
812bool MainWindow2::maybeSave()
813{
814 if (!mEditor->undoRedo()->hasUnsavedChanges())
815 {
816 return true;
817 }
818
819 int ret = QMessageBox::warning(this, tr("Warning"),
820 tr("This animation has been modified.\n Do you want to save your changes?"),
821 QMessageBox::Discard | QMessageBox::Save | QMessageBox::Cancel);
822 if (ret == QMessageBox::Save)
823 return saveDocument();
824 else
825 return ret == QMessageBox::Discard;
826}
827
828bool MainWindow2::autoSave()
829{
830 if (!mEditor->object()->filePath().isEmpty())
831 {
832 return saveDocument();
833 }
834
835 if (mEditor->autoSaveNeverAskAgain())
836 return false;
837
838 if(mSuppressAutoSaveDialog)
839 return false;
840
841 QMessageBox msgBox(this);
842 msgBox.setIcon(QMessageBox::Question);
843 msgBox.setWindowTitle(tr("AutoSave Reminder"));
844 msgBox.setText(tr("The animation is not saved yet.\n Do you want to save now?"));
845 msgBox.addButton(tr("Never ask again", "AutoSave reminder button"), QMessageBox::RejectRole);
846 msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
847 msgBox.setDefaultButton(QMessageBox::Yes);
848
849 int ret = msgBox.exec();
850 if (ret == QMessageBox::Yes)
851 {
852 return saveDocument();
853 }
854 if (ret != QMessageBox::No) // Never ask again
855 {
856 mEditor->dontAskAutoSave(true);
857 }
858
859 return false;
860}
861
862void MainWindow2::emptyDocumentWhenErrorOccurred()
863{
864 newObject();
865
866 setWindowTitle(PENCIL_WINDOW_TITLE);
867 updateSaveState();
868}
869
870void MainWindow2::importImage()
871{
872 QString strFilePath = FileDialog::getOpenFileName(this, FileType::IMAGE);
873
874 if (strFilePath.isEmpty()) { return; }
875 if (!QFile::exists(strFilePath)) { return; }
876
877 ImportPositionDialog* positionDialog = new ImportPositionDialog(mEditor, this);
878 OnScopeExit(delete positionDialog)
879
880 positionDialog->exec();
881
882 if (positionDialog->result() != QDialog::Accepted)
883 {
884 return;
885 }
886
887 Status st = mEditor->importImage(strFilePath);
888 if (!st.ok())
889 {
890 ErrorDialog errorDialog(st.title(), st.description(), st.details().html());
891 errorDialog.exec();
892 return;
893 }
894
895 ui->scribbleArea->updateFrame();
896 mTimeLine->updateContent();
897}
898
899void MainWindow2::importImageSequence()
900{
901 mSuppressAutoSaveDialog = true;
902
903 ImportImageSeqDialog* imageSeqDialog = new ImportImageSeqDialog(this);
904 OnScopeExit(delete imageSeqDialog)
905 imageSeqDialog->setCore(mEditor);
906
907 connect(imageSeqDialog, &ImportImageSeqDialog::notifyAnimationLengthChanged, mEditor->layers(), &LayerManager::notifyAnimationLengthChanged);
908
909 imageSeqDialog->exec();
910 if (imageSeqDialog->result() == QDialog::Rejected)
911 {
912 return;
913 }
914
915 ImportPositionDialog* positionDialog = new ImportPositionDialog(mEditor, this);
916 OnScopeExit(delete positionDialog)
917
918 positionDialog->exec();
919 if (positionDialog->result() != QDialog::Accepted)
920 {
921 return;
922 }
923
924 imageSeqDialog->importArbitrarySequence();
925
926 mSuppressAutoSaveDialog = false;
927}
928
929void MainWindow2::importPredefinedImageSet()
930{
931 ImportImageSeqDialog* imageSeqDialog = new ImportImageSeqDialog(this, ImportExportDialog::Import, FileType::IMAGE, ImportCriteria::PredefinedSet);
932 OnScopeExit(delete imageSeqDialog)
933 imageSeqDialog->setCore(mEditor);
934
935 connect(imageSeqDialog, &ImportImageSeqDialog::notifyAnimationLengthChanged, mEditor->layers(), &LayerManager::notifyAnimationLengthChanged);
936
937 mSuppressAutoSaveDialog = true;
938 imageSeqDialog->exec();
939 if (imageSeqDialog->result() == QDialog::Rejected)
940 {
941 return;
942 }
943
944 ImportPositionDialog* positionDialog = new ImportPositionDialog(mEditor, this);
945 OnScopeExit(delete positionDialog)
946
947 positionDialog->exec();
948 if (positionDialog->result() != QDialog::Accepted)
949 {
950 return;
951 }
952
953 imageSeqDialog->importPredefinedSet();
954 mSuppressAutoSaveDialog = false;
955}
956
957void MainWindow2::importLayers()
958{
959 ImportLayersDialog* importLayers = new ImportLayersDialog(this);
960 importLayers->setCore(mEditor);
961 importLayers->setAttribute(Qt::WA_DeleteOnClose);
962 importLayers->open();
963}
964
965void MainWindow2::importAnimatedImage()
966{
967 // Flag this so we don't prompt the user about auto-save in the middle of the import.
968 mSuppressAutoSaveDialog = true;
969
970 mCommands->importAnimatedImage();
971
972 mSuppressAutoSaveDialog = false;
973}
974
975void MainWindow2::lockWidgets(bool shouldLock)
976{
977 QDockWidget::DockWidgetFeatures feat = shouldLock
978 ? QDockWidget::NoDockWidgetFeatures
979 : (QDockWidget::DockWidgetFeature::DockWidgetClosable |
980 QDockWidget::DockWidgetFeature::DockWidgetMovable |
981 QDockWidget::DockWidgetFeature::DockWidgetFloatable);
982
983 for (QDockWidget* d : mDockWidgets)
984 {
985 d->setFeatures(feat);
986
987 // https://doc.qt.io/qt-5/qdockwidget.html#setTitleBarWidget
988 // A empty QWidget looks like the tittle bar is hidden.
989 // nullptr means removing the custom title bar and restoring the default one
990 QWidget* customTitleBarWidget = shouldLock ? (new QWidget) : nullptr;
991 d->setTitleBarWidget(customTitleBarWidget);
992 }
993}
994
995void MainWindow2::preferences()
996{
997 if (mPrefDialog)
998 {
999 mPrefDialog->activateWindow();
1000 mPrefDialog->raise();
1001 return;
1002 }
1003 mPrefDialog = new PreferencesDialog(this);
1004 mPrefDialog->setWindowFlags(Qt::Dialog | Qt::WindowTitleHint | Qt::WindowCloseButtonHint);
1005 mPrefDialog->setAttribute(Qt::WA_DeleteOnClose);
1006 mPrefDialog->init(mEditor->preference());
1007
1008 connect(mPrefDialog, &PreferencesDialog::windowOpacityChange, this, &MainWindow2::setOpacity);
1009 connect(mPrefDialog, &PreferencesDialog::soundScrubChanged, mEditor->playback(), &PlaybackManager::setSoundScrubActive);
1010 connect(mPrefDialog, &PreferencesDialog::soundScrubMsecChanged, mEditor->playback(), &PlaybackManager::setSoundScrubMsec);
1011 connect(mPrefDialog, &PreferencesDialog::finished, [&]
1012 {
1013 clearKeyboardShortcuts();
1014 setupKeyboardShortcuts();
1015 mPrefDialog = nullptr;
1016 });
1017
1018 mPrefDialog->show();
1019}
1020
1021void MainWindow2::resetAndDockAllSubWidgets()
1022{
1023 QSettings settings(PENCIL2D, PENCIL2D);
1024 settings.remove(SETTING_WINDOW_GEOMETRY);
1025 settings.remove(SETTING_WINDOW_STATE);
1026
1027 for (BaseDockWidget* dock : mDockWidgets)
1028 {
1029 dock->setFloating(false);
1030 dock->raise();
1031 dock->show();
1032 }
1033
1034 addDockWidget(Qt::RightDockWidgetArea, mColorBox);
1035 addDockWidget(Qt::RightDockWidgetArea, mColorInspector);
1036 addDockWidget(Qt::RightDockWidgetArea, mColorPalette);
1037 addDockWidget(Qt::LeftDockWidgetArea, mToolBox);
1038 addDockWidget(Qt::LeftDockWidgetArea, mToolOptions);
1039 addDockWidget(Qt::LeftDockWidgetArea, mOnionSkinWidget);
1040 addDockWidget(Qt::BottomDockWidgetArea, mTimeLine);
1041}
1042
1043void MainWindow2::newObject()
1044{
1045 auto object = new Object();
1046 object->init();
1047
1048 // default layers
1049 object->addNewCameraLayer();
1050 object->addNewBitmapLayer();
1051 // Layers are counted bottom up
1052 // 0 - Camera Layer
1053 // 1 - Bitmap Layer
1054 object->data()->setCurrentLayer(1);
1055
1056 mEditor->setObject(object);
1057
1058 closeDialogs();
1059
1060 setWindowTitle(PENCIL_WINDOW_TITLE);
1061
1062 updateBackupActionState();
1063}
1064
1065bool MainWindow2::newObjectFromPresets(int presetIndex)
1066{
1067 QString presetFilePath = PresetDialog::getPresetPath(presetIndex);
1068
1069 if (presetFilePath.isEmpty())
1070 {
1071 return false;
1072 }
1073
1074 FileManager fm(this);
1075 Object* object = fm.load(presetFilePath);
1076
1077 if (!fm.error().ok() || object == nullptr)
1078 {
1079 return false;
1080 }
1081
1082 mEditor->setObject(object);
1083 object->setFilePath(QString());
1084
1085 setWindowTitle(PENCIL_WINDOW_TITLE);
1086 updateSaveState();
1087 updateBackupActionState();
1088
1089 return true;
1090}
1091
1092bool MainWindow2::loadMostRecent()
1093{
1094 if(!mEditor->preference()->isOn(SETTING::LOAD_MOST_RECENT))
1095 {
1096 return false;
1097 }
1098
1099 QSettings settings(PENCIL2D, PENCIL2D);
1100 QString myPath = settings.value(LAST_PCLX_PATH, QVariant("")).toString();
1101 if (myPath.isEmpty() || !QFile::exists(myPath))
1102 {
1103 return false;
1104 }
1105 return openObject(myPath);
1106}
1107
1108bool MainWindow2::tryLoadPreset()
1109{
1110 if (!mEditor->preference()->isOn(SETTING::ASK_FOR_PRESET))
1111 {
1112 int defaultPreset = mEditor->preference()->getInt(SETTING::DEFAULT_PRESET);
1113 return newObjectFromPresets(defaultPreset);
1114 }
1115
1116 PresetDialog* presetDialog = new PresetDialog(mEditor->preference(), this);
1117 presetDialog->setAttribute(Qt::WA_DeleteOnClose);
1118 connect(presetDialog, &PresetDialog::finished, [=](int result)
1119 {
1120 if (result != QDialog::Accepted)
1121 {
1122 return;
1123 }
1124
1125 int presetIndex = presetDialog->getPresetIndex();
1126 if (presetDialog->shouldAlwaysUse())
1127 {
1128 mEditor->preference()->set(SETTING::ASK_FOR_PRESET, false);
1129 mEditor->preference()->set(SETTING::DEFAULT_PRESET, presetIndex);
1130 }
1131 if (!newObjectFromPresets(presetIndex))
1132 {
1133 newObject();
1134 }
1135 });
1136 presetDialog->open();
1137 return true;
1138}
1139
1140void MainWindow2::closeDialogs()
1141{
1142 for (auto dialog : findChildren<QDialog*>(QString(), Qt::FindDirectChildrenOnly)) {
1143 dialog->close();
1144 }
1145}
1146
1147void MainWindow2::readSettings()
1148{
1149 QSettings settings(PENCIL2D, PENCIL2D);
1150
1151 QVariant winGeometry = settings.value(SETTING_WINDOW_GEOMETRY);
1152 restoreGeometry(winGeometry.toByteArray());
1153
1154 QVariant winState = settings.value(SETTING_WINDOW_STATE);
1155 restoreState(winState.toByteArray());
1156
1157 int opacity = mEditor->preference()->getInt(SETTING::WINDOW_OPACITY);
1158 setOpacity(100 - opacity);
1159
1160 bool isWindowsLocked = mEditor->preference()->isOn(SETTING::LAYOUT_LOCK);
1161 lockWidgets(isWindowsLocked);
1162}
1163
1164void MainWindow2::writeSettings()
1165{
1166 QSettings settings(PENCIL2D, PENCIL2D);
1167 settings.setValue(SETTING_WINDOW_GEOMETRY, saveGeometry());
1168 settings.setValue(SETTING_WINDOW_STATE, saveState());
1169}
1170
1171void MainWindow2::setupKeyboardShortcuts()
1172{
1173 checkExistingShortcuts();
1174
1175 auto cmdKeySeq = [](QString strCommandName) -> QKeySequence
1176 {
1177 strCommandName = QString("shortcuts/") + strCommandName;
1178 QKeySequence keySequence(pencilSettings().value(strCommandName).toString());
1179 return keySequence;
1180 };
1181
1182 // File menu
1183 ui->actionNew->setShortcut(cmdKeySeq(CMD_NEW_FILE));
1184 ui->actionOpen->setShortcut(cmdKeySeq(CMD_OPEN_FILE));
1185 ui->actionSave->setShortcut(cmdKeySeq(CMD_SAVE_FILE));
1186 ui->actionSave_as->setShortcut(cmdKeySeq(CMD_SAVE_AS));
1187
1188 ui->actionImport_Image->setShortcut(cmdKeySeq(CMD_IMPORT_IMAGE));
1189 ui->actionImport_ImageSeq->setShortcut(cmdKeySeq(CMD_IMPORT_IMAGE_SEQ));
1190 ui->actionImport_ImageSeqNum->setShortcut(cmdKeySeq(CMD_IMPORT_IMAGE_PREDEFINED_SET));
1191 ui->actionImport_MovieVideo->setShortcut(cmdKeySeq(CMD_IMPORT_MOVIE_VIDEO));
1192 ui->actionImport_AnimatedImage->setShortcut(cmdKeySeq(CMD_IMPORT_ANIMATED_IMAGE));
1193 ui->actionImportLayers_from_pclx->setShortcut(cmdKeySeq(CMD_IMPORT_LAYERS));
1194 ui->actionImport_Sound->setShortcut(cmdKeySeq(CMD_IMPORT_SOUND));
1195 ui->actionImport_MovieAudio->setShortcut(cmdKeySeq(CMD_IMPORT_MOVIE_AUDIO));
1196 ui->actionImport_Append_Palette->setShortcut(cmdKeySeq(CMD_IMPORT_PALETTE));
1197 ui->actionImport_Replace_Palette->setShortcut(cmdKeySeq(CMD_IMPORT_PALETTE_REPLACE));
1198
1199 ui->actionExport_Image->setShortcut(cmdKeySeq(CMD_EXPORT_IMAGE));
1200 ui->actionExport_ImageSeq->setShortcut(cmdKeySeq(CMD_EXPORT_IMAGE_SEQ));
1201 ui->actionExport_Movie->setShortcut(cmdKeySeq(CMD_EXPORT_MOVIE));
1202 ui->actionExport_Animated_GIF->setShortcut(cmdKeySeq(CMD_EXPORT_GIF));
1203 ui->actionExport_Palette->setShortcut(cmdKeySeq(CMD_EXPORT_PALETTE));
1204
1205 // edit menu
1206 ui->actionUndo->setShortcut(cmdKeySeq(CMD_UNDO));
1207 ui->actionRedo->setShortcut(cmdKeySeq(CMD_REDO));
1208 ui->actionCut->setShortcut(cmdKeySeq(CMD_CUT));
1209 ui->actionCopy->setShortcut(cmdKeySeq(CMD_COPY));
1210 ui->actionPaste_Previous->setShortcut(cmdKeySeq(CMD_PASTE_FROM_PREVIOUS));
1211 ui->actionPaste->setShortcut(cmdKeySeq(CMD_PASTE));
1212 ui->actionClearFrame->setShortcut(cmdKeySeq(CMD_CLEAR_FRAME));
1213 ui->actionFlip_X->setShortcut(cmdKeySeq(CMD_SELECTION_FLIP_HORIZONTAL));
1214 ui->actionFlip_Y->setShortcut(cmdKeySeq(CMD_SELECTION_FLIP_VERTICAL));
1215 ui->actionSelect_All->setShortcut(cmdKeySeq(CMD_SELECT_ALL));
1216 ui->actionDeselect_All->setShortcut(cmdKeySeq(CMD_DESELECT_ALL));
1217 ui->actionPegbarAlignment->setShortcut(cmdKeySeq(CMD_PEGBAR_ALIGNMENT));
1218 ui->actionPreference->setShortcut(cmdKeySeq(CMD_PREFERENCE));
1219
1220 // View menu
1221 ui->actionResetWindows->setShortcut(cmdKeySeq(CMD_RESET_WINDOWS));
1222 ui->actionLockWindows->setShortcut(cmdKeySeq(CMD_LOCK_WINDOWS));
1223 ui->actionReset_View->setShortcut(cmdKeySeq(CMD_RESET_ZOOM_ROTATE));
1224 ui->actionCenter_View->setShortcut(cmdKeySeq(CMD_CENTER_VIEW));
1225 ui->actionZoom_In->setShortcut(cmdKeySeq(CMD_ZOOM_IN));
1226 ui->actionZoom_Out->setShortcut(cmdKeySeq(CMD_ZOOM_OUT));
1227 ui->actionZoom400->setShortcut(cmdKeySeq(CMD_ZOOM_400));
1228 ui->actionZoom300->setShortcut(cmdKeySeq(CMD_ZOOM_300));
1229 ui->actionZoom200->setShortcut(cmdKeySeq(CMD_ZOOM_200));
1230 ui->actionZoom100->setShortcut(cmdKeySeq(CMD_ZOOM_100));
1231 ui->actionZoom50->setShortcut(cmdKeySeq(CMD_ZOOM_50));
1232 ui->actionZoom33->setShortcut(cmdKeySeq(CMD_ZOOM_33));
1233 ui->actionZoom25->setShortcut(cmdKeySeq(CMD_ZOOM_25));
1234 ui->actionRotate_Clockwise->setShortcut(cmdKeySeq(CMD_ROTATE_CLOCK));
1235 ui->actionRotate_Anticlockwise->setShortcut(cmdKeySeq(CMD_ROTATE_ANTI_CLOCK));
1236 ui->actionReset_Rotation->setShortcut(cmdKeySeq(CMD_RESET_ROTATION));
1237 ui->actionHorizontal_Flip->setShortcut(cmdKeySeq(CMD_FLIP_HORIZONTAL));
1238 ui->actionVertical_Flip->setShortcut(cmdKeySeq(CMD_FLIP_VERTICAL));
1239 ui->actionGrid->setShortcut(cmdKeySeq(CMD_GRID));
1240 ui->actionCenter->setShortcut(cmdKeySeq(CMD_OVERLAY_CENTER));
1241 ui->actionThirds->setShortcut(cmdKeySeq(CMD_OVERLAY_THIRDS));
1242 ui->actionGoldenRatio->setShortcut(cmdKeySeq(CMD_OVERLAY_GOLDEN_RATIO));
1243 ui->actionSafeAreas->setShortcut(cmdKeySeq(CMD_OVERLAY_SAFE_AREAS));
1244 ui->actionOnePointPerspective->setShortcut(cmdKeySeq(CMD_OVERLAY_ONE_POINT_PERSPECTIVE));
1245 ui->actionTwoPointPerspective->setShortcut(cmdKeySeq(CMD_OVERLAY_TWO_POINT_PERSPECTIVE));
1246 ui->actionThreePointPerspective->setShortcut(cmdKeySeq(CMD_OVERLAY_THREE_POINT_PERSPECTIVE));
1247 ui->actionOnionPrev->setShortcut(cmdKeySeq(CMD_ONIONSKIN_PREV));
1248 ui->actionOnionNext->setShortcut(cmdKeySeq(CMD_ONIONSKIN_NEXT));
1249 ui->actionStatusBar->setShortcut(cmdKeySeq(CMD_TOGGLE_STATUS_BAR));
1250
1251 // Animation menu
1252 ui->actionPlay->setShortcut(cmdKeySeq(CMD_PLAY));
1253 ui->actionLoop->setShortcut(cmdKeySeq(CMD_LOOP));
1254 ui->actionLoopControl->setShortcut(cmdKeySeq(CMD_LOOP_CONTROL));
1255 ui->actionPrevious_Frame->setShortcut(cmdKeySeq(CMD_GOTO_PREV_FRAME));
1256 ui->actionNext_Frame->setShortcut(cmdKeySeq(CMD_GOTO_NEXT_FRAME));
1257 ui->actionPrev_KeyFrame->setShortcut(cmdKeySeq(CMD_GOTO_PREV_KEY_FRAME));
1258 ui->actionNext_KeyFrame->setShortcut(cmdKeySeq(CMD_GOTO_NEXT_KEY_FRAME));
1259 ui->actionAdd_Frame->setShortcut(cmdKeySeq(CMD_ADD_FRAME));
1260 ui->actionDuplicate_Frame->setShortcut(cmdKeySeq(CMD_DUPLICATE_FRAME));
1261 ui->actionRemove_Frame->setShortcut(cmdKeySeq(CMD_REMOVE_FRAME));
1262 ui->actionAdd_Frame_Exposure->setShortcut(cmdKeySeq(CMD_SELECTION_ADD_FRAME_EXPOSURE));
1263 ui->actionSubtract_Frame_Exposure->setShortcut(cmdKeySeq(CMD_SELECTION_SUBTRACT_FRAME_EXPOSURE));
1264 ui->actionReverse_Frames_Order->setShortcut(cmdKeySeq(CMD_REVERSE_SELECTED_FRAMES));
1265 ui->actionRemove_Frames->setShortcut(cmdKeySeq(CMD_REMOVE_SELECTED_FRAMES));
1266 ui->actionMove_Frame_Backward->setShortcut(cmdKeySeq(CMD_MOVE_FRAME_BACKWARD));
1267 ui->actionMove_Frame_Forward->setShortcut(cmdKeySeq(CMD_MOVE_FRAME_FORWARD));
1268 ui->actionFlip_inbetween->setShortcut(cmdKeySeq(CMD_FLIP_INBETWEEN));
1269 ui->actionFlip_rolling->setShortcut(cmdKeySeq(CMD_FLIP_ROLLING));
1270 ui->actionReposition_Selected_Frames->setShortcut(cmdKeySeq(CMD_SELECTION_REPOSITION_FRAMES));
1271
1272 ShortcutFilter* shortcutFilter = new ShortcutFilter(ui->scribbleArea, this);
1273 ui->actionMove->setShortcut(cmdKeySeq(CMD_TOOL_MOVE));
1274 ui->actionSelect->setShortcut(cmdKeySeq(CMD_TOOL_SELECT));
1275 ui->actionBrush->setShortcut(cmdKeySeq(CMD_TOOL_BRUSH));
1276 ui->actionPolyline->setShortcut(cmdKeySeq(CMD_TOOL_POLYLINE));
1277 ui->actionSmudge->setShortcut(cmdKeySeq(CMD_TOOL_SMUDGE));
1278 ui->actionPen->setShortcut(cmdKeySeq(CMD_TOOL_PEN));
1279 ui->actionHand->setShortcut(cmdKeySeq(CMD_TOOL_HAND));
1280 ui->actionPencil->setShortcut(cmdKeySeq(CMD_TOOL_PENCIL));
1281 ui->actionBucket->setShortcut(cmdKeySeq(CMD_TOOL_BUCKET));
1282 ui->actionEyedropper->setShortcut(cmdKeySeq(CMD_TOOL_EYEDROPPER));
1283 ui->actionEraser->setShortcut(cmdKeySeq(CMD_TOOL_ERASER));
1284 ui->actionResetToolsDefault->setShortcut(cmdKeySeq(CMD_RESET_ALL_TOOLS));
1285
1286 ui->actionMove->installEventFilter(shortcutFilter);
1287 ui->actionMove->installEventFilter(shortcutFilter);
1288 ui->actionSelect->installEventFilter(shortcutFilter);
1289 ui->actionBrush->installEventFilter(shortcutFilter);
1290 ui->actionPolyline->installEventFilter(shortcutFilter);
1291 ui->actionSmudge->installEventFilter(shortcutFilter);
1292 ui->actionPen->installEventFilter(shortcutFilter);
1293 ui->actionHand->installEventFilter(shortcutFilter);
1294 ui->actionPencil->installEventFilter(shortcutFilter);
1295 ui->actionBucket->installEventFilter(shortcutFilter);
1296 ui->actionEyedropper->installEventFilter(shortcutFilter);
1297 ui->actionEraser->installEventFilter(shortcutFilter);
1298
1299 // Layer menu
1300 ui->actionNew_Bitmap_Layer->setShortcut(cmdKeySeq(CMD_NEW_BITMAP_LAYER));
1301 ui->actionNew_Vector_Layer->setShortcut(cmdKeySeq(CMD_NEW_VECTOR_LAYER));
1302 ui->actionNew_Camera_Layer->setShortcut(cmdKeySeq(CMD_NEW_CAMERA_LAYER));
1303 ui->actionNew_Sound_Layer->setShortcut(cmdKeySeq(CMD_NEW_SOUND_LAYER));
1304 ui->actionDelete_Current_Layer->setShortcut(cmdKeySeq(CMD_DELETE_CUR_LAYER));
1305 ui->actionChangeLineColorCurrent_keyframe->setShortcut(cmdKeySeq(CMD_CHANGE_LINE_COLOR_KEYFRAME));
1306 ui->actionChangeLineColorAll_keyframes_on_layer->setShortcut(cmdKeySeq(CMD_CHANGE_LINE_COLOR_LAYER));
1307 ui->actionChangeLayerOpacity->setShortcut(cmdKeySeq(CMD_CHANGE_LAYER_OPACITY));
1308
1309 ui->actionVisibilityCurrentLayerOnly->setShortcut(cmdKeySeq(CMD_CURRENT_LAYER_VISIBILITY));
1310 ui->actionVisibilityRelative->setShortcut(cmdKeySeq(CMD_RELATIVE_LAYER_VISIBILITY));
1311 ui->actionVisibilityAll->setShortcut(cmdKeySeq(CMD_ALL_LAYER_VISIBILITY));
1312
1313 mToolBox->toggleViewAction()->setShortcut(cmdKeySeq(CMD_TOGGLE_TOOLBOX));
1314 mToolOptions->toggleViewAction()->setShortcut(cmdKeySeq(CMD_TOGGLE_TOOL_OPTIONS));
1315 mColorBox->toggleViewAction()->setShortcut(cmdKeySeq(CMD_TOGGLE_COLOR_WHEEL));
1316 mColorPalette->toggleViewAction()->setShortcut(cmdKeySeq(CMD_TOGGLE_COLOR_LIBRARY));
1317 mTimeLine->toggleViewAction()->setShortcut(cmdKeySeq(CMD_TOGGLE_TIMELINE));
1318 mColorInspector->toggleViewAction()->setShortcut(cmdKeySeq(CMD_TOGGLE_COLOR_INSPECTOR));
1319 mOnionSkinWidget->toggleViewAction()->setShortcut(cmdKeySeq(CMD_TOGGLE_ONION_SKIN));
1320
1321 ui->actionHelp->setShortcut(cmdKeySeq(CMD_HELP));
1322 ui->actionExit->setShortcut(cmdKeySeq(CMD_EXIT));
1323}
1324
1325void MainWindow2::clearKeyboardShortcuts()
1326{
1327 QList<QAction*> actionList = findChildren<QAction*>();
1328 for (QAction* action : actionList)
1329 {
1330 action->setShortcut(QKeySequence(0));
1331 }
1332}
1333
1334void MainWindow2::exportPalette()
1335{
1336 QString filePath = FileDialog::getSaveFileName(this, FileType::PALETTE);
1337 if (!filePath.isEmpty())
1338 {
1339 mEditor->object()->exportPalette(filePath);
1340 }
1341}
1342
1343void MainWindow2::importPalette()
1344{
1345 QString filePath = FileDialog::getOpenFileName(this, FileType::PALETTE);
1346 if (!filePath.isEmpty())
1347 {
1348 mEditor->object()->importPalette(filePath);
1349 mColorPalette->refreshColorList();
1350 mColorPalette->adjustSwatches();
1351 mEditor->color()->setColorNumber(0);
1352 }
1353}
1354
1355void MainWindow2::openPalette()
1356{
1357 for (int i = 0; i < mEditor->object()->getColorCount(); i++)
1358 {
1359 if (!mEditor->object()->isColorInUse(i))
1360 {
1361 continue;
1362 }
1363
1364 QMessageBox msgBox;
1365 msgBox.setText(tr("Opening a palette will replace the old palette.\n"
1366 "Color(s) in strokes will be altered by this action!"));
1367 msgBox.addButton(tr("Open Palette"), QMessageBox::AcceptRole);
1368 msgBox.addButton(QMessageBox::Cancel);
1369
1370 if (msgBox.exec() == QMessageBox::Cancel) {
1371 return;
1372 }
1373 break;
1374 }
1375
1376 QString filePath = FileDialog::getOpenFileName(this, FileType::PALETTE);
1377 if (filePath.isEmpty())
1378 {
1379 return;
1380 }
1381
1382 mEditor->object()->openPalette(filePath);
1383 mColorPalette->refreshColorList();
1384 mEditor->color()->setColorNumber(0);
1385}
1386
1387void MainWindow2::makeConnections(Editor* editor)
1388{
1389 connect(editor->undoRedo(), &UndoRedoManager::didUpdateUndoStack, this, &MainWindow2::updateSaveState);
1390 connect(editor->undoRedo(), &UndoRedoManager::didUpdateUndoStack, this, &MainWindow2::updateBackupActionState);
1391 connect(editor, &Editor::needDisplayInfo, this, &MainWindow2::displayMessageBox);
1392 connect(editor, &Editor::needDisplayInfoNoTitle, this, &MainWindow2::displayMessageBoxNoTitle);
1393 connect(editor->layers(), &LayerManager::currentLayerChanged, this, &MainWindow2::currentLayerChanged);
1394 connect(editor->select(), &SelectionManager::selectionChanged, this, &MainWindow2::selectionChanged);
1395 connect(editor, &Editor::canCopyChanged, this, [=](bool canCopy) {
1396 ui->actionCopy->setEnabled(canCopy);
1397 ui->actionCut->setEnabled(canCopy);
1398 });
1399 connect(editor, &Editor::canPasteChanged, ui->actionPaste, &QAction::setEnabled);
1400}
1401
1402void MainWindow2::makeConnections(Editor* editor, ColorBox* colorBox)
1403{
1404 connect(colorBox, &ColorBox::colorChanged, editor->color(), &ColorManager::setFrontColor);
1405 connect(editor->color(), &ColorManager::colorChanged, colorBox, &ColorBox::setColor);
1406}
1407
1408void MainWindow2::makeConnections(Editor* editor, ColorInspector* colorInspector)
1409{
1410 connect(colorInspector, &ColorInspector::colorChanged, editor->color(), &ColorManager::setFrontColor);
1411 connect(editor->color(), &ColorManager::colorChanged, colorInspector, &ColorInspector::setColor);
1412}
1413
1414void MainWindow2::makeConnections(Editor* editor, ScribbleArea* scribbleArea)
1415{
1416 connect(editor->tools(), &ToolManager::toolChanged, scribbleArea, &ScribbleArea::updateToolCursor);
1417 connect(editor->tools(), &ToolManager::toolChanged, mToolBox, &ToolBoxWidget::onToolSetActive);
1418 connect(editor->tools(), &ToolManager::toolPropertyChanged, scribbleArea, &ScribbleArea::updateToolCursor);
1419
1420
1421 connect(editor->layers(), &LayerManager::currentLayerChanged, scribbleArea, &ScribbleArea::onLayerChanged);
1422 connect(editor->layers(), &LayerManager::layerDeleted, scribbleArea, &ScribbleArea::onLayerChanged);
1423 connect(editor, &Editor::scrubbed, scribbleArea, &ScribbleArea::onScrubbed);
1424 connect(editor, &Editor::frameModified, scribbleArea, &ScribbleArea::onFrameModified);
1425 connect(editor, &Editor::framesModified, scribbleArea, &ScribbleArea::onFramesModified);
1426 connect(editor, &Editor::objectLoaded, scribbleArea, &ScribbleArea::onObjectLoaded);
1427 connect(editor->view(), &ViewManager::viewChanged, scribbleArea, &ScribbleArea::onViewChanged);
1428}
1429
1430void MainWindow2::makeConnections(Editor* pEditor, TimeLine* pTimeline)
1431{
1432 PlaybackManager* pPlaybackManager = pEditor->playback();
1433 connect(pTimeline, &TimeLine::duplicateLayerClick, mCommands, &ActionCommands::duplicateLayer);
1434 connect(pTimeline, &TimeLine::duplicateKeyClick, mCommands, &ActionCommands::duplicateKey);
1435
1436 connect(pTimeline, &TimeLine::soundClick, pPlaybackManager, &PlaybackManager::enableSound);
1437 connect(pTimeline, &TimeLine::fpsChanged, pPlaybackManager, &PlaybackManager::setFps);
1438 connect(pTimeline, &TimeLine::fpsChanged, pEditor, &Editor::setFps);
1439
1440 connect(pTimeline, &TimeLine::insertKeyClick, mCommands, &ActionCommands::insertKeyFrameAtCurrentPosition);
1441 connect(pTimeline, &TimeLine::removeKeyClick, mCommands, &ActionCommands::removeKey);
1442
1443 connect(pTimeline, &TimeLine::newBitmapLayer, mCommands, &ActionCommands::addNewBitmapLayer);
1444 connect(pTimeline, &TimeLine::newVectorLayer, mCommands, &ActionCommands::addNewVectorLayer);
1445 connect(pTimeline, &TimeLine::newSoundLayer, mCommands, &ActionCommands::addNewSoundLayer);
1446 connect(pTimeline, &TimeLine::newCameraLayer, mCommands, &ActionCommands::addNewCameraLayer);
1447 connect(mTimeLine, &TimeLine::playButtonTriggered, mCommands, &ActionCommands::PlayStop);
1448 connect(pTimeline, &TimeLine::deleteCurrentLayerClick, mCommands, &ActionCommands::deleteCurrentLayer);
1449
1450 // Clipboard state handling
1451 connect(QApplication::clipboard(), &QClipboard::dataChanged, mEditor, &Editor::clipboardChanged);
1452 connect(pTimeline, &TimeLine::selectionChanged, this, &MainWindow2::updateCopyCutPasteEnabled);
1453 connect(this, &MainWindow2::windowActivated, this, &MainWindow2::updateCopyCutPasteEnabled);
1454 connect(mEditor->select(), &SelectionManager::selectionChanged, this, &MainWindow2::updateCopyCutPasteEnabled);
1455
1456 connect(pEditor->layers(), &LayerManager::currentLayerChanged, pTimeline, &TimeLine::updateUI);
1457 connect(pEditor->layers(), &LayerManager::animationLengthChanged, pTimeline, &TimeLine::extendLength);
1458 connect(pEditor->sound(), &SoundManager::soundClipDurationChanged, pTimeline, &TimeLine::updateUI);
1459
1460 // Menu UI changes
1461 connect(ui->menuEdit, &QMenu::aboutToShow, this, &MainWindow2::updateCopyCutPasteEnabled);
1462
1463 connect(pEditor, &Editor::objectLoaded, pTimeline, &TimeLine::onObjectLoaded);
1464 connect(pEditor, &Editor::updateTimeLine, pTimeline, &TimeLine::updateUI);
1465 connect(pEditor, &Editor::updateTimeLineCached, pTimeline, &TimeLine::updateUICached);
1466
1467 connect(pEditor->layers(), &LayerManager::currentLayerChanged, this, &MainWindow2::updateLayerMenu);
1468 connect(pEditor->layers(), &LayerManager::currentLayerChanged, mToolOptions, &ToolOptionWidget::updateUI);
1469}
1470
1471void MainWindow2::makeConnections(Editor*, OnionSkinWidget*)
1472{
1473}
1474
1475void MainWindow2::makeConnections(Editor* editor, ToolOptionWidget* toolOptions)
1476{
1477 toolOptions->makeConnectionToEditor(editor);
1478}
1479
1480void MainWindow2::makeConnections(Editor* pEditor, ColorPaletteWidget* pColorPalette)
1481{
1482 connect(pEditor, &Editor::objectLoaded, pColorPalette, &ColorPaletteWidget::updateUI);
1483
1484 ColorManager* pColorManager = pEditor->color();
1485 ScribbleArea* pScribbleArea = pEditor->getScribbleArea();
1486
1487 connect(pColorPalette, &ColorPaletteWidget::colorNumberChanged, pColorManager, &ColorManager::setColorNumber);
1488 connect(pColorManager, &ColorManager::colorNumberChanged, pScribbleArea, &ScribbleArea::paletteColorChanged);
1489 connect(pColorManager, &ColorManager::colorNumberChanged, pColorPalette, &ColorPaletteWidget::selectColorNumber);
1490}
1491
1492void MainWindow2::makeConnections(Editor* editor, StatusBar *statusBar)
1493{
1494 connect(editor->tools(), &ToolManager::toolChanged, statusBar, &StatusBar::updateToolStatus);
1495 connect(editor->tools()->getTool(POLYLINE), &BaseTool::isActiveChanged, statusBar, &StatusBar::updateToolStatus);
1496
1497 connect(editor->view(), &ViewManager::viewChanged, statusBar, &StatusBar::updateZoomStatus);
1498 connect(statusBar, &StatusBar::zoomChanged, editor->view(), &ViewManager::scale);
1499}
1500
1501void MainWindow2::updateCopyCutPasteEnabled()
1502{
1503 bool canCopy = mEditor->canCopy();
1504 bool canPaste = mEditor->canPaste();
1505
1506 ui->actionCopy->setEnabled(canCopy);
1507 ui->actionCut->setEnabled(canCopy);
1508 ui->actionPaste->setEnabled(canPaste);
1509}
1510
1511void MainWindow2::updateLayerMenu()
1512{
1513 ui->actionDelete_Current_Layer->setEnabled(mEditor->layers()->canDeleteLayer(mEditor->currentLayerIndex()));
1514}
1515
1516void MainWindow2::changePlayState(bool isPlaying)
1517{
1518 if (isPlaying)
1519 {
1520 ui->actionPlay->setText(tr("Stop"));
1521 ui->actionPlay->setIcon(mStopIcon);
1522 }
1523 else
1524 {
1525 ui->actionPlay->setText(tr("Play"));
1526 ui->actionPlay->setIcon(mStartIcon);
1527 }
1528 update();
1529}
1530
1531void MainWindow2::importMovieVideo()
1532{
1533 // Flag this so we don't prompt the user about auto-save in the middle of the import.
1534 mSuppressAutoSaveDialog = true;
1535
1536 mCommands->importMovieVideo();
1537
1538 mSuppressAutoSaveDialog = false;
1539}
1540
1541bool MainWindow2::event(QEvent* event)
1542{
1543 if(event->type() == QEvent::WindowActivate) {
1544 emit windowActivated();
1545 }
1546 return QMainWindow::event(event);
1547}
1548
1549void MainWindow2::displayMessageBox(const QString& title, const QString& body)
1550{
1551 QMessageBox::information(this, tr(qPrintable(title)), tr(qPrintable(body)), QMessageBox::Ok);
1552}
1553
1554void MainWindow2::displayMessageBoxNoTitle(const QString& body)
1555{
1556 QMessageBox::information(this, nullptr, tr(qPrintable(body)), QMessageBox::Ok);
1557}
1558
1559bool MainWindow2::tryRecoverUnsavedProject()
1560{
1561 FileManager fm;
1562 QStringList recoverables = fm.searchForUnsavedProjects();
1563
1564 if (recoverables.empty())
1565 {
1566 return false;
1567 }
1568
1569 QString caption = tr("Restore Project?");
1570 QString text = tr("Pencil2D didn't close correctly. Would you like to restore the project?");
1571
1572 QString recoverPath = recoverables[0];
1573
1574 QMessageBox* msgBox = new QMessageBox(this);
1575 msgBox->setWindowTitle(tr("Restore project"));
1576 msgBox->setWindowModality(Qt::ApplicationModal);
1577 msgBox->setAttribute(Qt::WA_DeleteOnClose);
1578 msgBox->setIconPixmap(QPixmap(":/icons/logo.png"));
1579 msgBox->setText(QString("<h4>%1</h4>%2").arg(caption, text));
1580 msgBox->setInformativeText(QString("<b>%1</b>").arg(retrieveProjectNameFromTempPath(recoverPath)));
1581 msgBox->setStandardButtons(QMessageBox::Open | QMessageBox::Discard);
1582 msgBox->setProperty("RecoverPath", recoverPath);
1583 hideQuestionMark(*msgBox);
1584
1585 connect(msgBox, &QMessageBox::finished, this, &MainWindow2::startProjectRecovery);
1586 msgBox->open();
1587 return true;
1588}
1589
1590void MainWindow2::startProjectRecovery(int result)
1591{
1592 const QMessageBox* msgBox = dynamic_cast<QMessageBox*>(QObject::sender());
1593 const QString recoverPath = msgBox->property("RecoverPath").toString();
1594
1595 if (result == QMessageBox::Discard)
1596 {
1597 // The user presses discard
1598 QDir(recoverPath).removeRecursively();
1599 tryLoadPreset();
1600 return;
1601 }
1602 Q_ASSERT(result == QMessageBox::Open);
1603
1604 FileManager fm;
1605 Object* o = fm.recoverUnsavedProject(recoverPath);
1606 if (!fm.error().ok())
1607 {
1608 Q_ASSERT(o == nullptr);
1609 const QString title = tr("Recovery Failed.");
1610 const QString text = tr("Sorry! Pencil2D is unable to restore your project");
1611 QMessageBox::information(this, title, QString("<h4>%1</h4>%2").arg(title, text));
1612 return;
1613 }
1614
1615 Q_ASSERT(o);
1616 mEditor->setObject(o);
1617 updateSaveState();
1618 updateBackupActionState();
1619
1620 const QString title = tr("Recovery Succeeded!");
1621 const QString text = tr("Please save your work immediately to prevent loss of data");
1622 QMessageBox::information(this, title, QString("<h4>%1</h4>%2").arg(title, text));
1623}
1624
1625void MainWindow2::createToolbars()
1626{
1627 mMainToolbar = addToolBar(tr("Main Toolbar"));
1628 mMainToolbar->setObjectName("mMainToolbar");
1629 mMainToolbar->addAction(ui->actionNew);
1630 mMainToolbar->addAction(ui->actionOpen);
1631 mMainToolbar->addAction(ui->actionSave);
1632 mMainToolbar->addSeparator();
1633 mMainToolbar->addAction(ui->actionUndo);
1634 mMainToolbar->addAction(ui->actionRedo);
1635 mMainToolbar->addSeparator();
1636 mMainToolbar->addAction(ui->actionCut);
1637 mMainToolbar->addAction(ui->actionCopy);
1638 mMainToolbar->addAction(ui->actionPaste);
1639 mMainToolbar->addAction(ui->actionClearFrame);
1640
1641 mViewToolbar = addToolBar(tr("View Toolbar"));
1642 mViewToolbar->setObjectName("mViewToolbar");
1643 mViewToolbar->addAction(ui->actionZoom_In);
1644 mViewToolbar->addAction(ui->actionZoom_Out);
1645 mViewToolbar->addAction(ui->actionReset_View);
1646 mViewToolbar->addSeparator();
1647 mViewToolbar->addAction(ui->actionHorizontal_Flip);
1648 mViewToolbar->addAction(ui->actionVertical_Flip);
1649 mViewToolbar->addSeparator();
1650 mViewToolbar->addAction(ui->actionShowInvisibleLines);
1651 mViewToolbar->addAction(ui->actionShowOutlinesOnly);
1652
1653 mOverlayToolbar = addToolBar(tr("Overlay Toolbar"));
1654 mOverlayToolbar->setObjectName("mOverlayToolbar");
1655 mOverlayToolbar->addAction(ui->actionGrid);
1656 mOverlayToolbar->addAction(ui->actionCenter);
1657 mOverlayToolbar->addAction(ui->actionThirds);
1658 mOverlayToolbar->addAction(ui->actionGoldenRatio);
1659 mOverlayToolbar->addAction(ui->actionSafeAreas);
1660 mOverlayToolbar->addAction(ui->actionOnePointPerspective);
1661 mOverlayToolbar->addAction(ui->actionTwoPointPerspective);
1662 mOverlayToolbar->addAction(ui->actionThreePointPerspective);
1663 mOverlayToolbar->setIconSize(QSize(22,22));
1664 mViewToolbar->setIconSize(QSize(22,22));
1665 mMainToolbar->setIconSize(QSize(22,22));
1666
1667 QToolButton* perspectiveLinesAngleButton = new QToolButton(this);
1668 perspectiveLinesAngleButton->setDefaultAction(ui->menuPerspectiveLinesAngle->menuAction());
1669 perspectiveLinesAngleButton->setPopupMode(QToolButton::InstantPopup);
1670 mOverlayToolbar->addWidget(perspectiveLinesAngleButton);
1671
1672 mToolbars = { mMainToolbar, mViewToolbar, mOverlayToolbar };
1673
1674 for (QToolBar* tb : mToolbars)
1675 {
1676 ui->menuToolbars->addAction(tb->toggleViewAction());
1677 }
1678}
ActionCommands
Definition: actioncommands.h:30
ActionCommands::insertKeyFrameAtCurrentPosition
Status insertKeyFrameAtCurrentPosition()
Will insert a keyframe at the current position and push connected frames to the right.
Definition: actioncommands.cpp:696
BaseDockWidget
Definition: basedockwidget.h:27
ColorBox
Definition: colorbox.h:24
ColorInspector
Definition: colorinspector.h:27
ColorManager
Definition: colormanager.h:27
ColorPaletteWidget
Definition: colorpalettewidget.h:39
Editor
Definition: editor.h:70
Editor::framesModified
void framesModified()
This should be emitted after modifying multiple frames.
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.
ErrorDialog
Definition: errordialog.h:28
FileDialog::getSaveFileName
static QString getSaveFileName(QWidget *parent, FileType fileType, const QString &caption=QString())
Shows a file dialog which allows the user to select a file save path.
Definition: filedialog.cpp:84
FileDialog::getOpenFileName
static QString getOpenFileName(QWidget *parent, FileType fileType, const QString &caption=QString())
Shows a file dialog which allows the user to select a file to open.
Definition: filedialog.cpp:28
FileManager
Definition: filemanager.h:36
ImportImageSeqDialog
Definition: importimageseqdialog.h:45
ImportLayersDialog
Definition: importlayersdialog.h:29
ImportPositionDialog
Definition: importpositiondialog.h:29
LayerManager::notifyAnimationLengthChanged
void notifyAnimationLengthChanged()
This should be emitted whenever the animation length frames, eg.
Definition: layermanager.cpp:403
LayerOpacityDialog
Definition: layeropacitydialog.h:22
MainWindow2
Definition: mainwindow2.h:58
MainWindow2::windowActivated
void windowActivated()
Emitted when window regains focus.
Object
Definition: object.h:42
OnionSkinWidget
Definition: onionskinwidget.h:32
PegBarAlignmentDialog
Definition: pegbaralignmentdialog.h:29
PlaybackManager
Definition: playbackmanager.h:30
PreferenceManager
Definition: preferencemanager.h:28
PreferencesDialog
Definition: preferencesdialog.h:30
PresetDialog
Definition: presetdialog.h:29
RecentFileMenu
Definition: recentfilemenu.h:30
RepositionFramesDialog
Definition: repositionframesdialog.h:16
ScribbleArea
Definition: scribblearea.h:52
ScribbleArea::onScrubbed
void onScrubbed(int frameNumber)
Frame scrubbed, invalidate relevant cache.
Definition: scribblearea.cpp:329
ScribbleArea::onViewChanged
void onViewChanged()
View updated, invalidate relevant cache.
Definition: scribblearea.cpp:355
ScribbleArea::onObjectLoaded
void onObjectLoaded()
Object updated, invalidate all cache.
Definition: scribblearea.cpp:377
ScribbleArea::onFramesModified
void onFramesModified()
Multiple frames modified, invalidate cache for affected frames.
Definition: scribblearea.cpp:336
ScribbleArea::onPlayStateChanged
void onPlayStateChanged()
Playstate changed, invalidate relevant cache.
Definition: scribblearea.cpp:315
ScribbleArea::onLayerChanged
void onLayerChanged()
Layer changed, invalidate relevant cache.
Definition: scribblearea.cpp:360
ScribbleArea::onFrameModified
void onFrameModified(int frameNumber)
Frame modified, invalidate cache for frame if any.
Definition: scribblearea.cpp:345
ShortcutFilter
Definition: shortcutfilter.h:24
StatusBar
The status bar of Pencil2D's main window.
Definition: statusbar.h:34
StatusBar::updateToolStatus
void updateToolStatus(ToolType tool)
Updates the status bar with information about the current tool.
Definition: statusbar.cpp:93
StatusBar::zoomChanged
void zoomChanged(double scale)
This signal is sent when the user chooses a new zoom level through the status bar.
StatusBar::updateZoomStatus
void updateZoomStatus()
Updates the zoom level displayed in the status bar.
Definition: statusbar.cpp:175
Status
Definition: pencilerror.h:40
TimeLine
Definition: timeline.h:32
TimeLine::extendLength
void extendLength(int frame)
Extends the timeline frame length if necessary.
Definition: timeline.cpp:262
ToolBoxWidget
Definition: toolbox.h:36
ToolOptionWidget
Definition: tooloptionwidget.h:41
UndoRedoManager::hasUnsavedChanges
bool hasUnsavedChanges() const
Checks whether there are unsaved changes.
Definition: undoredomanager.cpp:125
QAction
QAction::NoRole
NoRole
QAction::setChecked
void setChecked(bool)
QAction::setEnabled
void setEnabled(bool)
QAction::setMenuRole
void setMenuRole(QAction::MenuRole menuRole)
QAction::setShortcut
void setShortcut(const QKeySequence &shortcut)
QAction::toggled
void toggled(bool checked)
QAction::triggered
void triggered(bool checked)
QActionGroup
QActionGroup::triggered
void triggered(QAction *action)
QClipboard::dataChanged
void dataChanged()
QCloseEvent
QCoreApplication::processEvents
void processEvents(QEventLoop::ProcessEventsFlags flags)
QDateTime
QDateTime::currentDateTime
QDateTime currentDateTime()
QDateTime::setTimeSpec
void setTimeSpec(Qt::TimeSpec spec)
QDateTime::toString
QString toString(Qt::DateFormat format) const const
QDialog::Accepted
Accepted
QDialog::exec
virtual int exec()
QDialog::finished
void finished(int result)
QDialog::open
virtual void open()
QDialog::result
int result() const const
QDir
QDir::removeRecursively
bool removeRecursively()
QDockWidget
QDockWidget::DockWidgetFeatures
typedef DockWidgetFeatures
QDockWidget::toggleViewAction
QAction * toggleViewAction() const const
QEvent
QEvent::WindowActivate
WindowActivate
QEvent::type
QEvent::Type type() const const
QEventLoop::ExcludeUserInputEvents
ExcludeUserInputEvents
QFile
QFile::exists
bool exists() const const
QFileInfo
QGuiApplication::clipboard
QClipboard * clipboard()
QIcon
QIODevice::WriteOnly
WriteOnly
QKeySequence
QList
QList::count
int count(const T &value) const const
QList::empty
bool empty() const const
QList::size
int size() const const
QMainWindow
QMainWindow::addDockWidget
void addDockWidget(Qt::DockWidgetArea area, QDockWidget *dockwidget)
QMainWindow::addToolBar
void addToolBar(Qt::ToolBarArea area, QToolBar *toolbar)
QMainWindow::setDockNestingEnabled
void setDockNestingEnabled(bool enabled)
QMainWindow::event
virtual bool event(QEvent *event) override
QMainWindow::restoreState
bool restoreState(const QByteArray &state, int version)
QMainWindow::saveState
QByteArray saveState(int version) const const
QMainWindow::statusBar
QStatusBar * statusBar() const const
QMenu
QMenu::aboutToShow
void aboutToShow()
QMenu::insertSeparator
QAction * insertSeparator(QAction *before)
QMessageBox
QMessageBox::RejectRole
RejectRole
QMessageBox::Question
Question
QMessageBox::Ok
Ok
QMessageBox::addButton
void addButton(QAbstractButton *button, QMessageBox::ButtonRole role)
QMessageBox::exec
virtual int exec() override
QMessageBox::setIconPixmap
void setIconPixmap(const QPixmap &pixmap)
QMessageBox::information
QMessageBox::StandardButton information(QWidget *parent, const QString &title, const QString &text, QMessageBox::StandardButtons buttons, QMessageBox::StandardButton defaultButton)
QMessageBox::setInformativeText
void setInformativeText(const QString &text)
QMessageBox::open
void open(QObject *receiver, const char *member)
QMessageBox::setWindowModality
void setWindowModality(Qt::WindowModality windowModality)
QMessageBox::setWindowTitle
void setWindowTitle(const QString &title)
QMessageBox::setStandardButtons
void setStandardButtons(QMessageBox::StandardButtons buttons)
QMessageBox::setText
void setText(const QString &text)
QMessageBox::warning
QMessageBox::StandardButton warning(QWidget *parent, const QString &title, const QString &text, QMessageBox::StandardButtons buttons, QMessageBox::StandardButton defaultButton)
QObject::connect
QMetaObject::Connection connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type)
QObject::setObjectName
void setObjectName(const QString &name)
QObject::property
QVariant property(const char *name) const const
QObject::sender
QObject * sender() const const
QObject::setProperty
bool setProperty(const char *name, const QVariant &value)
QObject::tr
QString tr(const char *sourceText, const char *disambiguation, int n)
QPixmap
QProgressDialog
QSettings
QSize
QStandardPaths::AppLocalDataLocation
AppLocalDataLocation
QStandardPaths::writableLocation
QString writableLocation(QStandardPaths::StandardLocation type)
QString
QString::isEmpty
bool isEmpty() const const
QString::prepend
QString & prepend(QChar ch)
QStringList
Qt
Qt::ISODate
ISODate
Qt::AllDockWidgetAreas
AllDockWidgetAreas
Qt::FindDirectChildrenOnly
FindDirectChildrenOnly
Qt::NoFocus
NoFocus
Qt::UTC
UTC
Qt::WA_DeleteOnClose
WA_DeleteOnClose
Qt::WindowModal
WindowModal
Qt::WindowFlags
typedef WindowFlags
QTabletEvent
QTest::keySequence
void keySequence(QWindow *window, const QKeySequence &keySequence)
QTest::toString
char * toString(const T &value)
QTextStream
QToolBar
QToolBar::addAction
QAction * addAction(const QString &text)
QToolBar::addSeparator
QAction * addSeparator()
QToolBar::addWidget
QAction * addWidget(QWidget *widget)
QToolBar::setIconSize
void setIconSize(const QSize &iconSize)
QToolButton
QToolButton::InstantPopup
InstantPopup
QToolButton::setPopupMode
void setPopupMode(QToolButton::ToolButtonPopupMode mode)
QToolButton::setDefaultAction
void setDefaultAction(QAction *action)
QVariant
QVariant::toByteArray
QByteArray toByteArray() const const
QVariant::toString
QString toString() const const
QVariant::value
T value() const const
QWidget
QWidget::activateWindow
void activateWindow()
QWidget::close
bool close()
QWidget::insertAction
void insertAction(QAction *before, QAction *action)
QWidget::raise
void raise()
QWidget::restoreGeometry
bool restoreGeometry(const QByteArray &geometry)
QWidget::saveGeometry
QByteArray saveGeometry() const const
QWidget::setAttribute
void setAttribute(Qt::WidgetAttribute attribute, bool on)
QWidget::setupUi
void setupUi(QWidget *widget)
QWidget::show
void show()
QWidget::setToolTip
void setToolTip(const QString &)
QWidget::update
void update()
QWidget::setVisible
virtual void setVisible(bool visible)
QWidget::windowFlags
windowFlags
QWidget::setWindowModified
void setWindowModified(bool)
QWidget::setWindowOpacity
void setWindowOpacity(qreal level)
QWidget::setWindowTitle
void setWindowTitle(const QString &)
Generated on Mon Dec 9 2024 07:54:59 for Pencil2D by doxygen 1.9.6 based on revision c43166759a84ba990c644a200a939b672f98b88b