/**
* The mode letter you're implementing.
*/
- char mode;
+ const char mode;
/** Mode prefix, or 0
*/
public:
/** Module that created this mode. NULL for core modes */
Module* const creator;
+ /** Long-form name
+ */
+ const std::string name;
/**
* The constructor for ModeHandler initalizes the mode handler.
* The constructor of any class you derive from ModeHandler should
* probably call this constructor with the parameters set correctly.
+ * @param name A one-word name for the mode
* @param modeletter The mode letter you wish to handle
- * @param parameters_on The number of parameters your mode takes when being set. Note that any nonzero value is treated as 1.
- * @param parameters_off The number of parameters your mode takes when being unset. Note that any nonzero value is treated as 1.
- * @param listmode Set to true if your mode is a listmode, e.g. it will respond to MODE #channel +modechar with a list of items
- * @param ModeType Set this to MODETYPE_USER for a usermode, or MODETYPE_CHANNEL for a channelmode.
- * @param operonly Set this to true if only opers should be allowed to set or unset the mode.
- * @param mprefix For listmodes where parameters are NICKNAMES which are on the channel (for example, +ohv), you may define a prefix.
- * When you define a prefix, it can be returned in NAMES, WHO etc if it has the highest value (as returned by GetPrefixRank())
- * In the core, the only modes to implement prefixes are +ovh (ops, voice, halfop) which define the prefix characters @, % and +
- * and the rank values OP_VALUE, HALFOP_VALUE and VOICE_VALUE respectively. Any prefixes you define should have unique values proportional
- * to these three defaults or proportional to another mode in a module you depend on. See src/cmode_o.cpp as an example.
- * @param prefixrequired The prefix required to change this mode
- */
- ModeHandler(Module* me, char modeletter, ParamSpec params, ModeType type);
- /**
- * The default destructor does nothing
+ * @param params Parameters taken by the mode
+ * @param type Type of the mode (MODETYPE_USER or MODETYPE_CHANNEL)
*/
+ ModeHandler(Module* me, const std::string& name, char modeletter, ParamSpec params, ModeType type);
virtual ~ModeHandler();
/**
* Returns true if the mode is a list mode
class CoreExport SimpleUserModeHandler : public ModeHandler
{
public:
- SimpleUserModeHandler(Module* Creator, char modeletter)
- : ModeHandler(Creator, modeletter, PARAM_NONE, MODETYPE_USER) {}
+ SimpleUserModeHandler(Module* Creator, const std::string& Name, char modeletter)
+ : ModeHandler(Creator, Name, modeletter, PARAM_NONE, MODETYPE_USER) {}
virtual ~SimpleUserModeHandler() {}
virtual ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding);
};
class CoreExport SimpleChannelModeHandler : public ModeHandler
{
public:
- SimpleChannelModeHandler(Module* Creator, char modeletter)
- : ModeHandler(Creator, modeletter, PARAM_NONE, MODETYPE_CHANNEL) {}
+ SimpleChannelModeHandler(Module* Creator, const std::string& Name, char modeletter)
+ : ModeHandler(Creator, Name, modeletter, PARAM_NONE, MODETYPE_CHANNEL) {}
virtual ~SimpleChannelModeHandler() {}
virtual ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding);
};
* @param autotidy Automatically tidy list entries on add
* @param ctag Configuration tag to get limits from
*/
- ListModeBase(Module* Creator, char modechar, const std::string &eolstr, unsigned int lnum, unsigned int eolnum, bool autotidy, const std::string &ctag = "banlist")
- : ModeHandler(Creator, modechar, PARAM_ALWAYS, MODETYPE_CHANNEL),
+ ListModeBase(Module* Creator, const std::string& Name, char modechar, const std::string &eolstr, unsigned int lnum, unsigned int eolnum, bool autotidy, const std::string &ctag = "banlist")
+ : ModeHandler(Creator, Name, modechar, PARAM_ALWAYS, MODETYPE_CHANNEL),
listnumeric(lnum), endoflistnumeric(eolnum), endofliststring(eolstr), tidy(autotidy),
- configtag(ctag), extItem("listbase_mode_" + std::string(1, mode) + "_list", Creator)
+ configtag(ctag), extItem("listbase_mode_" + name + "_list", Creator)
{
list = true;
this->DoRehash();
/* +s (server notice masks) */
#include "modes/umode_s.h"
-ModeHandler::ModeHandler(Module* Creator, char modeletter, ParamSpec Params, ModeType type)
+ModeHandler::ModeHandler(Module* Creator, const std::string& Name, char modeletter, ParamSpec Params, ModeType type)
: m_paramtype(TR_TEXT), parameters_taken(Params), mode(modeletter), prefix(0), oper(false),
- list(false), m_type(type), count(0), levelrequired(HALFOP_VALUE), creator(Creator)
+ list(false), m_type(type), count(0), levelrequired(HALFOP_VALUE), creator(Creator), name(Name)
{
}
#include "hashcomp.h"
#include "modes/cmode_b.h"
-ModeChannelBan::ModeChannelBan() : ModeHandler(NULL, 'b', PARAM_ALWAYS, MODETYPE_CHANNEL)
+ModeChannelBan::ModeChannelBan() : ModeHandler(NULL, "ban", 'b', PARAM_ALWAYS, MODETYPE_CHANNEL)
{
list = true;
}
#include "modules.h"
#include "modes/cmode_h.h"
-ModeChannelHalfOp::ModeChannelHalfOp() : ModeHandler(NULL, 'h', PARAM_ALWAYS, MODETYPE_CHANNEL)
+ModeChannelHalfOp::ModeChannelHalfOp() : ModeHandler(NULL, "halfop", 'h', PARAM_ALWAYS, MODETYPE_CHANNEL)
{
list = true;
prefix = '%';
#include "users.h"
#include "modes/cmode_i.h"
-ModeChannelInviteOnly::ModeChannelInviteOnly() : SimpleChannelModeHandler(NULL, 'i')
+ModeChannelInviteOnly::ModeChannelInviteOnly() : SimpleChannelModeHandler(NULL, "invite", 'i')
{
}
#include "users.h"
#include "modes/cmode_k.h"
-ModeChannelKey::ModeChannelKey() : ModeHandler(NULL, 'k', PARAM_ALWAYS, MODETYPE_CHANNEL)
+ModeChannelKey::ModeChannelKey() : ModeHandler(NULL, "key", 'k', PARAM_ALWAYS, MODETYPE_CHANNEL)
{
}
#include "users.h"
#include "modes/cmode_l.h"
-ModeChannelLimit::ModeChannelLimit() : ModeHandler(NULL, 'l', PARAM_SETONLY, MODETYPE_CHANNEL)
+ModeChannelLimit::ModeChannelLimit() : ModeHandler(NULL, "limit", 'l', PARAM_SETONLY, MODETYPE_CHANNEL)
{
}
#include "users.h"
#include "modes/cmode_m.h"
-ModeChannelModerated::ModeChannelModerated() : SimpleChannelModeHandler(NULL, 'm')
+ModeChannelModerated::ModeChannelModerated() : SimpleChannelModeHandler(NULL, "moderated", 'm')
{
}
#include "users.h"
#include "modes/cmode_n.h"
-ModeChannelNoExternal::ModeChannelNoExternal() : SimpleChannelModeHandler(NULL, 'n')
+ModeChannelNoExternal::ModeChannelNoExternal() : SimpleChannelModeHandler(NULL, "noextmsg", 'n')
{
}
#include "modules.h"
#include "modes/cmode_o.h"
-ModeChannelOp::ModeChannelOp() : ModeHandler(NULL, 'o', PARAM_ALWAYS, MODETYPE_CHANNEL)
+ModeChannelOp::ModeChannelOp() : ModeHandler(NULL, "op", 'o', PARAM_ALWAYS, MODETYPE_CHANNEL)
{
list = true;
prefix = '@';
#include "users.h"
#include "modes/cmode_p.h"
-ModeChannelPrivate::ModeChannelPrivate() : SimpleChannelModeHandler(NULL, 'p')
+ModeChannelPrivate::ModeChannelPrivate() : SimpleChannelModeHandler(NULL, "private", 'p')
{
}
#include "users.h"
#include "modes/cmode_s.h"
-ModeChannelSecret::ModeChannelSecret() : SimpleChannelModeHandler(NULL, 's')
+ModeChannelSecret::ModeChannelSecret() : SimpleChannelModeHandler(NULL, "secret", 's')
{
}
#include "users.h"
#include "modes/cmode_t.h"
-ModeChannelTopicOps::ModeChannelTopicOps() : ModeHandler(NULL, 't', PARAM_NONE, MODETYPE_CHANNEL)
+ModeChannelTopicOps::ModeChannelTopicOps() : ModeHandler(NULL, "topic", 't', PARAM_NONE, MODETYPE_CHANNEL)
{
}
#include "modules.h"
#include "modes/cmode_v.h"
-ModeChannelVoice::ModeChannelVoice() : ModeHandler(NULL, 'v', PARAM_ALWAYS, MODETYPE_CHANNEL)
+ModeChannelVoice::ModeChannelVoice() : ModeHandler(NULL, "voice", 'v', PARAM_ALWAYS, MODETYPE_CHANNEL)
{
list = true;
prefix = '+';
#include "users.h"
#include "modes/umode_i.h"
-ModeUserInvisible::ModeUserInvisible() : SimpleUserModeHandler(NULL, 'i')
+ModeUserInvisible::ModeUserInvisible() : SimpleUserModeHandler(NULL, "invisible", 'i')
{
}
#include "users.h"
#include "modes/umode_o.h"
-ModeUserOperator::ModeUserOperator() : ModeHandler(NULL, 'o', PARAM_NONE, MODETYPE_USER)
+ModeUserOperator::ModeUserOperator() : ModeHandler(NULL, "oper", 'o', PARAM_NONE, MODETYPE_USER)
{
oper = true;
}
#include "users.h"
#include "modes/umode_s.h"
-ModeUserServerNoticeMask::ModeUserServerNoticeMask() : ModeHandler(NULL, 's', PARAM_SETONLY, MODETYPE_USER)
+ModeUserServerNoticeMask::ModeUserServerNoticeMask() : ModeHandler(NULL, "snomask", 's', PARAM_SETONLY, MODETYPE_USER)
{
oper = true;
}
#include "users.h"
#include "modes/umode_w.h"
-ModeUserWallops::ModeUserWallops() : SimpleUserModeHandler(NULL, 'w')
+ModeUserWallops::ModeUserWallops() : SimpleUserModeHandler(NULL, "wallops", 'w')
{
}
class AllowInvite : public SimpleChannelModeHandler
{
public:
- AllowInvite(Module* Creator) : SimpleChannelModeHandler(Creator, 'A') { }
+ AllowInvite(Module* Creator) : SimpleChannelModeHandler(Creator, "allowinvite", 'A') { }
};
class ModuleAllowInvite : public Module
class AuditoriumMode : public ModeHandler
{
public:
- AuditoriumMode(Module* Creator) : ModeHandler(Creator, 'u', PARAM_NONE, MODETYPE_CHANNEL)
+ AuditoriumMode(Module* Creator) : ModeHandler(Creator, "auditorium", 'u', PARAM_NONE, MODETYPE_CHANNEL)
{
levelrequired = OP_VALUE;
}
class BanException : public ListModeBase
{
public:
- BanException(Module* Creator) : ListModeBase(Creator, 'e', "End of Channel Exception List", 348, 349, true) { }
+ BanException(Module* Creator) : ListModeBase(Creator, "banexception", 'e', "End of Channel Exception List", 348, 349, true) { }
};
class BlockCaps : public SimpleChannelModeHandler
{
public:
- BlockCaps(Module* Creator) : SimpleChannelModeHandler(Creator, 'B') { }
+ BlockCaps(Module* Creator) : SimpleChannelModeHandler(Creator, "blockcaps", 'B') { }
};
class ModuleBlockCAPS : public Module
class BlockColor : public SimpleChannelModeHandler
{
public:
- BlockColor(Module* Creator) : SimpleChannelModeHandler(Creator, 'c') { }
+ BlockColor(Module* Creator) : SimpleChannelModeHandler(Creator, "blockcolor", 'c') { }
};
class ModuleBlockColour : public Module
class BotMode : public SimpleUserModeHandler
{
public:
- BotMode(Module* Creator) : SimpleUserModeHandler(Creator, 'B') { }
+ BotMode(Module* Creator) : SimpleUserModeHandler(Creator, "bot", 'B') { }
};
class ModuleBotMode : public Module
class User_g : public SimpleUserModeHandler
{
public:
- User_g(Module* Creator) : SimpleUserModeHandler(Creator, 'g') { }
+ User_g(Module* Creator) : SimpleUserModeHandler(Creator, "callerid", 'g') { }
};
class CommandAccept : public Command
class CensorUser : public SimpleUserModeHandler
{
public:
- CensorUser(Module* Creator) : SimpleUserModeHandler(Creator, 'G') { }
+ CensorUser(Module* Creator) : SimpleUserModeHandler(Creator, "censor", 'G') { }
};
/** Handles channel mode +G
class CensorChannel : public SimpleChannelModeHandler
{
public:
- CensorChannel(Module* Creator) : SimpleChannelModeHandler(Creator, 'G') { }
+ CensorChannel(Module* Creator) : SimpleChannelModeHandler(Creator, "censor", 'G') { }
};
class ModuleCensor : public Module
class ChanFilter : public ListModeBase
{
public:
- ChanFilter(Module* Creator) : ListModeBase(Creator, 'g', "End of channel spamfilter list", 941, 940, false, "chanfilter") { }
+ ChanFilter(Module* Creator) : ListModeBase(Creator, "filter", 'g', "End of channel spamfilter list", 941, 940, false, "chanfilter") { }
virtual bool ValidateParam(User* user, Channel* chan, std::string &word)
{
{
public:
ChanFounder(Module* Creator)
- : ModeHandler(Creator, 'q', PARAM_ALWAYS, MODETYPE_CHANNEL),
+ : ModeHandler(Creator, "founder", 'q', PARAM_ALWAYS, MODETYPE_CHANNEL),
FounderProtectBase('q', "founder", 386, 387)
{
ModeHandler::list = true;
{
public:
ChanProtect(Module* Creator)
- : ModeHandler(Creator, 'a', PARAM_ALWAYS, MODETYPE_CHANNEL),
+ : ModeHandler(Creator, "protected", 'a', PARAM_ALWAYS, MODETYPE_CHANNEL),
FounderProtectBase('a',"protected user", 388, 389)
{
ModeHandler::list = true;
}
CloakUser(Module* source, Module* Hash)
- : ModeHandler(source, 'x', PARAM_NONE, MODETYPE_USER), HashProvider(Hash),
+ : ModeHandler(source, "cloak", 'x', PARAM_NONE, MODETYPE_USER), HashProvider(Hash),
ext("cloaked_host", source)
{
}
class PrivacyMode : public ModeHandler
{
public:
- PrivacyMode(Module* Creator) : ModeHandler(Creator, 'c', PARAM_NONE, MODETYPE_USER) { }
+ PrivacyMode(Module* Creator) : ModeHandler(Creator, "deaf_commonchan", 'c', PARAM_NONE, MODETYPE_USER) { }
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding)
{
class User_d : public ModeHandler
{
public:
- User_d(Module* Creator) : ModeHandler(Creator, 'd', PARAM_NONE, MODETYPE_USER) { }
+ User_d(Module* Creator) : ModeHandler(Creator, "deaf", 'd', PARAM_NONE, MODETYPE_USER) { }
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding)
{
private:
CUList empty;
public:
- DelayJoinMode(Module* Parent) : ModeHandler(Parent, 'D', PARAM_NONE, MODETYPE_CHANNEL)
+ DelayJoinMode(Module* Parent) : ModeHandler(Parent, "delayjoin", 'D', PARAM_NONE, MODETYPE_CHANNEL)
{
levelrequired = OP_VALUE;
}
CUList empty;
public:
LocalIntExt jointime;
- DelayMsgMode(Module* Parent) : ModeHandler(Parent, 'd', PARAM_SETONLY, MODETYPE_CHANNEL)
+ DelayMsgMode(Module* Parent) : ModeHandler(Parent, "delaymsg", 'd', PARAM_SETONLY, MODETYPE_CHANNEL)
, jointime("delaymsg", Parent)
{
levelrequired = OP_VALUE;
class Helpop : public ModeHandler
{
public:
- Helpop(Module* Creator) : ModeHandler(Creator, 'h', PARAM_NONE, MODETYPE_USER)
+ Helpop(Module* Creator) : ModeHandler(Creator, "helpop", 'h', PARAM_NONE, MODETYPE_USER)
{
oper = true;
}
class HideChans : public ModeHandler
{
public:
- HideChans(Module* Creator) : ModeHandler(Creator, 'I', PARAM_NONE, MODETYPE_USER) { }
+ HideChans(Module* Creator) : ModeHandler(Creator, "hidechans", 'I', PARAM_NONE, MODETYPE_USER) { }
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding)
{
class HideOper : public ModeHandler
{
public:
- HideOper(Module* Creator) : ModeHandler(Creator, 'H', PARAM_NONE, MODETYPE_USER)
+ HideOper(Module* Creator) : ModeHandler(Creator, "hideoper", 'H', PARAM_NONE, MODETYPE_USER)
{
oper = true;
}
class InvisibleMode : public ModeHandler
{
public:
- InvisibleMode(Module* Creator) : ModeHandler(Creator, 'Q', PARAM_NONE, MODETYPE_USER)
+ InvisibleMode(Module* Creator) : ModeHandler(Creator, "invis-oper", 'Q', PARAM_NONE, MODETYPE_USER)
{
oper = true;
}
class InviteException : public ListModeBase
{
public:
- InviteException(Module* Creator) : ListModeBase(Creator, 'I', "End of Channel Invite Exception List", 346, 347, true) { }
+ InviteException(Module* Creator) : ListModeBase(Creator, "invex", 'I', "End of Channel Invite Exception List", 346, 347, true) { }
};
class ModuleInviteException : public Module
{
public:
SimpleExtItem<joinfloodsettings> ext;
- JoinFlood(Module* Creator) : ModeHandler(Creator, 'j', PARAM_SETONLY, MODETYPE_CHANNEL),
+ JoinFlood(Module* Creator) : ModeHandler(Creator, "joinflood", 'j', PARAM_SETONLY, MODETYPE_CHANNEL),
ext("joinflood", Creator) { }
ModePair ModeSet(User* source, User* dest, Channel* channel, const std::string ¶meter)
{
public:
SimpleExtItem<delaylist> ext;
- KickRejoin(Module* Creator) : ModeHandler(Creator, 'J', PARAM_SETONLY, MODETYPE_CHANNEL),
+ KickRejoin(Module* Creator) : ModeHandler(Creator, "kicknorejoin", 'J', PARAM_SETONLY, MODETYPE_CHANNEL),
ext("norejoinusers", Creator) { }
ModePair ModeSet(User* source, User* dest, Channel* channel, const std::string ¶meter)
class Knock : public SimpleChannelModeHandler
{
public:
- Knock(Module* Creator) : SimpleChannelModeHandler(Creator, 'K') { }
+ Knock(Module* Creator) : SimpleChannelModeHandler(Creator, "noknock", 'K') { }
};
class ModuleKnock : public Module
{
public:
SimpleExtItem<floodsettings> ext;
- MsgFlood(Module* Creator) : ModeHandler(Creator, 'f', PARAM_SETONLY, MODETYPE_CHANNEL),
+ MsgFlood(Module* Creator) : ModeHandler(Creator, "flood", 'f', PARAM_SETONLY, MODETYPE_CHANNEL),
ext("messageflood", Creator) { }
ModePair ModeSet(User* source, User* dest, Channel* channel, const std::string ¶meter)
{
public:
SimpleExtItem<nickfloodsettings> ext;
- NickFlood(Module* Creator) : ModeHandler(Creator, 'F', PARAM_SETONLY, MODETYPE_CHANNEL),
+ NickFlood(Module* Creator) : ModeHandler(Creator, "nickflood", 'F', PARAM_SETONLY, MODETYPE_CHANNEL),
ext("nickflood", Creator) { }
ModePair ModeSet(User* source, User* dest, Channel* channel, const std::string ¶meter)
class NoCTCP : public ModeHandler
{
public:
- NoCTCP(Module* Creator) : ModeHandler(Creator, 'C', PARAM_NONE, MODETYPE_CHANNEL) { }
+ NoCTCP(Module* Creator) : ModeHandler(Creator, "noctcp", 'C', PARAM_NONE, MODETYPE_CHANNEL) { }
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding)
{
class NoKicks : public SimpleChannelModeHandler
{
public:
- NoKicks(Module* Creator) : SimpleChannelModeHandler(Creator, 'Q') { }
+ NoKicks(Module* Creator) : SimpleChannelModeHandler(Creator, "nokick", 'Q') { }
};
class ModuleNoKicks : public Module
class NoNicks : public ModeHandler
{
public:
- NoNicks(Module* Creator) : ModeHandler(Creator, 'N', PARAM_NONE, MODETYPE_CHANNEL) { }
+ NoNicks(Module* Creator) : ModeHandler(Creator, "nonick", 'N', PARAM_NONE, MODETYPE_CHANNEL) { }
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding)
{
class NoNotice : public SimpleChannelModeHandler
{
public:
- NoNotice(Module* Creator) : SimpleChannelModeHandler(Creator, 'T') { }
+ NoNotice(Module* Creator) : SimpleChannelModeHandler(Creator, "nonotice", 'T') { }
};
class ModuleNoNotice : public Module
class NetworkPrefix : public ModeHandler
{
public:
- NetworkPrefix(Module* parent) : ModeHandler(parent, 'Y', PARAM_ALWAYS, MODETYPE_CHANNEL)
+ NetworkPrefix(Module* parent) : ModeHandler(parent, "official-join", 'Y', PARAM_ALWAYS, MODETYPE_CHANNEL)
{
list = true;
prefix = NPrefix;
{
public:
/* This is an oper-only mode */
- OperChans(Module* Creator) : ModeHandler(Creator, 'O', PARAM_NONE, MODETYPE_CHANNEL) { oper = true; }
+ OperChans(Module* Creator) : ModeHandler(Creator, "operonly", 'O', PARAM_NONE, MODETYPE_CHANNEL) { oper = true; }
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding)
{
class OperPrefixMode : public ModeHandler
{
public:
- OperPrefixMode(Module* Creator, char pfx) : ModeHandler(Creator, 'y', PARAM_ALWAYS, MODETYPE_CHANNEL)
+ OperPrefixMode(Module* Creator, char pfx) : ModeHandler(Creator, "operprefix", 'y', PARAM_ALWAYS, MODETYPE_CHANNEL)
{
list = true;
prefix = pfx;
class PermChannel : public ModeHandler
{
public:
- PermChannel(Module* Creator) : ModeHandler(Creator, 'P', PARAM_NONE, MODETYPE_CHANNEL) { }
+ PermChannel(Module* Creator) : ModeHandler(Creator, "permanent", 'P', PARAM_NONE, MODETYPE_CHANNEL) { }
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding)
{
class Redirect : public ModeHandler
{
public:
- Redirect(Module* Creator) : ModeHandler(Creator, 'L', PARAM_SETONLY, MODETYPE_CHANNEL) { }
+ Redirect(Module* Creator) : ModeHandler(Creator, "redirect", 'L', PARAM_SETONLY, MODETYPE_CHANNEL) { }
ModePair ModeSet(User* source, User* dest, Channel* channel, const std::string ¶meter)
{
{
public:
- Channel_r(Module* Creator) : ModeHandler(Creator, 'r', PARAM_NONE, MODETYPE_CHANNEL) { }
+ Channel_r(Module* Creator) : ModeHandler(Creator, "registered", 'r', PARAM_NONE, MODETYPE_CHANNEL) { }
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding)
{
{
public:
- User_r(Module* Creator) : ModeHandler(Creator, 'r', PARAM_NONE, MODETYPE_USER) { }
+ User_r(Module* Creator) : ModeHandler(Creator, "registered", 'r', PARAM_NONE, MODETYPE_USER) { }
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding)
{
class AChannel_R : public SimpleChannelModeHandler
{
public:
- AChannel_R(Module* Creator) : SimpleChannelModeHandler(Creator, 'R') { }
+ AChannel_R(Module* Creator) : SimpleChannelModeHandler(Creator, "reginvite", 'R') { }
};
/** User mode +R - unidentified users cannot message
class AUser_R : public SimpleUserModeHandler
{
public:
- AUser_R(Module* Creator) : SimpleUserModeHandler(Creator, 'R') { }
+ AUser_R(Module* Creator) : SimpleUserModeHandler(Creator, "regdeaf", 'R') { }
};
/** Channel mode +M - unidentified users cannot message channel
class AChannel_M : public SimpleChannelModeHandler
{
public:
- AChannel_M(Module* Creator) : SimpleChannelModeHandler(Creator, 'M') { }
+ AChannel_M(Module* Creator) : SimpleChannelModeHandler(Creator, "regmoderated", 'M') { }
};
class ModuleServicesAccount : public Module
class ServProtectMode : public ModeHandler
{
public:
- ServProtectMode(Module* Creator) : ModeHandler(Creator, 'k', PARAM_NONE, MODETYPE_USER) { oper = true; }
+ ServProtectMode(Module* Creator) : ModeHandler(Creator, "servprotect", 'k', PARAM_NONE, MODETYPE_USER) { oper = true; }
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding)
{
class SeeWhois : public ModeHandler
{
public:
- SeeWhois(Module* Creator, bool IsOpersOnly) : ModeHandler(Creator, 'W', PARAM_NONE, MODETYPE_USER)
+ SeeWhois(Module* Creator, bool IsOpersOnly) : ModeHandler(Creator, "showwhois", 'W', PARAM_NONE, MODETYPE_USER)
{
oper = IsOpersOnly;
}
class SSLMode : public ModeHandler
{
public:
- SSLMode(Module* Creator) : ModeHandler(Creator, 'z', PARAM_NONE, MODETYPE_CHANNEL) { }
+ SSLMode(Module* Creator) : ModeHandler(Creator, "sslonly", 'z', PARAM_NONE, MODETYPE_CHANNEL) { }
ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string ¶meter, bool adding)
{
class ChannelStripColor : public SimpleChannelModeHandler
{
public:
- ChannelStripColor(Module* Creator) : SimpleChannelModeHandler(Creator, 'S') { }
+ ChannelStripColor(Module* Creator) : SimpleChannelModeHandler(Creator, "stripcolor", 'S') { }
};
/** Handles user mode +S
class UserStripColor : public SimpleUserModeHandler
{
public:
- UserStripColor(Module* Creator) : SimpleUserModeHandler(Creator, 'S') { }
+ UserStripColor(Module* Creator) : SimpleUserModeHandler(Creator, "stripcolor", 'S') { }
};