mirror of
https://github.com/LMMS/lmms.git
synced 2026-01-21 21:07:56 -05:00
303215f8b1
* Maximize button for resizable instruments
Show the maximize button for resizable instruments.
Most other changes have the character of refactorings and code
reorganizations.
Remove the negation in the if condition for resizable instruments to
make the code better readable.
Only manipulate the system menu if the instrument is not resizable.
Add a TODO to the special code that sets a size.
* Fix rendering of maximized sub windows
In `SubWindow::paintEvent` don't paint anything if the sub window is
maximized . Otherwise some gradients are visible behind the maximized
child content.
In `SubWindow::adjustTitleBar` hide the title label and the buttons if the
sub window is maximized. Always show the title and close button if not
maximized. This is needed to reset the state correctly after
maximization.
* Add SubWindow::addTitleButton
Add the helper method `SubWindow::addTitleButton` to reduce code
repetition in the constructor.
* Only disable the minimize button
Disable the minimize button by taking the current flags and removing
the minimize button hint from them instead of giving a list which might
become incomplete in the future. So only do what we want to do.
* Remove dependency on MdiArea
Remove a dependency on the `MdiArea` when checking if the sub window is
the active one. Query its own window state to find out if it is active.
* Clear Qt::MSWindowsFixedSizeDialogHint
Clear the `Qt::MSWindowsFixedSizeDialogHint` flag for resizable
instruments (symmetric to the `else` case).
* Update the sub window title bar of exchanged instruments
Update the title bar of an instrument's sub window if the model changes, e.g. if an instrument is exchanged via drag & drop.
The main fix is to call the new method `updateSubWindowState` in `InstrumentTrackWindow::modelChanged`. It contains mostly the code that was previously executed in the constructor of `InstrumentTrackWindow`. The constructor now simply calls this method after it has put the constructed instance into a sub window.
With the current implementation the sub window needs to be explicitly triggered to update its title bar once the flags have been adjusted in `updateSubWindowState`. This is done with the new public method `SubWindow::updateTitleBar`. Please note that such an explicit update is not needed if the instrument windows are managed by a `QMdiSubWindow` instead of a `SubWindow`. This means that the implementation of `SubWindow` is still missing something that `QMdiSubWindow` does. However, debugging also showed that setting the window flags of the sub window does not seem to lead to an event that could be caught in `SubWindow::changeEvent`. This was found out by simply dumping the event types of all events that arrive in that method and exchanging an instrument.
The method `updateSubWindowState` uses the added method `findSubWindowInParents` to find the sub window it is contained in. The latter method should be considered to be moved into a templated helper class because it might be useful in other contexts as well.
## Technical details
If you want to experiment with using QMdiSubWindows then simply add the following method to `MainWindow` (right next to `addWindowedWidget`):
```
QMdiSubWindow* MainWindow::addQMdiSubWindow(QWidget *w, Qt::WindowFlags windowFlags)
{
// wrap the widget in our own *custom* window that patches some errors in QMdiSubWindow
auto win = new QMdiSubWindow(m_workspace->viewport(), windowFlags);
win->setAttribute(Qt::WA_DeleteOnClose);
win->setWidget(w);
m_workspace->addSubWindow(win);
return win;
}
```
Then call that method instead of `addWindowedWidget` in the constructor of `InstrumentTrackWindow`:
```
QMdiSubWindow* subWin = getGUI()->mainWindow()->addQMdiSubWindow( this );
```
You can then comment out the cast and the call of `updateTitleBar` in `updateSubWindowState` and everything will still work.
* Update the system menu
Show or hide the "Size" and "Maximize" entries in the system menu
depending on whether the instrument view is resizable or not.
* Show non-resizable instruments as normal
Show the sub windows of non-resizable instruments as normal if the sub
window is maximized because it was previously used with a resizable
instrument.
* Fix typo
* Rename updateSubWindowState
Rename `updateSubWindowState` to `updateSubWindow`.
182 lines
4.3 KiB
C++
182 lines
4.3 KiB
C++
/*
|
|
* InstrumentTrackWindow.h - declaration of InstrumentTrackWindow class
|
|
*
|
|
* Copyright (c) 2004-2014 Tobias Doerffel <tobydox/at/users.sourceforge.net>
|
|
*
|
|
* This file is part of LMMS - https://lmms.io
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public
|
|
* License along with this program (see COPYING); if not, write to the
|
|
* Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
* Boston, MA 02110-1301 USA.
|
|
*
|
|
*/
|
|
|
|
#ifndef LMMS_GUI_INSTRUMENT_TRACK_WINDOW_H
|
|
#define LMMS_GUI_INSTRUMENT_TRACK_WINDOW_H
|
|
|
|
#include <QWidget>
|
|
|
|
#include "ModelView.h"
|
|
#include "SerializingObject.h"
|
|
#include "PluginView.h"
|
|
|
|
class QLabel;
|
|
class QLineEdit;
|
|
class QWidget;
|
|
class QMdiSubWindow;
|
|
|
|
namespace lmms
|
|
{
|
|
|
|
class InstrumentTrack;
|
|
|
|
namespace gui
|
|
{
|
|
|
|
class EffectRackView;
|
|
class MixerChannelLcdSpinBox;
|
|
class InstrumentFunctionArpeggioView;
|
|
class InstrumentFunctionNoteStackingView;
|
|
class InstrumentMidiIOView;
|
|
class InstrumentTuningView;
|
|
class InstrumentSoundShapingView;
|
|
class InstrumentTrackShapingView;
|
|
class InstrumentTrackView;
|
|
class Knob;
|
|
class LcdSpinBox;
|
|
class LeftRightNav;
|
|
class PianoView;
|
|
class PluginView;
|
|
class TabWidget;
|
|
|
|
|
|
class InstrumentTrackWindow : public QWidget, public ModelView,
|
|
public SerializingObjectHook
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
InstrumentTrackWindow( InstrumentTrackView * _tv );
|
|
~InstrumentTrackWindow() override;
|
|
|
|
void resizeEvent(QResizeEvent* event) override;
|
|
|
|
|
|
// parent for all internal tab-widgets
|
|
TabWidget * tabWidgetParent()
|
|
{
|
|
return m_tabWidget;
|
|
}
|
|
|
|
InstrumentTrack * model()
|
|
{
|
|
return castModel<InstrumentTrack>();
|
|
}
|
|
|
|
const InstrumentTrack * model() const
|
|
{
|
|
return castModel<InstrumentTrack>();
|
|
}
|
|
|
|
void setInstrumentTrackView( InstrumentTrackView * _tv );
|
|
|
|
InstrumentTrackView *instrumentTrackView()
|
|
{
|
|
return m_itv;
|
|
}
|
|
|
|
|
|
PianoView * pianoView()
|
|
{
|
|
return m_pianoView;
|
|
}
|
|
|
|
static void dragEnterEventGeneric( QDragEnterEvent * _dee );
|
|
|
|
void dragEnterEvent( QDragEnterEvent * _dee ) override;
|
|
void dropEvent( QDropEvent * _de ) override;
|
|
|
|
|
|
public slots:
|
|
void textChanged( const QString & _new_name );
|
|
void toggleVisibility( bool _on );
|
|
void updateName();
|
|
void updateInstrumentView();
|
|
|
|
|
|
protected:
|
|
// capture close-events for toggling instrument-track-button
|
|
void closeEvent( QCloseEvent * _ce ) override;
|
|
void focusInEvent( QFocusEvent * _fe ) override;
|
|
|
|
void saveSettings( QDomDocument & _doc, QDomElement & _this ) override;
|
|
void loadSettings( const QDomElement & _this ) override;
|
|
|
|
|
|
protected slots:
|
|
void saveSettingsBtnClicked();
|
|
void viewNextInstrument();
|
|
void viewPrevInstrument();
|
|
|
|
private:
|
|
void modelChanged() override;
|
|
void viewInstrumentInDirection(int d);
|
|
//! adjust size of any child widget of the main tab
|
|
//! required to keep the old look when using a variable sized tab widget
|
|
void adjustTabSize(QWidget *w);
|
|
|
|
QMdiSubWindow* findSubWindowInParents();
|
|
void updateSubWindow();
|
|
|
|
InstrumentTrack * m_track;
|
|
InstrumentTrackView * m_itv;
|
|
|
|
// widgets on the top of an instrument-track-window
|
|
QLineEdit * m_nameLineEdit;
|
|
LeftRightNav * m_leftRightNav;
|
|
Knob * m_volumeKnob;
|
|
Knob * m_panningKnob;
|
|
Knob * m_pitchKnob;
|
|
QLabel * m_pitchLabel;
|
|
LcdSpinBox* m_pitchRangeSpinBox;
|
|
QLabel * m_pitchRangeLabel;
|
|
MixerChannelLcdSpinBox * m_mixerChannelNumber;
|
|
|
|
|
|
|
|
// tab-widget with all children
|
|
TabWidget * m_tabWidget;
|
|
PluginView * m_instrumentView;
|
|
InstrumentSoundShapingView * m_ssView;
|
|
InstrumentFunctionNoteStackingView* m_noteStackingView;
|
|
InstrumentFunctionArpeggioView* m_arpeggioView;
|
|
QWidget* m_instrumentFunctionsView; // container of note stacking and arpeggio
|
|
InstrumentMidiIOView * m_midiView;
|
|
EffectRackView * m_effectView;
|
|
InstrumentTuningView *m_tuningView;
|
|
|
|
|
|
// test-piano at the bottom of every instrument-settings-window
|
|
PianoView * m_pianoView;
|
|
|
|
friend class InstrumentView;
|
|
friend class InstrumentTrackView;
|
|
} ;
|
|
|
|
|
|
} // namespace gui
|
|
|
|
} // namespace lmms
|
|
|
|
#endif // LMMS_GUI_INSTRUMENT_TRACK_WINDOW_H
|