void Module::Start()
{
if (d->moduleContext)
{
US_WARN << "Module " << d->info.name << " already started.";
return;
}
d->moduleContext = new ModuleContext(this->d);
// try
// {
d->coreCtx->listeners.ModuleChanged(ModuleEvent(ModuleEvent::LOADING, this));
// try to get a ModuleActivator instance
if (d->info.activatorHook)
{
try
{
d->moduleActivator = d->info.activatorHook();
}
catch (...)
{
US_ERROR << "Creating the module activator of " << d->info.name << " failed";
throw;
}
d->moduleActivator->Load(d->moduleContext);
}
d->StartStaticModules();
#ifdef US_ENABLE_AUTOLOADING_SUPPORT
if (ModuleSettings::IsAutoLoadingEnabled())
{
AutoLoadModules(d->info);
}
#endif
d->coreCtx->listeners.ModuleChanged(ModuleEvent(ModuleEvent::LOADED, this));
// }
// catch (...)
// {
// d->coreCtx->listeners.ModuleChanged(ModuleEvent(ModuleEvent::UNLOADING, this));
// d->RemoveModuleResources();
// delete d->moduleContext;
// d->moduleContext = 0;
// d->coreCtx->listeners.ModuleChanged(ModuleEvent(ModuleEvent::UNLOADED, this));
// US_ERROR << "Calling the module activator Load() method of " << d->info.name << " failed!";
// throw;
// }
}
void Module::Start()
{
if (d->moduleContext)
{
US_WARN << "Module " << d->info.name << " already started.";
return;
}
d->moduleContext = new ModuleContext(this->d);
typedef ModuleActivator*(*ModuleActivatorHook)(void);
ModuleActivatorHook activatorHook = nullptr;
std::string activator_func = "_us_module_activator_instance_" + d->info.name;
void* activatorHookSym = ModuleUtils::GetSymbol(d->info, activator_func.c_str());
std::memcpy(&activatorHook, &activatorHookSym, sizeof(void*));
d->coreCtx->listeners.ModuleChanged(ModuleEvent(ModuleEvent::LOADING, this));
// try to get a ModuleActivator instance
if (activatorHook)
{
try
{
d->moduleActivator = activatorHook();
}
catch (...)
{
US_ERROR << "Creating the module activator of " << d->info.name << " failed";
throw;
}
// This method should be "noexcept" and by not catching exceptions
// here we semantically treat it that way since any exception during
// static initialization will either terminate the program or cause
// the dynamic loader to report an error.
d->moduleActivator->Load(d->moduleContext);
}
#ifdef US_ENABLE_AUTOLOADING_SUPPORT
if (ModuleSettings::IsAutoLoadingEnabled())
{
const std::vector<std::string> loadedPaths = AutoLoadModules(d->info);
if (!loadedPaths.empty())
{
d->moduleManifest.SetValue(PROP_AUTOLOADED_MODULES(), Any(loadedPaths));
}
}
#endif
d->coreCtx->listeners.ModuleChanged(ModuleEvent(ModuleEvent::LOADED, this));
}
/*
* ToolbarButtonPressed: Toolbar button with given Button structure was pressed.
*/
void ToolbarButtonPressed(Button *b)
{
int action;
void *data;
/* See if module wants to handle this event */
if (ModuleEvent(EVENT_TOOLBUTTON, b) == False)
return;
action = b->action;
data = b->action_data;
// If button is a toggle, set state to toggled if pressing in; perform up action if pushing out
if (b->action2 != A_NOACTION)
{
// b->pressed = !b->pressed;
if (b->pressed)
Button_SetState(b->hwnd, TRUE);
else
{
action = b->action2;
data = b->action_data2;
}
}
PerformAction(action, data);
}
void Module::Stop()
{
if (d->moduleContext == 0)
{
US_WARN << "Module " << d->info.name << " already stopped.";
return;
}
try
{
d->coreCtx->listeners.ModuleChanged(ModuleEvent(ModuleEvent::UNLOADING, this));
if (d->moduleActivator)
{
d->moduleActivator->Unload(d->moduleContext);
}
}
catch (...)
{
US_WARN << "Calling the module activator Unload() method of " << d->info.name << " failed!";
try
{
this->Uninit();
}
catch (...) {}
throw;
}
this->Uninit();
}
void UseListSet(list_type new_using)
{
list_delete(use_list);
use_list = new_using;
ModuleEvent(EVENT_INVENTORY, INVENTORY_USELIST, use_list);
}
void UnuseObject(ID obj_id)
{
if (list_find_item(use_list, (void *) obj_id, CompareId) == NULL)
return; /* Not an error, since we always try to unuse what we drop */
use_list = list_delete_item(use_list, (void *) obj_id, CompareId);
ModuleEvent(EVENT_INVENTORY, INVENTORY_UNUSE, obj_id);
}
void ColorsRestoreDefaults(void)
{
ColorsDestroy();
ColorsCreate(True);
MainChangeColor();
ModuleEvent(EVENT_COLORCHANGED, -1, 0);
}
void FontsRestoreDefaults(void)
{
FontsDestroy();
FontsCreate(True);
MainChangeFont();
ModuleEvent(EVENT_FONTCHANGED, -1, NULL);
}
void AnimationTimerProc(HWND hwnd, UINT timer)
{
Bool need_redraw = False;
static DWORD last_animate_time = 0;
DWORD dt, now;
PingTimerProc(hwnd, 0, 0, 0);
if (!(GameGetState() == GAME_PLAY || GameGetState() == GAME_SELECT))
return;
if (last_animate_time == 0)
{
last_animate_time = timeGetTime();
return;
}
config.quickstart = FALSE;
now = timeGetTime();
dt = now - last_animate_time;
last_animate_time = now;
timeLastFrame = dt;
/* Send event to modules */
ModuleEvent(EVENT_ANIMATE, dt);
/* Send event to non-module child windows */
if (config.animate)
{
Lagbox_Animate(dt);
}
/* Animate the first-person view elements */
if (config.animate && GetGameDataValid())
{
// Avoid short-circuiting OR
need_redraw |= ObjectsMove(dt);
need_redraw |= ProjectilesMove(dt);
need_redraw |= AnimateObjects(dt);
need_redraw |= AnimateRoom(¤t_room, dt);
need_redraw |= AnimateProjectiles(dt);
need_redraw |= AnimatePlayerOverlays(dt);
need_redraw |= AnimateBackgroundOverlays(dt);
AnimateDescription(dt);
need_redraw |= AnimateEffects(dt);
if (need_redraw)
RedrawAll();
}
if (GetGameDataValid())
RedrawForce();
return;
}
void Module::Stop()
{
if (d->moduleContext == 0)
{
US_WARN << "Module " << d->info.name << " already stopped.";
return;
}
try
{
d->coreCtx->listeners.ModuleChanged(ModuleEvent(ModuleEvent::UNLOADING, this));
d->StopStaticModules();
if (d->moduleActivator)
{
d->moduleActivator->Unload(d->moduleContext);
}
}
catch (...)
{
US_WARN << "Calling the module activator Unload() method of " << d->info.name << " failed!";
try
{
d->RemoveModuleResources();
}
catch (...) {}
delete d->moduleContext;
d->moduleContext = 0;
d->coreCtx->listeners.ModuleChanged(ModuleEvent(ModuleEvent::UNLOADED, this));
throw;
}
d->RemoveModuleResources();
delete d->moduleContext;
d->moduleContext = 0;
d->coreCtx->listeners.ModuleChanged(ModuleEvent(ModuleEvent::UNLOADED, this));
}
/* Return True iff message should NOT be passed to Windows for default processing */
Bool MainKey(HWND hwnd, UINT vk, BOOL fDown, int cRepeat, UINT flags)
{
/* See if a module wants to handle key */
if (ModuleEvent(EVENT_KEY, hwnd, vk, fDown, cRepeat, flags) == False)
return True;
switch (state)
{
case STATE_GAME:
return GameKey(hwnd, vk, fDown, cRepeat, flags);
}
return False;
}
void Module::Uninit()
{
if (d->moduleContext != nullptr)
{
//d->coreCtx->listeners.HooksModuleStopped(d->moduleContext);
d->RemoveModuleResources();
delete d->moduleContext;
d->moduleContext = 0;
d->coreCtx->listeners.ModuleChanged(ModuleEvent(ModuleEvent::UNLOADED, this));
d->moduleActivator = 0;
}
}
void MainMouseRButtonDown(HWND hwnd, BOOL fDoubleClick, int x, int y, UINT keyFlags)
{
// Send it to HandleKeys first in case user set a keybind to one
// of the mouse buttons.
HandleKeys(0);
/* See if a module wants to handle mouse click */
if (ModuleEvent(EVENT_MOUSECLICK, hwnd, fDoubleClick, x, y, keyFlags) == False)
return;
switch (state)
{
case STATE_GAME:
GameMouseButtonDown(hwnd, fDoubleClick, x, y, keyFlags);
break;
}
}
/*
* UserSelectColor: Allow user to select a single color.
*/
void UserSelectColor(WORD color)
{
CHOOSECOLOR cc;
memset(&cc, 0, sizeof(CHOOSECOLOR));
cc.lStructSize = sizeof(CHOOSECOLOR);
cc.hwndOwner = hMain;
cc.rgbResult = GetColor(color);
cc.lpCustColors = CustColors;
cc.Flags = CC_RGBINIT | CC_FULLOPEN;
if (ChooseColor(&cc) == 0)
return;
/* Set new color */
SetColor(color, cc.rgbResult);
/* See if a module wants to intercept color change */
if (ModuleEvent(EVENT_COLORCHANGED, color, cc.rgbResult) == False)
return;
MainChangeColor();
}
/*
* UserSelectFont: Bring up font chooser dialog to allow user to change
* given font.
*/
void UserSelectFont(WORD font)
{
CHOOSEFONT cf;
LOGFONT newfont;
if (font > MAXFONTS)
{
debug(("Illegal font #%u", font));
return;
}
/* Get LOGFONT structure for current font; use default on failure */
if (GetObject(fonts[font], sizeof(LOGFONT), &newfont) == 0)
GetObject(hDefaultFont, sizeof(LOGFONT), &newfont);
memset(&cf, 0, sizeof(CHOOSEFONT));
cf.lStructSize = sizeof(CHOOSEFONT);
cf.hwndOwner = hMain;
cf.lpfnHook = ChooseFontHookProc;
cf.lpLogFont = &newfont;
cf.Flags = CF_SCREENFONTS | CF_ENABLEHOOK | CF_INITTOLOGFONTSTRUCT | CF_EFFECTS;
if (ChooseFont(&cf) == 0)
return;
/* Make new font */
DestroyFont(font);
cf.lpLogFont->lfQuality = ANTIALIASED_QUALITY;
SetFont(font, cf.lpLogFont);
/* See if a module wants to intercept font change */
if (ModuleEvent(EVENT_FONTCHANGED, font, cf.lpLogFont) == False)
return;
/* Update fonts on screen */
MainChangeFont();
}
/*
* ParseVerbAlias: User typed this. Reissue a command if it was an alias.
*/
BOOL ParseVerbAlias(char* pInput)
{
char accum[MAXSAY+1];
char* pVerb;
char* pArgs;
int iMatch = -1;
BOOL bTie = FALSE;
BOOL bInvalid;
int i;
if (!pInput || !*pInput)
return FALSE;
pInput = strdup(pInput);
if (!pInput)
return FALSE;
pVerb = pInput;
while (*pVerb == ' ' || *pVerb == '\t')
pVerb++;
pArgs = strtok(pVerb, " \t\r\n");
pArgs = strtok(NULL, "\r\n");
if (!pArgs)
pArgs = "";
for (i = 0; i < _nVerbAliases; i++)
{
// if defined verb begins with typed verb,
if (_apVerbAliases[i].verb[0])
{
if (0 == strnicmp(_apVerbAliases[i].verb, pVerb, strlen(pVerb)))
{
if (iMatch >= 0)
bTie = TRUE;
iMatch = i;
if (0 == stricmp(_apVerbAliases[i].verb, pVerb))
{
bTie = FALSE;
break;
}
}
}
}
if (iMatch < 0)
return FALSE;
if (bTie)
{
GameMessage(GetString(hInst, IDS_AMBIGUOUSALIAS));
return TRUE;
}
// Find any ~~ in .text, replace it with pArgs.
//
pVerb = _apVerbAliases[iMatch].text;
strcpy(accum, pVerb);
{
char* pBefore = pVerb;
char* pAfter = strstr(pVerb, "~~");
if (pAfter && (strlen(pVerb)+strlen(pArgs) < MAXSAY))
{
strcpy(accum+(pAfter-pBefore), pArgs);
strcat(accum, pAfter+2);
pVerb = accum;
}
}
bInvalid = ModuleEvent(EVENT_TEXTCOMMAND, accum);
if (bInvalid)
GameMessage(GetString(hInst, IDS_INVALIDALIAS));
// Return TRUE if command found and handled.
return TRUE;
}
/*
* InventoryKey: User pressed a key on the inventory list.
* Return True iff key should NOT be passed on to Windows for default processing.
*/
Bool InventoryKey(HWND hwnd, UINT key, Bool fDown, int cRepeat, UINT flags)
{
ID id;
Bool held_down = (flags & 0x4000) ? True : False; /* Is key being held down? */
int action, params;
InvItem *item;
void *action_data;
Bool inform;
UserDidSomething();
/* See if inventory handles this key specially */
action = TranslateKey(key, inventory_key_table, &action_data);
if (action == A_NOACTION)
return False;
// Skip held-down keys, except for moving cursor around
if (held_down && !IsCursorAction(action))
return True;
item = InventoryGetCurrentItem();
if (item == NULL)
id = INVALID_ID;
else id = item->obj->id;
// See if we should inform modules about event
inform = True;
switch (action)
{
case A_TABFWD:
case A_TABBACK:
case A_TOGGLEUSE:
case A_USE:
case A_UNUSE:
case A_DROP:
case A_APPLY:
case A_LOOKINVENTORY:
case A_SELECT:
action_data = (void *) id;
break;
default:
inform = False; // Modules will be informed in PerformAction call below
}
// See if a module wants to handle this action
if (inform)
if (ModuleEvent(EVENT_USERACTION, action, action_data) == False)
return True;
if (IsCursorAction(action))
{
InventoryCursorMove(action);
return True;
}
switch (action)
{
case A_TABFWD:
TextInputSetFocus(True); // ajw
//StatsSetFocus(True);
break;
case A_TABBACK:
SetFocus(cinfo->hMain);
break;
case A_TOGGLEUSE:
if (id != INVALID_ID)
{
if (item->obj->flags & OF_APPLYABLE)
StartApply(id);
else ToggleUse(id);
}
break;
case A_USE:
if (id != INVALID_ID)
RequestUse(id);
break;
case A_UNUSE:
if (id != INVALID_ID)
RequestUnuse(id);
break;
case A_DROP:
if (id != INVALID_ID)
InventoryDropCurrentItem(NULL);
break;
case A_APPLY:
if (id != INVALID_ID)
StartApply(id);
break;
case A_LOOKINVENTORY:
if (id == INVALID_ID)
break;
params = DESC_DROP;
if (item->is_using)
params |= DESC_UNUSE;
else if (item->obj->flags & OF_APPLYABLE)
params |= DESC_APPLY;
else params |= DESC_USE;
SetDescParams(cinfo->hMain, params);
RequestLook(id);
break;
case A_SELECT:
if (id != INVALID_ID)
SelectedObject(id);
break;
default:
PerformAction(action, action_data);
break;
}
return True;
}
/*
* MenuCommand: A menu item has been selected.
*/
void MenuCommand(HWND hwnd, int id, HWND hwndCtl, UINT codeNotify)
{
// Set last action time to now, to prevent keypress from being interpreted as a game action.
KeySetLastNorepeatTime();
// See if module wants to handle menu selection
if (ModuleEvent(EVENT_MENUITEM, id) == False)
return;
/* Handle menu selections */
switch (id)
{
case ID_GAME_EXIT:
if (connection != CON_NONE && !AreYouSure(hInst, hMain, NO_BUTTON, IDS_LOGOFF))
break;
MainQuit(hwnd);
break;
case ID_GAME_PRINTMAP:
if (state == STATE_GAME)
PrintMap(FALSE);
break;
case ID_GAME_CONNECT:
OfflineConnect();
break;
case ID_GAME_DISCONNECT:
if (!AreYouSure(hInst, hMain, NO_BUTTON, IDS_LOGOFF))
break;
Logoff();
MainSetState(STATE_OFFLINE);
break;
case ID_GAME_SETTINGS:
if (DialogBox(hInst, MAKEINTRESOURCE(IDD_SETTINGS), hMain, PreferencesDialogProc) == IDOK)
{
ModuleEvent(EVENT_CONFIGCHANGED);
MenuDisplaySettings(hMain);
}
break;
case ID_CONFIGMENU:
ConfigMenuLaunch();
break;
case ID_GAME_PASSWORD:
PerformAction(A_CHANGEPASSWORD, NULL);
break;
case ID_OPTIONS_TIMEOUT:
UserSetTimeout();
break;
case ID_OPTIONS_MUSIC:
config.play_music = !config.play_music;
CheckMenuItem(menu, ID_OPTIONS_MUSIC, config.play_music ? MF_CHECKED : MF_UNCHECKED);
UserToggleMusic(config.play_music);
break;
case ID_OPTIONS_SOUND:
config.play_sound = !config.play_sound;
CheckMenuItem(menu, ID_OPTIONS_SOUND, config.play_sound ? MF_CHECKED : MF_UNCHECKED);
if (!config.play_sound)
SoundStopAll();
break;
case ID_OPTIONS_SAVENOW:
SaveSettings();
break;
case ID_OPTIONS_SAVEEXIT:
config.save_settings = !config.save_settings;
CheckMenuItem(menu, ID_OPTIONS_SAVEEXIT, config.save_settings ? MF_CHECKED : MF_UNCHECKED);
break;
case ID_OPTIONS_AREA:
// due to issues with certain D3D drivers, this no longer immediately updates the config
// it now sets a temporary variable that will update the config on shutdown
// this means a shutdown and restart are necessary for window size changes
MessageBox(hMain, "You must shutdown and restart Meridian 59 for these changes to take effect",
"Direct3D", MB_OK);
// config.large_area = !config.large_area;
gLargeArea = !gLargeArea;
CheckMenuItem(menu, ID_OPTIONS_AREA, gLargeArea ? MF_CHECKED : MF_UNCHECKED);
/* if (state == STATE_GAME)
// Send ourselves a resize message
ResizeAll();
RedrawAll();*/
break;
case ID_OPTIONS_FONT_MAP_TITLE: UserSelectFont(FONT_MAP_TITLE); break;
case ID_OPTIONS_FONT_MAP_LABEL: UserSelectFont(FONT_MAP_LABEL); break;
case ID_OPTIONS_FONT_MAP_TEXT: UserSelectFont(FONT_MAP_TEXT); break;
case ID_FONT_GAMETEXT:
UserSelectFont(FONT_EDIT);
break;
case ID_FONT_LIST:
UserSelectFont(FONT_LIST);
break;
case ID_FONT_MAIL:
UserSelectFont(FONT_MAIL);
break;
case ID_FONT_TITLES:
UserSelectFont(FONT_TITLES);
break;
case ID_FONT_STATISTICS:
UserSelectFont(FONT_STATS);
break;
case ID_FONT_INPUT:
UserSelectFont(FONT_INPUT);
break;
case ID_FONT_LABELS:
UserSelectFont(FONT_LABELS);
break;
case ID_FONT_DEFAULTS:
FontsRestoreDefaults();
break;
case ID_COLOR_MAIN:
UserSelectColors(COLOR_FGD, COLOR_BGD);
break;
case ID_COLOR_LIST:
UserSelectColors(COLOR_LISTFGD, COLOR_LISTBGD);
break;
case ID_COLOR_LISTSEL:
UserSelectColors(COLOR_LISTSELFGD, COLOR_LISTSELBGD);
break;
case ID_COLOR_MAGIC:
UserSelectColor(COLOR_ITEM_MAGIC_FG);
break;
case ID_COLOR_HIGHLIGHT:
UserSelectColor(COLOR_HIGHLITE);
break;
case ID_COLOR_MAIL:
UserSelectColors(COLOR_MAILFGD, COLOR_MAILBGD);
break;
case ID_COLOR_TEXT:
UserSelectColors(COLOR_MAINEDITFGD, COLOR_MAINEDITBGD);
break;
case ID_COLOR_EDIT:
UserSelectColors(COLOR_EDITFGD, COLOR_EDITBGD);
break;
case ID_COLOR_SYSMSG:
UserSelectColor(COLOR_SYSMSGFGD);
case ID_COLOR_QUESTHEADER:
UserSelectColor(COLOR_QUEST_HEADER);
break;
break;
case ID_COLOR_STATS:
UserSelectColors(COLOR_STATSFGD, COLOR_STATSBGD);
break;
case ID_COLOR_BAR1:
UserSelectColor(COLOR_BAR1);
break;
case ID_COLOR_BAR2:
UserSelectColor(COLOR_BAR2);
break;
case ID_COLOR_BAR3:
UserSelectColor(COLOR_BAR3);
break;
case ID_COLOR_BAR4:
UserSelectColor(COLOR_BAR4);
break;
case ID_COLOR_INVNUM:
UserSelectColors(COLOR_INVNUMFGD, COLOR_INVNUMBGD);
break;
case ID_COLOR_DEFAULTS:
ColorsRestoreDefaults();
break;
case ID_HELP_CONTENTS:
StartHelp();
break;
case ID_HOMEPAGE:
WebLaunchBrowser(GetString(hInst, IDS_HOMEPAGEURL));
break;
case ID_FORUM:
WebLaunchBrowser(GetString(hInst, IDS_FORUMURL));
break;
case ID_WIKI:
WebLaunchBrowser(GetString(hInst, IDS_WIKIURL));
break;
case ID_HELP_ABOUT:
DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUT), hMain, AboutDialogProc);
break;
}
}
/**
* ParseLineArgV
*
* Parses and processes a line which was sent by the server.
*
* @param argc number of tokens
* @param argv the tokens
*/
bool CIRCConnection::ParseLineArgV(int argc, const char **argv) {
CChannel *Channel;
CClientConnection *Client;
m_LastResponse = g_CurrentTime;
if (argc < 2) {
return true;
}
const char *Reply = argv[0];
const char *Raw = argv[1];
char *Nick = ::NickFromHostmask(Reply);
int iRaw = atoi(Raw);
bool b_Me = false;
if (m_CurrentNick != NULL && Nick != NULL && strcasecmp(Nick, m_CurrentNick) == 0) {
b_Me = true;
}
free(Nick);
Client = GetOwner()->GetClientConnectionMultiplexer();
// HASH values
CHashCompare hashRaw(argv[1]);
static CHashCompare hashPrivmsg("PRIVMSG");
static CHashCompare hashNotice("NOTICE");
static CHashCompare hashJoin("JOIN");
static CHashCompare hashPart("PART");
static CHashCompare hashKick("KICK");
static CHashCompare hashNick("NICK");
static CHashCompare hashQuit("QUIT");
static CHashCompare hashMode("MODE");
static CHashCompare hashTopic("TOPIC");
static CHashCompare hashPong("PONG");
// END of HASH values
if (argc > 3 && iRaw == 433) {
bool ReturnValue = ModuleEvent(argc, argv);
if (ReturnValue) {
if (GetCurrentNick() == NULL) {
WriteLine("NICK :%s_", argv[3]);
}
if (m_NickCatchTimer == NULL) {
m_NickCatchTimer = new CTimer(30, false, NickCatchTimer, this);
}
}
return ReturnValue;
} else if (argc > 3 && hashRaw == hashPrivmsg && Client == NULL) {
const char *Host;
const char *Dest = argv[2];
char *Nick = ::NickFromHostmask(Reply);
Channel = GetChannel(Dest);
if (Channel != NULL) {
CNick *User = Channel->GetNames()->Get(Nick);
if (User != NULL) {
User->SetIdleSince(g_CurrentTime);
}
Channel->AddBacklogLine(argv[0], argv[3]);
}
if (!ModuleEvent(argc, argv)) {
free(Nick);
return false;
}
/* don't log ctcp requests */
if (argv[3][0] != '\1' && argv[3][strlen(argv[3]) - 1] != '\1' && Dest != NULL &&
Nick != NULL && m_CurrentNick != NULL && strcasecmp(Dest, m_CurrentNick) == 0 &&
strcasecmp(Nick, m_CurrentNick) != 0) {
char *Dup;
char *Delim;
Dup = strdup(Reply);
if (AllocFailed(Dup)) {
free(Nick);
return true;
}
Delim = strchr(Dup, '!');
if (Delim != NULL) {
*Delim = '\0';
Host = Delim + 1;
}
GetOwner()->Log("%s (%s): %s", Dup, Delim ? Host : "<unknown host>", argv[3]);
free(Dup);
}
free(Nick);
UpdateHostHelper(Reply);
return true;
} else if (argc > 3 && hashRaw == hashPrivmsg && Client != NULL) {
Channel = GetChannel(argv[2]);
if (Channel != NULL) {
Channel->AddBacklogLine(argv[0], argv[3]);
}
} else if (argc > 3 && hashRaw == hashNotice && Client == NULL) {
const char *Dest = argv[2];
char *Nick;
if (!ModuleEvent(argc, argv)) {
return false;
}
Nick = ::NickFromHostmask(Reply);
/* don't log ctcp replies */
if (argv[3][0] != '\1' && argv[3][strlen(argv[3]) - 1] != '\1' && Dest != NULL &&
Nick != NULL && m_CurrentNick != NULL && strcasecmp(Dest, m_CurrentNick) == 0 &&
strcasecmp(Nick, m_CurrentNick) != 0) {
GetOwner()->Log("%s (notice): %s", Reply, argv[3]);
}
free(Nick);
return true;
} else if (argc > 2 && hashRaw == hashJoin) {
if (b_Me) {
AddChannel(argv[2]);
/* GetOwner() can be NULL if AddChannel failed */
if (GetOwner() != NULL && Client == NULL) {
WriteLine("MODE %s", argv[2]);
}
}
Channel = GetChannel(argv[2]);
if (Channel != NULL) {
Nick = NickFromHostmask(Reply);
if (AllocFailed(Nick)) {
return false;
}
Channel->AddUser(Nick, '\0');
free(Nick);
}
UpdateHostHelper(Reply);
} else if (argc > 2 && hashRaw == hashPart) {
bool bRet = ModuleEvent(argc, argv);
if (b_Me) {
RemoveChannel(argv[2]);
} else {
Channel = GetChannel(argv[2]);
if (Channel != NULL) {
Nick = ::NickFromHostmask(Reply);
if (AllocFailed(Nick)) {
return false;
}
Channel->RemoveUser(Nick);
free(Nick);
}
}
UpdateHostHelper(Reply);
return bRet;
} else if (argc > 3 && hashRaw == hashKick) {
bool bRet = ModuleEvent(argc, argv);
if (m_CurrentNick != NULL && strcasecmp(argv[3], m_CurrentNick) == 0) {
RemoveChannel(argv[2]);
if (Client == NULL) {
char *Dup = strdup(Reply);
if (AllocFailed(Dup)) {
return bRet;
}
char *Delim = strchr(Dup, '!');
const char *Host = NULL;
if (Delim) {
*Delim = '\0';
Host = Delim + 1;
}
GetOwner()->Log("%s (%s) kicked you from %s (%s)", Dup, Delim ? Host : "<unknown host>", argv[2], argc > 4 ? argv[4] : "");
free(Dup);
}
} else {
Channel = GetChannel(argv[2]);
if (Channel != NULL) {
Channel->RemoveUser(argv[3]);
}
}
UpdateHostHelper(Reply);
return bRet;
} else if (argc > 2 && iRaw == 1) {
if (Client != NULL) {
if (strcmp(Client->GetNick(), argv[2]) != 0) {
Client->WriteLine(":%s!%s NICK :%s", Client->GetNick(), m_Site ? m_Site : "*****@*****.**", argv[2]);
}
}
free(m_CurrentNick);
m_CurrentNick = strdup(argv[2]);
free(m_Server);
m_Server = strdup(Reply);
} else if (argc > 2 && hashRaw == hashNick) {
if (b_Me) {
free(m_CurrentNick);
m_CurrentNick = strdup(argv[2]);
}
Nick = NickFromHostmask(argv[0]);
int i = 0;
if (!b_Me && GetOwner()->GetClientConnectionMultiplexer() == NULL) {
const char *AwayNick = GetOwner()->GetAwayNick();
if (AwayNick != NULL && strcasecmp(AwayNick, Nick) == 0) {
WriteLine("NICK %s", AwayNick);
}
}
while (hash_t<CChannel *> *ChannelHash = m_Channels->Iterate(i++)) {
ChannelHash->Value->RenameUser(Nick, argv[2]);
}
free(Nick);
} else if (argc > 1 && hashRaw == hashQuit) {
bool bRet = ModuleEvent(argc, argv);
Nick = NickFromHostmask(argv[0]);
int i = 0;
while (hash_t<CChannel *> *ChannelHash = m_Channels->Iterate(i++)) {
ChannelHash->Value->RemoveUser(Nick);
}
free(Nick);
return bRet;
} else if (argc > 1 && (iRaw == 422 || iRaw == 376)) {
int DelayJoin = GetOwner()->GetDelayJoin();
if (m_State != State_Connected) {
const CVector<CModule *> *Modules = g_Bouncer->GetModules();
for (int i = 0; i < Modules->GetLength(); i++) {
(*Modules)[i]->ServerLogon(GetOwner()->GetUsername());
}
const char *ClientNick;
if (Client != NULL) {
ClientNick = Client->GetNick();
if (strcmp(m_CurrentNick, ClientNick) != 0) {
Client->ChangeNick(m_CurrentNick);
}
}
GetOwner()->Log("You were successfully connected to an IRC server.");
g_Bouncer->Log("User %s connected to an IRC server.",
GetOwner()->GetUsername());
}
if (DelayJoin == 1) {
m_DelayJoinTimer = g_Bouncer->CreateTimer(5, false, DelayJoinTimer, this);
} else if (DelayJoin == 0) {
JoinChannels();
}
if (Client == NULL) {
bool AppendTS = (GetOwner()->GetConfig()->ReadInteger("user.ts") != 0);
const char *AwayReason = GetOwner()->GetAwayText();
if (AwayReason != NULL) {
WriteLine(AppendTS ? "AWAY :%s (Away since the dawn of time)" : "AWAY :%s", AwayReason);
}
}
const char *AutoModes = GetOwner()->GetAutoModes();
const char *DropModes = GetOwner()->GetDropModes();
if (AutoModes != NULL) {
WriteLine("MODE %s +%s", GetCurrentNick(), AutoModes);
}
if (DropModes != NULL && Client == NULL) {
WriteLine("MODE %s -%s", GetCurrentNick(), DropModes);
}
m_State = State_Connected;
} else if (argc > 1 && strcasecmp(Reply, "ERROR") == 0) {
if (strstr(Raw, "throttle") != NULL) {
GetOwner()->ScheduleReconnect(120);
} else {
GetOwner()->ScheduleReconnect(5);
}
if (GetCurrentNick() != NULL && GetSite() != NULL) {
g_Bouncer->LogUser(GetUser(), "Error received for user %s [%s!%s]: %s",
GetOwner()->GetUsername(), GetCurrentNick(), GetSite(), argv[1]);
} else {
g_Bouncer->LogUser(GetUser(), "Error received for user %s: %s",
GetOwner()->GetUsername(), argv[1]);
}
} else if (argc > 3 && iRaw == 465) {
if (GetCurrentNick() != NULL && GetSite() != NULL) {
g_Bouncer->LogUser(GetUser(), "G/K-line reason for user %s [%s!%s]: %s",
GetOwner()->GetUsername(), GetCurrentNick(), GetSite(), argv[3]);
} else {
g_Bouncer->LogUser(GetUser(), "G/K-line reason for user %s: %s",
GetOwner()->GetUsername(), argv[3]);
}
} else if (argc > 5 && iRaw == 351) {
free(m_ServerVersion);
m_ServerVersion = strdup(argv[3]);
free(m_ServerFeat);
m_ServerFeat = strdup(argv[5]);
} else if (argc > 3 && iRaw == 5) {
for (int i = 3; i < argc - 1; i++) {
char *Dup = strdup(argv[i]);
if (AllocFailed(Dup)) {
return false;
}
char *Eq = strchr(Dup, '=');
if (strcasecmp(Dup, "NAMESX") == 0) {
WriteLine("PROTOCTL NAMESX");
}
char *Value;
if (Eq) {
*Eq = '\0';
Value = strdup(++Eq);
} else {
Value = strdup("");
}
m_ISupport->Add(Dup, Value);
free(Dup);
}
} else if (argc > 4 && iRaw == 324) {
Channel = GetChannel(argv[3]);
if (Channel != NULL) {
Channel->ClearModes();
Channel->ParseModeChange(argv[0], argv[4], argc - 5, &argv[5]);
Channel->SetModesValid(true);
}
} else if (argc > 3 && hashRaw == hashMode) {
Channel = GetChannel(argv[2]);
if (Channel != NULL) {
Channel->ParseModeChange(argv[0], argv[3], argc - 4, &argv[4]);
} else if (strcmp(m_CurrentNick, argv[2]) == 0) {
bool Flip = true, WasNull;
const char *Modes = argv[3];
size_t Length = strlen(Modes) + 1;
if (m_Usermodes != NULL) {
Length += strlen(m_Usermodes);
}
WasNull = (m_Usermodes != NULL) ? false : true;
m_Usermodes = (char *)realloc(m_Usermodes, Length);
if (AllocFailed(m_Usermodes)) {
return false;
}
if (WasNull) {
m_Usermodes[0] = '\0';
}
while (*Modes != '\0') {
if (*Modes == '+') {
Flip = true;
} else if (*Modes == '-') {
Flip = false;
} else {
if (Flip) {
size_t Position = strlen(m_Usermodes);
m_Usermodes[Position] = *Modes;
m_Usermodes[Position + 1] = '\0';
} else {
char *CurrentModes = m_Usermodes;
size_t a = 0;
while (*CurrentModes != '\0') {
*CurrentModes = m_Usermodes[a];
if (*CurrentModes != *Modes) {
CurrentModes++;
}
a++;
}
}
}
Modes++;
}
}
UpdateHostHelper(Reply);
} else if (argc > 4 && iRaw == 329) {
Channel = GetChannel(argv[3]);
if (Channel != NULL) {
Channel->SetCreationTime(atoi(argv[4]));
}
} else if (argc > 4 && iRaw == 332) {
Channel = GetChannel(argv[3]);
if (Channel != NULL) {
Channel->SetTopic(argv[4]);
}
} else if (argc > 5 && iRaw == 333) {
Channel = GetChannel(argv[3]);
if (Channel != NULL) {
Channel->SetTopicNick(argv[4]);
Channel->SetTopicStamp(atoi(argv[5]));
}
} else if (argc > 3 && iRaw == 331) {
Channel = GetChannel(argv[3]);
if (Channel != NULL) {
Channel->SetNoTopic();
}
} else if (argc > 3 && hashRaw == hashTopic) {
Channel = GetChannel(argv[2]);
if (Channel != NULL) {
Channel->SetTopic(argv[3]);
Channel->SetTopicStamp(g_CurrentTime);
Channel->SetTopicNick(argv[0]);
}
UpdateHostHelper(Reply);
} else if (argc > 5 && iRaw == 353) {
Channel = GetChannel(argv[4]);
if (Channel != NULL) {
const char *nicks;
const char **nickv;
nicks = ArgTokenize(argv[5]);
if (AllocFailed(nicks)) {
return false;
}
nickv = ArgToArray(nicks);
if (AllocFailed(nickv)) {
ArgFree(nicks);
return false;
}
int nickc = ArgCount(nicks);
for (int i = 0; i < nickc; i++) {
char *Nick = strdup(nickv[i]);
char *BaseNick = Nick;
if (AllocFailed(Nick)) {
ArgFree(nicks);
return false;
}
StrTrim(Nick, ' ');
while (IsNickPrefix(*Nick)) {
Nick++;
}
char *Modes = NULL;
if (BaseNick != Nick) {
Modes = (char *)malloc(Nick - BaseNick + 1);
if (!AllocFailed(Modes)) {
strmcpy(Modes, BaseNick, Nick - BaseNick + 1);
}
}
Channel->AddUser(Nick, Modes);
free(BaseNick);
free(Modes);
}
ArgFreeArray(nickv);
ArgFree(nicks);
}
} else if (argc > 3 && iRaw == 366) {
Channel = GetChannel(argv[3]);
if (Channel != NULL) {
Channel->SetHasNames();
}
} else if (argc > 9 && iRaw == 352) {
const char *Ident = argv[4];
const char *Host = argv[5];
const char *Server = argv[6];
const char *Nick = argv[7];
const char *Realname = argv[9];
char *Mask;
int rc = asprintf(&Mask, "%s!%s@%s", Nick, Ident, Host);
if (!RcFailed(rc)) {
UpdateHostHelper(Mask);
UpdateWhoHelper(Nick, Realname, Server);
free(Mask);
}
} else if (argc > 6 && iRaw == 367) {
Channel = GetChannel(argv[3]);
if (Channel != NULL) {
Channel->GetBanlist()->SetBan(argv[4], argv[5], atoi(argv[6]));
}
} else if (argc > 3 && iRaw == 368) {
Channel = GetChannel(argv[3]);
if (Channel != NULL) {
Channel->SetHasBans();
}
} else if (argc > 3 && iRaw == 396) {
free(m_Site);
m_Site = strdup(argv[3]);
if (AllocFailed(m_Site)) {}
} else if (argc > 3 && hashRaw == hashPong && m_Server != NULL && strcasecmp(argv[2], m_Server) == 0 && m_EatPong) {
m_EatPong = false;
return false;
} else if (argc > 3 && iRaw == 421) {
m_FloodControl->Unplug();
return false;
}
if (GetOwner() != NULL) {
return ModuleEvent(argc, argv);
} else {
return true;
}
}
long CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
/* See if module wants to handle message */
if (ModuleEvent(EVENT_WINDOWMSG, hwnd, message, wParam, lParam) == False)
return 0;
switch (message)
{
HANDLE_MSG(hwnd, WM_CREATE, MainInit);
HANDLE_MSG(hwnd, WM_PAINT, MainExpose);
HANDLE_MSG(hwnd, WM_DESTROY, MainQuit);
HANDLE_MSG(hwnd, WM_KEYDOWN, MainKey);
HANDLE_MSG(hwnd, WM_KEYUP, MainKey);
case WM_SYSKEYDOWN:
if (HANDLE_WM_SYSKEYDOWN_BLAK(hwnd, wParam, lParam, MainKey) == True)
return 0;
break; // Pass message on to Windows for default menu handling
case WM_SYSKEYUP:
if (HANDLE_WM_SYSKEYDOWN_BLAK(hwnd, wParam, lParam, MainKey) == True)
return 0;
break; // Pass message on to Windows for default menu handling
HANDLE_MSG(hwnd, WM_CHAR, MainChar);
HANDLE_MSG(hwnd, WM_LBUTTONDOWN, MainMouseLButtonDown);
HANDLE_MSG(hwnd, WM_RBUTTONDOWN, MainMouseRButtonDown);
HANDLE_MSG(hwnd, WM_MBUTTONDOWN, MainMouseMButtonDown);
HANDLE_MSG(hwnd, WM_LBUTTONDBLCLK, MainMouseLButtonDown);
HANDLE_MSG(hwnd, WM_LBUTTONUP, MainMouseLButtonUp);
HANDLE_MSG(hwnd, WM_MOUSEMOVE, MainMouseMove);
HANDLE_MSG(hwnd, WM_VSCROLL,MainVScroll);
HANDLE_MSG(hwnd, WM_TIMER, MainTimer);
HANDLE_MSG(hwnd, WM_COMMAND, MainCommand);
HANDLE_MSG(hwnd, WM_SIZE, MainResize);
HANDLE_MSG(hwnd, WM_GETMINMAXINFO, MainMinMaxInfo);
HANDLE_MSG(hwnd, WM_MOVE, MainMove);
HANDLE_MSG(hwnd, WM_SETFOCUS, MainSetFocus);
HANDLE_MSG(hwnd, WM_KILLFOCUS, MainKillFocus);
HANDLE_MSG(hwnd, WM_MENUSELECT, MainMenuSelect);
HANDLE_MSG(hwnd, WM_ENTERIDLE, MainEnterIdle);
HANDLE_MSG(hwnd, WM_NOTIFY, MainNotify);
HANDLE_MSG(hwnd, WM_ACTIVATEAPP, MainActivateApp);
HANDLE_MSG(hwnd, WM_PALETTECHANGED, MainPaletteChanged);
HANDLE_MSG(hwnd, WM_QUERYNEWPALETTE, MainQueryNewPalette);
HANDLE_MSG(hwnd, WM_INITMENUPOPUP, InitMenuPopupHandler);
case WM_MEASUREITEM:
ItemListMeasureItem(hwnd, (MEASUREITEMSTRUCT *) lParam);
return 0;
case WM_DRAWITEM: // windowsx.h macro always returns FALSE
return MainDrawItem(hwnd, (const DRAWITEMSTRUCT *)(lParam));
case WM_SETCURSOR:
if (HANDLE_WM_SETCURSOR(hwnd, wParam, lParam, MainSetCursor))
return TRUE; // avoid DefWindowProc if we handled it
break;
HANDLE_MSG(hwnd, WM_CTLCOLOREDIT, MainCtlColor);
HANDLE_MSG(hwnd, WM_CTLCOLORLISTBOX, MainCtlColor);
HANDLE_MSG(hwnd, WM_CTLCOLORSTATIC, MainCtlColor);
HANDLE_MSG(hwnd, WM_CTLCOLORSCROLLBAR, MainCtlColor);
/* Wave mixer has finished playing file */
HANDLE_MSG(hwnd, MM_WOM_DONE, SoundDone);
case BK_SOCKETEVENT:
MainReadSocket(hwnd, WSAGETSELECTEVENT(lParam), (SOCKET) wParam, WSAGETSELECTERROR(lParam));
return 0;
#ifndef M59_MSS
case MM_MCINOTIFY: /* MIDI file has finished playing */
if (wParam != MCI_NOTIFY_SUCCESSFUL)
break;
MusicDone(LOWORD(lParam));
break;
#endif
case BK_NEWSOUND:
NewMusic(wParam, lParam);
break;
case BK_NORESOURCE:
MissingResource();
break;
case BK_MODULEUNLOAD:
ModuleUnloadById(lParam);
break;
}
return DefWindowProc (hwnd, message, wParam, lParam);
}
void UseObject(ID obj_id)
{
use_list = list_add_item(use_list, (void *) obj_id);
ModuleEvent(EVENT_INVENTORY, INVENTORY_USE, obj_id);
}
