// ***************************************************************************
void COutpostManager::startPvpJoinProposal(bool playerGuildInConflict, bool playerGuildIsAttacker,
uint32 ownerGuildNameId, uint32 attackerGuildNameId, uint32 declTimer)
{
// reset counter that force player to be neutral (eg: 10 seconds)
_EndTickForPvpJoinProposal= NetMngr.getCurrentServerTick() + declTimer;
// setup TEMP DB
CInterfaceManager *pIM= CInterfaceManager::getInstance();
CCDBNodeLeaf *node= pIM->getDbProp("UI:TEMP:OUTPOST:PVP_PROPOSAL_PLAYER_GUILD_IN_CONFLICT");
if(node) node->setValueBool(playerGuildInConflict);
node= pIM->getDbProp("UI:TEMP:OUTPOST:PVP_PROPOSAL_PLAYER_GUILD_IS_ATTACKER");
if(node) node->setValueBool(playerGuildIsAttacker);
node= pIM->getDbProp("UI:TEMP:OUTPOST:PVP_PROPOSAL_ATTACKER");
if(node) node->setValue32(attackerGuildNameId);
node= pIM->getDbProp("UI:TEMP:OUTPOST:PVP_PROPOSAL_DEFENDER");
if(node) node->setValue32(ownerGuildNameId);
node= pIM->getDbProp("UI:TEMP:OUTPOST:PVP_PROPOSAL_TICK_END");
if(node) node->setValue32(_EndTickForPvpJoinProposal);
// open Popup
CGroupContainer *pGC = dynamic_cast<CGroupContainer*>(pIM->getElementFromId("ui:interface:join_pvp_outpost_proposal"));
if (pGC)
{
pGC->setActive(true);
pIM->setTopWindow(pGC);
pGC->updateCoords();
pGC->updateCoords();
pGC->center();
pGC->enableBlink(2);
}
}
// ***************************************************************************************
void CBotChatPageMission::begin()
{
CBotChatPage::begin();
CInterfaceManager *im = CInterfaceManager::getInstance();
// clear intro text
im->getDbProp(BOT_CHAT_BASE_DB_PATH ":CHOOSE_MISSION")->setValue32(0);
_MissionPagesObs.setMissionClientType(_MType);
_MissionPagesObs.start();
// Select the Mission Aspect according to mission type
im->getDbProp("UI:TEMP:MISSION:MISSION_TYPE")->setValue32(_MType);
CGroupContainer *gc = dynamic_cast<CGroupContainer *>(im->getElementFromId(WIN_BOT_CHAT_PAGE_MISSION));
if (gc)
{
// show the ui
gc->setActive(true);
// unselect any list
CDBGroupListSheetText *buyListSheet = dynamic_cast<CDBGroupListSheetText *>(gc->getGroup("missions"));
if (buyListSheet)
{
buyListSheet->unselect();
}
}
}
virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
{
CInterfaceManager *pIM = CInterfaceManager::getInstance();
CGroupContainer *pGC = dynamic_cast<CGroupContainer*>(pIM->getElementFromId("ui:interface", Params));
if (pGC == NULL)
{
nlwarning("%s is not a container", Params.c_str());
return;
}
if (!isContainerAuthorized(pGC)) return;
CActionsManager *pAM = &Actions;
// If key is up
if (!pAM->valide(CAction::CName("show_on_press",Params.c_str())))
{
pGC->setActive(false);
_FirstTime = true;
}
else // Key is down
{
// For the first time ?
/*if (_FirstTime)
{
_FirstTime = false;
}
else // Not the first time*/
{
// Show the container
pGC->setActive(true);
}
}
}
// ***************************************************************************
void CGuildManager::launchAscensor()
{
// Start the huge list exchange
Ascensors.start();
// Increment session id
Ascensors.incrementSessionID();
// Send request of the first page to the server specifying the session id
CBitMemStream out;
if(GenericMsgHeaderMngr.pushNameToStream("GUILD:FIRST_ASCENSOR_PAGE", out))
{
uint16 session = Ascensors.getSessionID();
out.serial(session);
NetMngr.push(out);
//nlinfo("impulseCallBack : GUILD:FIRST_ASCENSOR_PAGE %d sent",session);
}
else
{
nlwarning("impulseCallBack : unknown message name : 'GUILD:FIRST_ASCENSOR_PAGE'.");
}
// Start Ascensor Interface
CInterfaceManager *pIM = CInterfaceManager::getInstance();
CGroupContainer *pAC = dynamic_cast<CGroupContainer*>(pIM->getElementFromId(WIN_ASCENSOR));
if (pAC == NULL) return;
pAC->setActive(true);
pIM->setTopWindow(pAC);
}
// ----------------------------------------------------------------------------
void CViewBitmap::draw ()
{
CInterfaceManager *pIM = CInterfaceManager::getInstance();
CViewRenderer &rVR = pIM->getViewRenderer();
CRGBA col;
if(getModulateGlobalColor())
{
col.modulateFromColor (_Color, pIM->getGlobalColorForContent());
}
else
{
col= _Color;
col.A = (uint8)(((sint32)col.A*((sint32)pIM->getGlobalColorForContent().A+1))>>8);
}
if (_InheritGCAlpha)
{
// search a parent container
CInterfaceGroup *gr = getParent();
while (gr)
{
if (gr->isGroupContainer())
{
CGroupContainer *gc = static_cast<CGroupContainer *>(gr);
col.A = (uint8)(((sint32)col.A*((sint32)gc->getCurrentContainerAlpha()+1))>>8);
break;
}
gr = gr->getParent();
}
}
// ***************************************************************************
bool CDBGroupListSheet::handleEvent (const CEventDescriptor &event)
{
if (event.getType() == CEventDescriptor::mouse)
{
const CEventDescriptorMouse &eventDesc = (const CEventDescriptorMouse &)event;
if (isIn(eventDesc.getX(), eventDesc.getY()))
{
if (eventDesc.getEventTypeExtended() == CEventDescriptorMouse::mousewheel)
{
if (_ScrollBar != NULL)
{
// and scroll for 1+ item.
_ScrollBar->moveTargetY (-eventDesc.getWheel() * _HSlot);
return true;
}
}
if (eventDesc.getEventTypeExtended() == CEventDescriptorMouse::mouseleftup)
{
CGroupContainer *pGC = getContainer();
if (pGC != NULL) pGC->setHighLighted(false);
}
}
}
return CInterfaceGroup::handleEvent(event);
}
virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
{
CInterfaceManager *pIM = CInterfaceManager::getInstance();
CGroupContainer *pGC = dynamic_cast<CGroupContainer*>(pIM->getElementFromId("ui:interface", Params));
if (pGC == NULL)
{
nlwarning("%s is not a container", Params.c_str());
return;
}
pGC->close();
}
// ***************************************************************************
// test if an interface element is open (uses its id) //
static DECLARE_INTERFACE_USER_FCT(isOpen)
{
if (args.size() != 1) return false;
if (!args[0].toString()) return false;
CGroupContainer *elm = dynamic_cast<CGroupContainer*>(CWidgetManager::getInstance()->getElementFromId(args[0].getString()));
if (!elm)
{
nlwarning("<isOpen> : can't find element %s", args[0].getString().c_str());
return false;
}
result.setBool(elm->isOpen());
return true;
}
virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
{
CInterfaceManager *pIM = CInterfaceManager::getInstance();
CGroupContainer *pGC = dynamic_cast<CGroupContainer*>(pIM->getElementFromId("ui:interface", Params));
if (pGC == NULL)
{
nlwarning("%s is not a container", Params.c_str());
return;
}
if (!isContainerAuthorized(pGC)) return;
pGC->setActive(true);
pIM->setTopWindow(pGC);
}
virtual void execute (CCtrlBase *pCaller, const std::string &/* Params */)
{
// CInterfaceManager *im = CInterfaceManager::getInstance();
CGroupContainer *gc = NULL;
CCtrlBase *cb = pCaller;
while (cb)
{
gc = dynamic_cast<CGroupContainer *>(cb);
if (gc) break;
cb = cb->getParent();
}
if (!gc) return;
//gc->setMovable(!gc->isMovable());
gc->setLocked(!gc->isLocked());
}
virtual void execute(CCtrlBase *pCaller, const string &/* Params */)
{
sint nMacNb = getMacroFromId(pCaller->getId());
CInterfaceManager *pIM = CInterfaceManager::getInstance();
CMacroCmdManager *pMCM = CMacroCmdManager::getInstance();
pMCM->CurrentEditMacro = pMCM->getMacros()[nMacNb];
pMCM->CurrentEditMacroNb = nMacNb;
CGroupContainer *pGC = dynamic_cast<CGroupContainer*>(CWidgetManager::getInstance()->getElementFromId(WIN_NEWMACRO));
if (pGC != NULL)
{
pGC->setTitle(NEWMACRO_TITLE_EDIT);
pGC->setActive (false);
pGC->setActive (true);
}
}
// ***************************************************************************
void CDBGroupListSheet::draw ()
{
// Drag'N'Drop : display the selected slot bitmap if this slot accept the currently dragged element
CInterfaceManager *pIM = CInterfaceManager::getInstance();
if (_CanDrop)
{
CGroupContainer *pGC = getContainer();
if (pGC != NULL) pGC->setHighLighted(false);
}
_CanDrop = false;
if (_CtrlInfo._AHOnCanDrop != NULL)
if (pIM->getCapturePointerLeft())
{
CGroupContainer *pGC = getContainer();
if (pIM->getCurrentWindowUnder() == pGC)
{
if ((pIM->getPointer()->getX() >= _XReal) &&
(pIM->getPointer()->getX() < (_XReal + _WReal))&&
(pIM->getPointer()->getY() > _YReal) &&
(pIM->getPointer()->getY() <= (_YReal+ _HReal)))
{
CDBCtrlSheet *pCSSrc = dynamic_cast<CDBCtrlSheet*>(pIM->getCapturePointerLeft());
if ((pCSSrc != NULL) && pCSSrc->isDraging())
{
string params = string("src=") + pCSSrc->getId();
if (!_CtrlInfo._AHCanDropParams.empty())
{
string sTmp = _CtrlInfo._AHCanDropParams;
params = sTmp + "|" + params;
}
pIM->runActionHandler (_CtrlInfo._AHOnCanDrop, this, params);
}
}
}
// Set the container highlighted
if (pGC != NULL) pGC->setHighLighted(_CanDrop);
}
CInterfaceGroup::draw();
}
void execute (CCtrlBase * /* pCaller */, const std::string &sParams)
{
CInterfaceManager *im = CInterfaceManager::getInstance();
string receiver = getParam (sParams, "player");
if (receiver.empty())
return;
CChatGroupWindow *pCGW = PeopleInterraction.getChatGroupWindow();
if (pCGW != NULL)
{
CGroupContainer *pGC = pCGW->createFreeTeller(receiver);
if (pGC != NULL)
pGC->setActive(true);
CGroupEditBox *eb = dynamic_cast<CGroupEditBox *>(pGC->getGroup("eb"));
if (eb)
{
CWidgetManager::getInstance()->setCaptureKeyboard(eb);
}
}
}
virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
{
CInterfaceManager *pIM = CInterfaceManager::getInstance();
CGroupContainer *pGC = dynamic_cast<CGroupContainer*>(pIM->getElementFromId("ui:interface", Params));
if (pGC == NULL)
{
nlwarning("%s is not a container", Params.c_str());
return;
}
if (!pGC->isPopable())
{
nlwarning("%s cannot be popup/popin", Params.c_str());
return;
}
if (!isContainerAuthorized(pGC)) return;
if (pGC->isPopuped())
pIM->runActionHandler("popin", NULL, Params);
else
pIM->runActionHandler("popup", NULL, Params);
}
virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
{
string webapp, window = Params;
vector<string> res;
explode(Params, string("|"), res);
if(res[0]=="webig" || res[0]=="mailbox" || res[0]=="guild_forum" || res[0]=="profile")
{
window = "webig";
if(res[0]=="mailbox")
webapp = "mail";
else if(res[0]=="guild_forum")
webapp = "forum";
else if(res[0]=="profile")
webapp = "profile&pname="+urlencode(getParam(Params,"pname"))+"&ptype="+getParam(Params,"ptype");
else
webapp = "web";
}
CInterfaceManager *pIM = CInterfaceManager::getInstance();
CGroupContainer *pGC = dynamic_cast<CGroupContainer*>(pIM->getElementFromId("ui:interface", window));
if (pGC == NULL)
{
nlwarning("%s is not a container", window.c_str());
return;
}
if (!isContainerAuthorized(pGC)) return;
if(window == "webig")
{
if(pGC->getActive() && currentWebApp == webapp)
{
pGC->setActive(false);
currentWebApp.clear();
}
else
{
pGC->setActive(true);
currentWebApp = webapp;
}
if(!webapp.empty() && pGC->getActive())
{
CGroupHTML *pGH = dynamic_cast<CGroupHTML*>(pIM->getElementFromId("ui:interface:webig:content:html"));
if (pGH == NULL)
{
nlwarning("%s is not a group html", window.c_str());
return;
}
pGH->setURL("http://atys.ryzom.com/start/index.php?app="+webapp);
}
}
else
{
// normal open/close swap
pGC->setActive(!pGC->getActive());
}
}
virtual void execute (CCtrlBase * /* pCaller */, const string &Params)
{
CInterfaceManager *pIM = CInterfaceManager::getInstance();
CGroupContainer *pGC = dynamic_cast<CGroupContainer*>(pIM->getElementFromId("ui:interface", Params));
if (pGC == NULL)
{
nlwarning("%s is not a container", Params.c_str());
return;
}
if (!pGC->isPopable())
{
nlwarning("%s cannot be popup", Params.c_str());
return;
}
if (!isContainerAuthorized(pGC)) return;
//
pGC->popup();
//
pIM->setCapturePointerLeft(NULL);
pIM->setCapturePointerRight(NULL);
}
virtual void execute (CCtrlBase *pCaller, const string &Params)
{
CInterfaceManager *im = CInterfaceManager::getInstance();
// get the parent container
CGroupContainer *gc = NULL;
CCtrlBase *cb = pCaller;
while (cb)
{
gc = dynamic_cast<CGroupContainer *>(cb);
if (gc) break;
cb = cb->getParent();
}
// update GC_POPUP flag
if (gc)
{
im->getDbProp("UI:VARIABLES:GC_POPUP")->setValue64((gc->isPopuped() || gc->getLayerSetup() == 0) ? 1 : 0);
}
else
{
im->getDbProp("UI:VARIABLES:GC_POPUP")->setValue64(0);
}
// update GC_HAS_HELP flag
if(gc && !gc->getHelpPage().empty())
{
im->getDbProp("UI:VARIABLES:GC_HAS_HELP")->setValue64(1);
}
else
{
im->getDbProp("UI:VARIABLES:GC_HAS_HELP")->setValue64(0);
}
// open the menu
if (CDBCtrlSheet::getDraggedSheet() == NULL)
{
CInterfaceManager::getInstance()->enableModalWindow (pCaller, getParam(Params, "menu"));
}
}
// ***************************************************************************
void COutpostManager::update()
{
// *** If there is a join proposal running
if(_EndTickForPvpJoinProposal!=0)
{
if(_EndTickForPvpJoinProposal<NetMngr.getCurrentServerTick())
{
CInterfaceManager *pIM= CInterfaceManager::getInstance();
// Force the neutral choose
pIM->runActionHandler("outpost_pvp_join", NULL, "neutral");
// close the window
CGroupContainer *pGC = dynamic_cast<CGroupContainer*>(pIM->getElementFromId("ui:interface:join_pvp_outpost_proposal"));
if (pGC)
pGC->setActive(false);
// stop timer
_EndTickForPvpJoinProposal= 0;
}
}
}
virtual void execute(CCtrlBase * /* pCaller */, const string &/* Params */)
{
CInterfaceManager *pIM = CInterfaceManager::getInstance();
CMacroCmdManager *pMCM = CMacroCmdManager::getInstance();
// Reinit the new_macro container and variables
CMacroCmd mc;
mc.Name = "NewMacro";
mc.BitmapBack = 0;
mc.BitmapIcon = 0;
mc.BitmapOver = 0;
pMCM->CurrentEditMacro = mc;
CGroupContainer *pGC = dynamic_cast<CGroupContainer*>(CWidgetManager::getInstance()->getElementFromId(WIN_NEWMACRO));
if (pGC != NULL)
{
pGC->setTitle(NEWMACRO_TITLE_NEW);
pGC->setActive (false);
pGC->setActive (true);
}
pMCM->CurrentEditMacroNb = -1;
pMCM->EditCmd->deactivate();
}
virtual void execute(CCtrlBase * /* pCaller */, const string &/* Params */)
{
CInterfaceManager *pIM = CInterfaceManager::getInstance();
CMacroCmdManager *pMCM = CMacroCmdManager::getInstance();
CSPhraseManager *pPM = CSPhraseManager::getInstance();
// Validate name
CAHManager::getInstance()->runActionHandler("new_macro_enter_name",NULL);
// Check if macro has more than one command
if (pMCM->CurrentEditMacro.Commands.size() == 0) return;
// Add a macro
if (pMCM->CurrentEditMacroNb != -1)
{
// retrieve the Id of the edited macro, to keep the same id in addMacro()
pMCM->CurrentEditMacro.ID= pMCM->getMacros()[pMCM->CurrentEditMacroNb].ID;
pMCM->delMacro(pMCM->CurrentEditMacroNb);
pMCM->addMacro(pMCM->CurrentEditMacro,pMCM->CurrentEditMacroNb);
// update the Memory Manager
pPM->updateMacroShortcuts(pMCM->CurrentEditMacro.ID);
// reset id of EditMacro
pMCM->CurrentEditMacro.ID= -1;
}
else
{
pMCM->addMacro(pMCM->CurrentEditMacro);
}
CGroupContainer *pGC = dynamic_cast<CGroupContainer*>(CWidgetManager::getInstance()->getElementFromId(WIN_NEWMACRO));
if (pGC != NULL) pGC->setActive (false);
CAHManager::getInstance()->runActionHandler("macros_open",NULL);
// Refresh key containers
pMCM->refreshAllKeyDisplays();
}
// --------------------------------------------------------------------------------------------------------------------
bool CViewPointer::drawResizer(CCtrlBase* pCB, CRGBA col)
{
CCtrlResizer *pCR = dynamic_cast<CCtrlResizer*>(pCB);
if (pCR != NULL)
{
CGroupContainer *parent = dynamic_cast<CGroupContainer *>(pCR->getParent());
if (parent && !parent->isLocked())
{
sint32 texID= -1;
switch(pCR->getRealResizerPos())
{
case Hotspot_BR:
case Hotspot_TL:
texID = _TxIdResizeBRTL;
break;
case Hotspot_BL:
case Hotspot_TR:
texID = _TxIdResizeBLTR;
break;
case Hotspot_MR:
case Hotspot_ML:
texID = _TxIdResizeLR;
break;
case Hotspot_TM:
case Hotspot_BM:
texID = _TxIdResizeTB;
break;
default:
return false;
break;
}
drawCursor(texID, col, false);
return true;
}
}
return false;
}
// ***************************************************************************
void CInterfaceConfig::CDesktopImage::updateGroupContainerImage(CGroupContainer &gc)
{
bool updated = false;
for(uint k = 0; k < GCImages.size(); ++k)
{
if (GCImages[k].Id == gc.getId())
{
GCImages[k].setFrom(&gc);
updated = true;
}
}
if (!updated)
{
SCont image;
image.setFrom(&gc);
GCImages.push_back(image);
}
}
virtual void execute (CCtrlBase * /* pCaller */, const std::string &Params)
{
CInterfaceManager *pIM = CInterfaceManager::getInstance();
CGroupContainer *pGC = dynamic_cast<CGroupContainer*>(pIM->getElementFromId(Params));
if (pGC != NULL)
{
pGC->setUseGlobalAlpha(false);
pGC->setContainerAlpha((uint8) 0);
pGC->setContentAlpha((uint8) 255);
pGC->setRolloverAlphaContainer((uint8) 255);
pGC->setRolloverAlphaContent((uint8) 0);
}
}
// ***************************************************************************************
void CBotChatPageMission::selectMission(CDBCtrlSheet *missionSheet)
{
if (!missionSheet) return;
if (missionSheet->getGrayed()) return;
// show the dialog with good infos
CInterfaceManager *im = CInterfaceManager::getInstance();
CGroupContainer *gc = dynamic_cast<CGroupContainer *>(im->getElementFromId(WIN_BOT_CHAT_ACCEPT_MISSION));
// copy text id for title
{
CCDBNodeLeaf *titleTextLeaf = dynamic_cast<CCDBNodeLeaf *>(missionSheet->getRootBranch()->getNode(ICDBNode::CTextId("TEXT")));
//
CViewTextID *viewTitleTextID = dynamic_cast<CViewTextID *>(gc->getView("text_title_id"));
if (viewTitleTextID && titleTextLeaf)
viewTitleTextID->setTextId(titleTextLeaf->getValue32());
}
// copy text id for details
CCDBNodeLeaf *detailTextLeaf = dynamic_cast<CCDBNodeLeaf *>(missionSheet->getRootBranch()->getNode(ICDBNode::CTextId("DETAIL_TEXT")));
//
CViewTextID *viewTextID = dynamic_cast<CViewTextID *>(gc->getView("text_id"));
if(viewTextID && detailTextLeaf)
{
viewTextID->setTextId(detailTextLeaf->getValue32());
}
// copy icon
CCDBNodeLeaf *iconLeaf = im->getDbProp("UI:TEMP:MISSION:ICON");
if (iconLeaf)
{
iconLeaf->setValue32(missionSheet->getSheetId());
}
//
if (!gc) return;
im->setTopWindow(gc);
gc->setActive(true);
gc->updateCoords();
gc->center();
gc->setModalParentList(WIN_BOT_CHAT_PAGE_MISSION);
_CurrSel = missionSheet;
}
// --------------------------------------------------------------------------------------------------------------------
void CViewPointer::draw ()
{
// Do not display the pointer if not visible.
if(!_PointerVisible)
return;
CInterfaceManager *pIM = CInterfaceManager::getInstance();
CViewRenderer &rVR = pIM->getViewRenderer();
if (pIM->isInGame())
if (!_StringCursor)
{
// Create the string cursor instance
std::vector<std::pair<std::string,std::string> > templateParams;
templateParams.push_back (std::pair<std::string,std::string>("id", "string_cursor"));
_StringCursor = pIM->createGroupInstance("string_cursor", "", templateParams);
if (_StringCursor)
_StringCursor->setParentPos(pIM->getElementFromId("ui:interface"));
templateParams.clear();
templateParams.push_back (std::pair<std::string,std::string>("id", "string_cursor_hardware"));
_StringCursorHardware = pIM->createGroupInstance("string_cursor_hardware", "", templateParams);
if (_StringCursorHardware)
_StringCursorHardware->setParentPos(pIM->getElementFromId("ui:interface"));
}
CRGBA col;
if(getModulateGlobalColor())
col.modulateFromColor (_Color, pIM->getGlobalColor());
else
col= _Color;
//col.A = (uint8)(((sint32)col.A*((sint32)pIM->getGlobalColor().A+1))>>8);
col.A = _Color.A;
if (_LastHightLight != NULL)
{
_LastHightLight->setHighLighted(false,0);
_LastHightLight = NULL;
}
if (pIM->getCapturePointerLeft() != NULL && pIM->isMouseHandlingEnabled())
{
CCtrlMover *pCM = dynamic_cast<CCtrlMover*>(pIM->getCapturePointerLeft());
if ((pCM != NULL) && (pCM->canMove() == true))
{
CGroupContainer *pGC = dynamic_cast<CGroupContainer *>(pCM->getParent());
if (pGC != NULL && !pGC->isLocked())
{
pGC->setHighLighted(true, 255);
_LastHightLight = pGC;
}
}
}
if (_TxIdDefault == -2)
{
_TxIdDefault = rVR.getTextureIdFromName (_TxDefault);
_TxIdMoveWindow = rVR.getTextureIdFromName (_TxMoveWindow);
_TxIdResizeBRTL = rVR.getTextureIdFromName (_TxResizeBRTL);
_TxIdResizeBLTR = rVR.getTextureIdFromName (_TxResizeBLTR);
_TxIdResizeTB = rVR.getTextureIdFromName (_TxResizeTB);
_TxIdResizeLR = rVR.getTextureIdFromName (_TxResizeLR);
_TxIdRotate = rVR.getTextureIdFromName (_TxRotate);
_TxIdScale = rVR.getTextureIdFromName (_TxScale);
_TxIdColPick = rVR.getTextureIdFromName (_TxColPick);
_TxIdPan = rVR.getTextureIdFromName (_TxPan);
_TxIdCanPan = rVR.getTextureIdFromName (_TxCanPan);
if (ClientCfg.R2EDEnabled)
{
_TxIdPanR2 = rVR.getTextureIdFromName (_TxPanR2);
_TxIdCanPanR2 = rVR.getTextureIdFromName (_TxCanPanR2);
}
}
const vector<CCtrlBase *> &rICL = pIM->getCtrlsUnderPointer ();
// Draw the captured cursor
CCtrlBase *pCB = pIM->getCapturePointerLeft();
if (pCB != NULL)
{
if (drawResizer(pCB,col)) return;
//if (drawMover(pCB,col)) return;
if (drawColorPicker(pCB,col)) return;
if (drawRotate(pCB,col)) return;
if (drawPan(pCB,col)) return;
if (drawCustom(pCB)) return;
drawCursor(_TxIdDefault, col, 0);
return;
}
const vector<CViewBase *> &vUP = pIM->getViewsUnderPointer ();
for(uint i=0;i<vUP.size();i++)
{
CViewLink *vLink = dynamic_cast<CViewLink*>(vUP[i]);
if (vLink != NULL)
{
string tooltip;
uint8 rot;
if (vLink->getMouseOverShape(tooltip, rot, col))
{
setString(ucstring(tooltip));
sint32 texId = rVR.getTextureIdFromName ("curs_pick.tga");
CInterfaceGroup *stringCursor = IsMouseCursorHardware() ? _StringCursorHardware : _StringCursor;
if (stringCursor)
{
stringCursor->setX(_PointerX);
stringCursor->setY(_PointerY);
stringCursor->updateCoords();
stringCursor->draw();
// if in hardware mode, force to draw the default cursor no matter what..
if (IsMouseCursorHardware())
drawCursor(texId, col, 0);
}
else
{
drawCursor(texId, col, 0);
}
return;
}
}
}
// Draw if capture right
pCB = pIM->getCapturePointerRight();
if (pCB != NULL)
{
// Is it a 3d scene ?
if (drawScale(pCB,col)) return;
drawCursor(_TxIdDefault, col, 0);
return;
}
bool overModalWindow = false;
// is the cursor currently over a modal window ?
CInterfaceGroup *currModal = pIM->getModalWindow();
if (currModal)
{
sint32 xPos = _XReal + _OffsetX;
sint32 yPos = _YReal + _OffsetY;
overModalWindow = currModal->isIn(xPos, yPos, _WReal, _HReal);
}
// Draw the cursor type that are under the pointer
if (pIM->isMouseHandlingEnabled())
{
// Sorts the controls according to their depth, to approximate as best the CapturePointerLeft algo.
// Especially important so that Resizers controls get the precedence over the move control (else could randomly bug like in chat group)
static vector<CCtrlDepthEntry> sortedControls;
sortedControls.clear();
for(uint i=0;i<rICL.size();i++)
{
CCtrlDepthEntry cde;
cde.Ctrl= rICL[i];
// NB: not the exact CInterfaceManager getDepth test here, but should work fine
cde.Depth= cde.Ctrl->getParentDepth() + cde.Ctrl->getDeltaDepth();
sortedControls.push_back(cde);
}
std::sort(sortedControls.begin(), sortedControls.end());
// Then draw the correct cursor
for (uint32 i = 0; i < sortedControls.size(); ++i)
{
CCtrlBase *pCB = sortedControls[i].Ctrl;
if (overModalWindow)
{
if (!pCB->isSonOf(currModal)) continue;
}
if (drawBrowse(pCB, col)) return;
if (drawResizer(pCB,col)) return;
if (drawColorPicker(pCB,col)) return;
if (drawLink (pCB, col)) return;
if (drawCustom(pCB)) return;
// test for move highlight
if (_LastHightLight == NULL)
{
CCtrlMover *pCM = dynamic_cast<CCtrlMover*>(pCB);
if ( (pCM != NULL) && (pCM->canMove() == true) )
{
CGroupContainer *pGC = dynamic_cast<CGroupContainer *>(pCM->getParent());
if (pGC != NULL && !pGC->isLocked())
{
if (pIM->getCapturePointerLeft() != pCM)
pGC->setHighLighted(true, 128);
else
pGC->setHighLighted(true, 255);
_LastHightLight = pGC;
break;
}
}
}
//if (drawMover(pCB,col)) return;
}
}
if (pIM->isMouseHandlingEnabled())
{
if (rICL.empty())
{
const vector<CInterfaceGroup *> &rIGL = pIM->getGroupsUnderPointer ();
for (uint32 i = 0; i < rIGL.size(); ++i)
{
CInterfaceGroup *pG = rIGL[i];
if (overModalWindow)
{
if (!pG->isSonOf(currModal)) continue;
}
if (drawPan (pG, col)) return;
if (drawBrowse(pG, col)) return;
}
}
}
if (_StringMode && pIM->isMouseHandlingEnabled())
{
CInterfaceGroup *stringCursor = IsMouseCursorHardware() ? _StringCursorHardware : _StringCursor;
if (stringCursor)
{
stringCursor->setX(_PointerX);
stringCursor->setY(_PointerY);
stringCursor->updateCoords();
stringCursor->draw();
// if in hardware mode, force to draw the default cursor no matter what..
if (IsMouseCursorHardware())
{
drawCursor(_TxIdDefault, col, 0);
}
}
}
else
{
// Draw the default cursor
drawCursor(_TxIdDefault, col, 0);
}
}
virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
{
uint32 i;
CInterfaceManager *pIM = CInterfaceManager::getInstance();
const vector<CInterfaceManager::SMasterGroup> &rVMG = pIM->getAllMasterGroup();
for (uint32 nMasterGroup = 0; nMasterGroup < rVMG.size(); nMasterGroup++)
{
const CInterfaceManager::SMasterGroup &rMG = rVMG[nMasterGroup];
const vector<CInterfaceGroup*> &rV = rMG.Group->getGroups();
// Active all containers (that can be activated)
for (i = 0; i < rV.size(); ++i)
{
CGroupContainer *pGC = dynamic_cast<CGroupContainer*>(rV[i]);
if (pGC == NULL) continue;
if (pGC->isSavable())
{
// Yoyo: DO NOT force activation of containers who don't want to save their Active state.
// Usually driven by server.
if(pGC->isActiveSavable())
pGC->setActive(true);
}
}
pIM->checkCoords();
pIM->getMasterGroup((uint8)nMasterGroup).centerAllContainers();
// Pop in and close all containers
for (i = 0; i < rV.size(); ++i)
{
CGroupContainer *pGC = dynamic_cast<CGroupContainer*>(rV[i]);
if (pGC == NULL) continue;
if (pGC->isSavable())
{
if (pGC->isPopable()&&pGC->isPopuped())
pGC->popin();
// Can close ?
if (pGC->isOpenable()&&pGC->isOpen())
pGC->close();
}
}
pIM->getMasterGroup((uint8)nMasterGroup).deactiveAllContainers();
}
}
// ***************************************************************************
void CGuildManager::update()
{
CInterfaceManager *pIM = CInterfaceManager::getInstance();
STRING_MANAGER::CStringManagerClient *pSMC = STRING_MANAGER::CStringManagerClient::instance();
// *** Need to rebuild the guild data?
if (_NeedRebuild)
{
_NeedUpdate = true;
_NeedRebuild = false;
// Rebuild transfert the database to the local structure
// Guild stuff
uint32 oldName = _Guild.NameID;
_Guild.NameID = pIM->getDbProp("SERVER:GUILD:NAME")->getValue32();
_Guild.Name = "";
_InGuild = (_Guild.NameID != 0);
if (!_InGuild)
closeAllInterfaces();
_Guild.Icon = pIM->getDbProp("SERVER:GUILD:ICON")->getValue64();
_Guild.QuitGuildAvailable = true;
// Guild Members
if(_NeedRebuildMembers)
{
_NeedUpdateMembers = true;
_NeedRebuildMembers = false;
_GuildMembers.clear();
for (uint32 i = 0; i < MAX_GUILD_MEMBER; ++i)
{
sint32 name = pIM->getDbProp("SERVER:GUILD:MEMBERS:"+toString(i)+":NAME")->getValue32();
if (name != 0)
{
SGuildMember gm;
gm.NameID = name;
gm.Index = i;
gm.Grade = (EGSPD::CGuildGrade::TGuildGrade)(pIM->getDbProp("SERVER:GUILD:MEMBERS:"+toString(i)+":GRADE")->getValue32());
gm.Online = (TCharConnectionState)(pIM->getDbProp("SERVER:GUILD:MEMBERS:"+toString(i)+":ONLINE")->getValue32());
gm.EnterDate = pIM->getDbProp("SERVER:GUILD:MEMBERS:"+toString(i)+":ENTER_DATE")->getValue32();
_GuildMembers.push_back(gm);
}
}
}
// Does the player are newcomer ?
// Boris 01/09/2006 : removed : now the guild interface is open if
// is was active before OR if the EGS ask it to the client
bool playerNewToTheGuild = _NewToTheGuild &&(oldName != _Guild.NameID) && _InGuild;
if (playerNewToTheGuild)
{
// reset the flag
_NewToTheGuild = false;
// Don't pop the guild window in ring mode.
// NB nico : this test should not be necessary, as the guild infos should be filled during the init of the db
// However, there are situation where this db info is filled after init (should only happen at guild creation time ...)
// Maybe an EGS bug ?
if (R2::getEditor().getMode() == R2::CEditor::NotInitialized)
{
CInterfaceElement *pElt;
// Open the guild info if we are not in the init phase
if (!IngameDbMngr.initInProgress())
{
pElt = pIM->getElementFromId(WIN_GUILD);
if (pElt != NULL)
pElt->setActive(true);
}
// Browse the forum
pElt = pIM->getElementFromId(WIN_GUILD_FORUM":content:html");
if (pElt != NULL)
{
CGroupHTML *html = dynamic_cast<CGroupHTML*>(pElt);
if (html)
html->browse("home");
}
}
}
}
// *** Need to update Names?
if (_NeedUpdate)
{
bool bAllValid = true;
// Update wait until all the name of members, name of the guild and description are valid
if (!pSMC->getString (_Guild.NameID, _Guild.Name)) bAllValid = false;
for (uint i = 0; i < _GuildMembers.size(); ++i)
{
if (!pSMC->getString (_GuildMembers[i].NameID, _GuildMembers[i].Name)) bAllValid = false;
else _GuildMembers[i].Name = CEntityCL::removeTitleAndShardFromName(_GuildMembers[i].Name);
}
// If all is valid no more need update and if guild is opened update the interface
if (bAllValid)
{
// Search for UserEntity to find our own grade
if ((UserEntity != NULL) && (_GuildMembers.size() > 0))
{
uint i;
_Grade = EGSPD::CGuildGrade::Member;
string sUserName = strlwr(UserEntity->getEntityName().toString());
for (i = 0; i < _GuildMembers.size(); ++i)
{
if (strlwr(_GuildMembers[i].Name.toString()) == sUserName)
{
_Grade = _GuildMembers[i].Grade;
break;
}
}
}
// set this value in the database
pIM->getDbProp("UI:VARIABLES:USER:GUILD_GRADE")->setValue32(_Grade);
// update the guild display
CGroupContainer *pGuild = dynamic_cast<CGroupContainer*>(pIM->getElementFromId(WIN_GUILD));
if (pGuild != NULL)
{
// if the guild window is visible
if (pGuild->isOpen() && pGuild->getActive())
{
// Close the modal window if the member list will change
if(pIM->getModalWindow()!=NULL && _NeedUpdateMembers)
{
if (pIM->getModalWindow()->getId() == MENU_GUILD_MEMBER )
pIM->disableModalWindow();
}
// Rebuild interface. Rebuild members only if needed
pIM->runActionHandler("guild_sheet_open", NULL, toString("update_members=%d", (uint)_NeedUpdateMembers) );
}
}
// guild updated
_NeedUpdate = false;
_NeedUpdateMembers= false;
}
}
// *** Join proposal handling
if (_JoinPropUpdate)
{
bool bAllValid = true;
if (!pSMC->getDynString (_JoinPropPhraseID, _JoinPropPhrase)) bAllValid = false;
// If all is valid no more need update and update the interface
if (bAllValid)
{
_JoinPropUpdate = false;
CGroupContainer *pJoinProp = dynamic_cast<CGroupContainer*>(pIM->getElementFromId(WIN_JOIN_PROPOSAL));
if (pJoinProp != NULL)
{
CViewText *pJoinPropPhraseView = dynamic_cast<CViewText*>(pIM->getElementFromId(VIEW_JOIN_PROPOSAL_PHRASE));
if (pJoinPropPhraseView != NULL)
pJoinPropPhraseView->setText(_JoinPropPhrase);
pJoinProp->setActive(true);
pIM->setTopWindow(pJoinProp);
pJoinProp->updateCoords();
pJoinProp->center();
pJoinProp->enableBlink(2);
}
}
}
}
// ***************************************************************************
void CInterfaceConfig::CDesktopImage::fromCurrentDesktop()
{
CInterfaceManager *pIM = CInterfaceManager::getInstance();
// Count number of container to save
uint32 nCount = 0, nMasterGroup, i, nCount2;
const vector<CInterfaceManager::SMasterGroup> &rVMG = pIM->getAllMasterGroup();
for (nMasterGroup = 0; nMasterGroup < rVMG.size(); nMasterGroup++)
{
const CInterfaceManager::SMasterGroup &rMG = rVMG[nMasterGroup];
const vector<CInterfaceGroup*> &rV = rMG.Group->getGroups();
for (i = 0; i < rV.size(); ++i)
{
CGroupContainer *pGC= dynamic_cast<CGroupContainer*>(rV[i]);
if ( pGC != NULL && pGC->isSavable() )
nCount++;
}
}
GCImages.resize(nCount);
SCont contTmp;
nCount2 = 0;
// retrieve all containers
for (nMasterGroup = 0; nMasterGroup < rVMG.size(); nMasterGroup++)
{
const CInterfaceManager::SMasterGroup &rMG = rVMG[nMasterGroup];
const vector<CInterfaceGroup*> &rV = rMG.Group->getGroups();
for (i = 0; i < rV.size(); ++i)
{
CGroupContainer *pGC = dynamic_cast<CGroupContainer*>(rV[i]);
if ( pGC != NULL && pGC->isSavable() )
{
GCImages[nCount2].setFrom(pGC);
nCount2++;
}
}
}
nlassert(nCount2 == nCount);
// set extra data stream version (in memory)
Version = INTERFACE_CONFIG_STREAM_VERSION;
// serial extra data in the stream
NLMISC::CMemStream &f = ExtraDatas;
if (f.isReading())
{
f.invert();
}
f.resetPtrTable();
f.seek(0, NLMISC::IStream::begin);
// Save the Top Window for this config.
CInterfaceGroup *topWindow= pIM->getTopWindow(pIM->getLastTopWindowPriority());
string topWindowName;
if (topWindow)
{
CGroupContainer *pGC= dynamic_cast<CGroupContainer*>(topWindow);
if (pGC != NULL && pGC->isSavable())
topWindowName = pGC->getId();
}
f.serial(topWindowName);
// retrieve number of elements that want their config saved
CCountUIElemWithConfigVisitor counter;
pIM->visit(&counter);
f.serial(counter.Count);
// Serial specific infos for each widget that reclaims it
CSaveUIConfigVisitor saver(f);
pIM->visit(&saver);
}
virtual void execute (CCtrlBase *pCaller, const std::string &/* Params */)
{
CInterfaceManager *im = CInterfaceManager::getInstance();
CGroupContainer *gc = NULL;
CCtrlBase *cb = pCaller;
while (cb)
{
gc = dynamic_cast<CGroupContainer *>(cb);
if (gc) break;
cb = cb->getParent();
}
if (!gc) return;
AlphaChooserTarget = gc;
if (!_AlphaObserversAdded)
{
_UiVariableBGAlpha = im->getDbProp("UI:VARIABLES:ALPHA_BG");
_UiVariableContentAlpha = im->getDbProp("UI:VARIABLES:ALPHA_CONTENT");
_UiVariableRolloverAlphaBG = im->getDbProp("UI:VARIABLES:ALPHA_ROLLOVER_BG");
_UiVariableRolloverAlphaContent = im->getDbProp("UI:VARIABLES:ALPHA_ROLLOVER_CONTENT");
ICDBNode::CTextId textIdBGAlpha, textIdContentAlpha, textIdRolloverAlphaBG, textIdRolloverAlphaContent;
_UiVariableBGAlpha->addObserver(&_BgAlphaObs, textIdBGAlpha);
_UiVariableContentAlpha->addObserver(&_ContentAlphaObs, textIdContentAlpha);
_UiVariableRolloverAlphaBG->addObserver(&_RolloverAlphaBGObs, textIdRolloverAlphaBG);
_UiVariableRolloverAlphaContent->addObserver(&_RolloverAlphaContentObs, textIdRolloverAlphaContent);
_AlphaObserversAdded = true;
}
// disable observers
_ContentAlphaObs.On = false;
_BgAlphaObs.On = false;
_RolloverAlphaBGObs.On = false;
_RolloverAlphaContentObs.On = false;
// set alpha of current chosen container
_UiVariableBGAlpha->setValue32(gc->getContainerAlpha());
_UiVariableContentAlpha->setValue32(gc->getContentAlpha());
_UiVariableRolloverAlphaBG->setValue32(255 - gc->getRolloverAlphaContainer());
_UiVariableRolloverAlphaContent->setValue32(255 - gc->getRolloverAlphaContent());
// enable observers
_ContentAlphaObs.On = true;
_BgAlphaObs.On = true;
_RolloverAlphaBGObs.On = true;
_RolloverAlphaContentObs.On = true;
// backup current alpha (if the user cancel)
OldContentAlpha = gc->getContentAlpha();
OldBgAlpha = gc->getContainerAlpha();
OldRolloverAlphaBG = gc->getRolloverAlphaContainer();
OldRolloverAlphaContent = gc->getRolloverAlphaContent();
OldUseGlobalAlpha = gc->isUsingGlobalAlpha();
// Enable 'use global alpha' button
im->getDbProp("UI:VARIABLES:USER_ALPHA")->setValue64(gc->isUsingGlobalAlpha() ? 0 : 1);
// show the modal box
im->enableModalWindow(gc, "ui:interface:define_ui_transparency");
}
