/*
* UpdateHints.h
* -------------
* Purpose: Hint type and abstraction class for passing around hints between module views.
* Notes : (currently none)
* Authors: OpenMPT Devs
* The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
*/
#pragma once
#include "openmpt/all/BuildSettings.hpp"
#include "openmpt/base/FlagSet.hpp"
#include "../soundlib/Snd_defs.h"
OPENMPT_NAMESPACE_BEGIN
// Mutually exclusive hint categories
enum HintCategory
{
HINTCAT_GLOBAL = 0, // Not a real category, since all other categories can be combined with this
HINTCAT_GENERAL = 0,
HINTCAT_PATTERNS = 1,
HINTCAT_SAMPLES = 2,
HINTCAT_INSTRUMENTS = 3,
HINTCAT_SEQUENCE = 4,
HINTCAT_PLUGINS = 5,
HINTCAT_COMMENTS = 6,
NUM_HINTCATS
};
enum HintType
{
// Hints that can be combined with any other hints (no parameter)
HINT_NONE = 0x00, // No specific hint
HINT_MODTYPE = 0x01, // Module type has changed. Generally this will force most things to update.
HINT_MPTOPTIONS = 0x02, // Some OpenMPT options (e.g. colours) have changed which might require stuff to be redrawn.
HINT_UNDO = 0x04, // Undo state information has changed
HINT_ALLGLOBAL = HINT_MODTYPE | HINT_MPTOPTIONS | HINT_UNDO,
// From here: Mutually exclusive hint categories
// General module setting hints (GeneralHint)
HINT_MODGENERAL = 0x10, // General global module settings have changed
HINT_MODCHANNELS = 0x20, // Module channel settings have changed (e.g. channel volume). Parameter: Channel ID
HINT_TUNINGS = 0x40, // Tuning collection was updated
// Pattern-specific hints (PatternHint)
HINT_PATTERNDATA = 0x10, // Pattern data has changed. Parameter: Pattern ID (0 = all patterns)
HINT_PATTERNROW = 0x20, // A row of the currently edited pattern has changed. Parameter: Row number
HINT_PATNAMES = 0x40, // Pattern names have changed. Parameter: Pattern ID (0 = all patterns)
// Sample-specific hints (SampleHint)
HINT_SAMPLEINFO = 0x10, // Sample properties have changed. Parameter: Sample ID (0 = all samples)
HINT_SAMPLEDATA = 0x20, // Sample waveform has changed. Parameter: Sample ID (0 = all samples)
HINT_SMPNAMES = 0x40, // Sample name has changed. Parameter: Sample ID (0 = all samples)
// Instrument-specific hints (InstrumentHint)
HINT_INSTRUMENT = 0x10, // Instrument properties have changed. Parameter: Instrument ID (0 = all instruments)
HINT_ENVELOPE = 0x20, // An instrument envelope has changed. Parameter: Instrument ID (0 = all instruments)
HINT_INSNAMES = 0x40, // Instrument name has changed. Parameter: Instrument ID (0 = all instruments)
// Sequence-specific hints (SequenceHint)
HINT_MODSEQUENCE = 0x10, // The pattern sequence has changed.
HINT_SEQNAMES = 0x20, // Sequence names have changed. Parameter: Sequence ID (0 = all sequences)
HINT_RESTARTPOS = 0x40, // Restart position has changed. Parameter: Sequence ID (0 = all sequences)
// Plugin-specific hints (PluginHint)
HINT_MIXPLUGINS = 0x10, // Plugin properties have changed. Parameter: Plugin ID (0 = all plugins, 1 = first plugin)
HINT_PLUGINNAMES = 0x20, // Plugin names have changed. Parameter: Plugin ID (0 = all plugins, 1 = first plugin)
HINT_PLUGINPARAM = 0x40, // Plugin parameter has changed. Parameter: Plugin ID (0 = all plugins, 1 = first plugin)
// Comment text hints (CommentHint)
HINT_MODCOMMENTS = 0x10, // Module comment text has changed
};
DECLARE_FLAGSET(HintType)
struct UpdateHint
{
protected:
using store_t = uint32;
union
{
struct
{
store_t type : 7; // All HintType flags must fit into this.
store_t category : 3; // All HintCategory types must fit into this.
store_t item : 22;
};
store_t rawData;
};
UpdateHint(HintCategory category_, store_t item_ = 0) : type(HINT_NONE), category(category_), item(item_)
{
static_assert(sizeof(UpdateHint) == sizeof(store_t), "Internal UpdateHint size inconsistency");
static_assert(sizeof(UpdateHint) <= sizeof(LPARAM), "Update hints are currently tunnelled through LPARAMs in MFC");
MPT_ASSERT(static_cast<HintCategory>(category) == category_);
MPT_ASSERT(UpdateHint::item == item);
}
template<typename T>
MPT_FORCEINLINE T GetData() const { return static_cast<T>(item); }
public:
UpdateHint() : type(HINT_NONE), category(HINTCAT_GLOBAL), item(0) { }
template<typename T>
MPT_FORCEINLINE UpdateHint &SetData(T i) { item = i; MPT_ASSERT(item == i); return *this; }
MPT_FORCEINLINE HintCategory GetCategory() const { return static_cast<HintCategory>(category); }
MPT_FORCEINLINE FlagSet<HintType> GetType() const { return FlagSet<HintType>(static_cast<FlagSet<HintType>::store_type>(type)); }
// CModDoc hint tunnelling
static MPT_FORCEINLINE UpdateHint FromLPARAM(LPARAM rawData) { UpdateHint hint; hint.rawData = static_cast<store_t>(rawData); return hint; }
MPT_FORCEINLINE LPARAM AsLPARAM() const { return rawData; }
// Discard any hints that don't belong to class T.
template<typename T>
MPT_FORCEINLINE T ToType() const
{
T hint = static_cast<const T &>(*this);
if(T::classCategory != static_cast<HintCategory>(category))
{
hint.type &= HINT_ALLGLOBAL;
hint.item = 0;
}
return hint;
}
// Set global hint flags
MPT_FORCEINLINE UpdateHint &ModType() { type |= HINT_MODTYPE; return *this; }
MPT_FORCEINLINE UpdateHint &MPTOptions() { type |= HINT_MPTOPTIONS; return *this; }
MPT_FORCEINLINE UpdateHint &Undo() { type |= HINT_UNDO; return *this; }
};
struct GeneralHint : public UpdateHint
{
static constexpr HintCategory classCategory = HINTCAT_GENERAL;
GeneralHint() : UpdateHint(classCategory, 0) { }
GeneralHint(CHANNELINDEX channel) : UpdateHint(classCategory, 1 + channel) { }
MPT_FORCEINLINE GeneralHint &General() { type |= HINT_MODGENERAL; return *this; }
MPT_FORCEINLINE GeneralHint &Channels() { type |= HINT_MODCHANNELS; return *this; }
MPT_FORCEINLINE GeneralHint &Tunings() { type |= HINT_TUNINGS; return *this; }
MPT_FORCEINLINE CHANNELINDEX GetChannel() const { return item ? static_cast<CHANNELINDEX>(item - 1) : CHANNELINDEX_INVALID; }
};
struct PatternHint : public UpdateHint
{
static constexpr HintCategory classCategory = HINTCAT_PATTERNS;
PatternHint(PATTERNINDEX item = 0) : UpdateHint(classCategory, item) { }
MPT_FORCEINLINE PatternHint &Data() { type |= HINT_PATTERNDATA; return *this; }
MPT_FORCEINLINE PatternHint &Names() { type |= HINT_PATNAMES; return *this; }
PATTERNINDEX GetPattern() const { return GetData<PATTERNINDEX>(); }
};
struct RowHint : public UpdateHint
{
static constexpr HintCategory classCategory = HINTCAT_PATTERNS;
RowHint(ROWINDEX item = 0) : UpdateHint(classCategory, item) { type = HINT_PATTERNROW; }
MPT_FORCEINLINE ROWINDEX GetRow() const { return GetData<ROWINDEX>(); }
};
struct SampleHint : public UpdateHint
{
static constexpr HintCategory classCategory = HINTCAT_SAMPLES;
SampleHint(SAMPLEINDEX item = 0) : UpdateHint(classCategory, item) { }
MPT_FORCEINLINE SampleHint &Info() { type |= HINT_SAMPLEINFO; return *this; }
MPT_FORCEINLINE SampleHint &Data() { type |= HINT_SAMPLEDATA; return *this; }
MPT_FORCEINLINE SampleHint &Names() { type |= HINT_SMPNAMES; return *this; }
MPT_FORCEINLINE SAMPLEINDEX GetSample() const { return GetData<SAMPLEINDEX>(); }
};
struct InstrumentHint : public UpdateHint
{
static constexpr HintCategory classCategory = HINTCAT_INSTRUMENTS;
InstrumentHint(INSTRUMENTINDEX item = 0) : UpdateHint(classCategory, item) { }
MPT_FORCEINLINE InstrumentHint &Info() { type |= HINT_INSTRUMENT; return *this; }
MPT_FORCEINLINE InstrumentHint &Envelope() { type |= HINT_ENVELOPE; return *this; }
MPT_FORCEINLINE InstrumentHint &Names() { type |= HINT_INSNAMES; return *this; }
MPT_FORCEINLINE INSTRUMENTINDEX GetInstrument() const { return GetData<INSTRUMENTINDEX>(); }
};
struct SequenceHint : public UpdateHint
{
static constexpr HintCategory classCategory = HINTCAT_SEQUENCE;
SequenceHint(SEQUENCEINDEX item = 0) : UpdateHint(classCategory, item) { }
MPT_FORCEINLINE SequenceHint &Data() { type |= HINT_MODSEQUENCE; return *this; }
MPT_FORCEINLINE SequenceHint &Names() { type |= HINT_SEQNAMES; return *this; }
MPT_FORCEINLINE SequenceHint &RestartPos() { type |= HINT_RESTARTPOS; return *this; }
MPT_FORCEINLINE SEQUENCEINDEX GetSequence() const { return GetData<SEQUENCEINDEX>(); }
};
struct PluginHint : public UpdateHint
{
static constexpr HintCategory classCategory = HINTCAT_PLUGINS;
PluginHint(PLUGINDEX item = 0) : UpdateHint(classCategory, item) { }
MPT_FORCEINLINE PluginHint &Info() { type |= HINT_MIXPLUGINS; return *this; }
MPT_FORCEINLINE PluginHint &Names() { type |= HINT_PLUGINNAMES; return *this; }
MPT_FORCEINLINE PluginHint &Parameter() { type |= HINT_PLUGINPARAM; return *this; }
MPT_FORCEINLINE PLUGINDEX GetPlugin() const { return GetData<PLUGINDEX>(); }
};
struct CommentHint : public UpdateHint
{
static constexpr HintCategory classCategory = HINTCAT_COMMENTS;
CommentHint() : UpdateHint(classCategory) { type = HINT_MODCOMMENTS; }
};
OPENMPT_NAMESPACE_END