ryzom/client/src/interface_v3/group_quick_help.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010-2021  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2013  Laszlo KIS-ADAM (dfighter) <dfighter1985@gmail.com>
   6 // Copyright (C) 2019-2020  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   7 //
   8 // This program is free software: you can redistribute it and/or modify
   9 // it under the terms of the GNU Affero General Public License as
  10 // published by the Free Software Foundation, either version 3 of the
  11 // License, or (at your option) any later version.
  12 //
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU Affero General Public License for more details.
  17 //
  18 // You should have received a copy of the GNU Affero General Public License
  19 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20
  21
  22
  23
  24
  25
  26 #include "stdpch.h"
  27
  28 #include "group_quick_help.h"
  29 #include "nel/gui/group_list.h"
  30 #include "nel/gui/group_paragraph.h"
  31 #include "nel/gui/libwww.h"
  32 #include "nel/gui/html_element.h"
  33 #include "interface_manager.h"
  34 #include "nel/gui/action_handler.h"
  35 #include "nel/misc/xml_auto_ptr.h"
  36 #include "../actions.h"
  37 #include "../client_cfg.h"
  38
  39 using namespace std;
  40 using namespace NLMISC;
  41
  42 // ***************************************************************************
  43 NLMISC_REGISTER_OBJECT(CViewBase, CGroupQuickHelp, std::string, "quick_help");
  44
  45 CGroupQuickHelp::CGroupQuickHelp(const TCtorParam &param)
  46 :       CGroupHTML(param)
  47 {
  48         _IsQuickHelp = false;
  49         initParameters();
  50         _UpdateParagraphNextUpdateCoords = true;
  51 }
  52
  53 // ***************************************************************************
  54
  55 CGroupQuickHelp::~CGroupQuickHelp()
  56 {
  57 }
  58
  59 // ***************************************************************************
  60
  61 bool CGroupQuickHelp::submitEvent (const char *event)
  62 {
  63         if(_IsQuickHelp==false)
  64                 return false;
  65
  66         if (_CurrentStep<_Steps.size())
  67         {
  68                 const CStep &step = _Steps[_CurrentStep];
  69                 if (step.EventToComplete.find (event) != step.EventToComplete.end())
  70                 {
  71                         // Next step
  72                         _CurrentStep++;
  73
  74                         activateCurrentStep ();
  75
  76                         // Update the text
  77                         updateParagraph ();
  78                 }
  79         }
  80         return false;
  81 }
  82
  83 // ***************************************************************************
  84
  85 void CGroupQuickHelp::updateParagraph ()
  86 {
  87         // Get the group list of CGroupScrollText
  88         CGroupList *groupList = getList ();
  89         if (groupList && groupList->getNumChildren())
  90         {
  91                 // Get the adaptator
  92                 CViewBase *viewBase = groupList->getChild(0);
  93                 if (viewBase)
  94                 {
  95                         CInterfaceGroup *adaptor = dynamic_cast<CInterfaceGroup*>(viewBase);
  96                         if (adaptor)
  97                         {
  98                                 // Get the groups
  99                                 const vector<CInterfaceGroup*> &groups = adaptor->getGroups();
 100
 101                                 // For each paragraph
 102                                 uint i;
 103                                 for (i=0; i<groups.size(); i++)
 104                                 {
 105                                         if (groups[i])
 106                                         {
 107                                                 // Get a paragraph
 108                                                 CGroupParagraph *paragraph = dynamic_cast<CGroupParagraph*> (groups[i]);
 109                                                 if (paragraph)
 110                                                 {
 111                                                         // Set the text size
 112                                                         if (i==_CurrentStep)
 113                                                                 setGroupTextSize (paragraph, true);
 114                                                         else
 115                                                                 setGroupTextSize (paragraph, false);
 116                                                 }
 117                                         }
 118                                 }
 119                         }
 120                 }
 121
 122         }
 123 }
 124
 125 // ***************************************************************************
 126
 127 bool CGroupQuickHelp::parse (xmlNodePtr cur, CInterfaceGroup *parentGroup)
 128 {
 129         // Reset parameters
 130         initParameters ();
 131
 132         CXMLAutoPtr ptr;
 133
 134         ptr = xmlGetProp (cur, (xmlChar*)"non_selected_color");
 135         if (ptr)
 136                 _NonSelectedColor = convertColor(ptr);
 137         ptr = xmlGetProp (cur, (xmlChar*)"non_selected_link_color");
 138         if (ptr)
 139                 _NonSelectedLinkColor = convertColor(ptr);
 140         ptr = xmlGetProp (cur, (xmlChar*)"non_selected_global_color");
 141         if (ptr)
 142                 _NonSelectedGlobalColor = convertBool(ptr);
 143         ptr = xmlGetProp (cur, (xmlChar*)"non_selected_font_size");
 144         if (ptr)
 145                 fromString((const char*)ptr, _NonSelectedSize);
 146
 147
 148         if (!CGroupHTML::parse (cur, parentGroup))
 149                 return false;
 150
 151         return true;
 152 }
 153
 154 // ***************************************************************************
 155
 156 void CGroupQuickHelp::initParameters()
 157 {
 158         _CurrentStep = 0;
 159         _NonSelectedSize = 10;
 160         _NonSelectedColor = CRGBA(128,128,128);
 161         _NonSelectedLinkColor = CRGBA(0,0,128);
 162         _NonSelectedGlobalColor = true;
 163 }
 164
 165 // ***************************************************************************
 166
 167 void CGroupQuickHelp::setGroupTextSize (CInterfaceGroup *group, bool selected)
 168 {
 169         bool globalColor = selected ? TextColorGlobalColor : _NonSelectedGlobalColor;
 170         bool linkGlobalColor = selected ? LinkColorGlobalColor : _NonSelectedGlobalColor;
 171         uint fontSize = selected ? _BrowserStyle.Current.FontSize : _NonSelectedSize;
 172         NLMISC::CRGBA color = selected ? _BrowserStyle.Current.TextColor : _NonSelectedColor;
 173         NLMISC::CRGBA linkColor = selected ? LinkColor : _NonSelectedLinkColor;
 174
 175         // Look for text in this group
 176         const vector<CViewBase*> &views = group->getViews();
 177         uint i;
 178         for (i=0; i<views.size(); i++)
 179         {
 180                 // View text ?
 181                 CViewLink *viewText = dynamic_cast<CViewLink *>(views[i]);
 182                 if (viewText)
 183                 {
 184                         bool link = !(viewText->getText().empty()) && viewText->getUnderlined ();
 185
 186                         // Set text attributes
 187                         viewText->setFontSize(fontSize);
 188                         viewText->setColor(link ? linkColor : color);
 189                         viewText->setModulateGlobalColor(link ? linkGlobalColor : globalColor);
 190                 }
 191         }
 192
 193         // Active / desactive link ctrl
 194         const vector<CCtrlBase*> &ctrls = group->getControls();
 195         for (i=0; i<ctrls.size(); i++)
 196         {
 197                 CCtrlLink *ctrlLink = dynamic_cast<CCtrlLink*>(ctrls[i]);
 198                 if (ctrlLink)
 199                 {
 200                         ctrlLink->setActive(selected);
 201                 }
 202         }
 203
 204         // Look into subgroups
 205         const vector<CInterfaceGroup*> &groups = group->getGroups();
 206         for (i=0; i<groups.size(); i++)
 207         {
 208                 if (groups[i])
 209                 {
 210                         setGroupTextSize (groups[i], selected);
 211                 }
 212         }
 213         CGroupParagraph *p = dynamic_cast<CGroupParagraph*>(group);
 214         if (p)
 215                 p->setTopSpace(0);
 216         group->setActive(selected);
 217 }
 218
 219 // ***************************************************************************
 220
 221 extern CActionsContext ActionsContext;
 222
 223 void CGroupQuickHelp::beginElement(CHtmlElement &elm)
 224 {
 225         CGroupHTML::beginElement (elm);
 226
 227         // Paragraph ?
 228         switch(elm.ID)
 229         {
 230         case HTML_A:
 231                         // Quick help
 232                         if (_TrustedDomain && elm.hasNonEmptyAttribute("z_action_shortcut"))
 233                         {
 234                                 // Get the action category
 235                                 string category = elm.getAttribute("z_action_category");
 236
 237                                 // Get the action params
 238                                 string params = elm.getAttribute("z_action_params");
 239
 240                                 // Get the action descriptor
 241                                 CActionsManager *actionManager = ActionsContext.getActionsManager (category);
 242                                 if (actionManager)
 243                                 {
 244                                         const CActionsManager::TActionComboMap &actionCombo = actionManager->getActionComboMap ();
 245                                         CActionsManager::TActionComboMap::const_iterator ite = actionCombo.find (CAction::CName (elm.getAttribute("z_action_shortcut").c_str(), params.c_str()));
 246                                         if (ite != actionCombo.end())
 247                                         {
 248                                                 addString (ite->second.toString());
 249                                         }
 250                                 }
 251                         }
 252                         break;
 253
 254         case HTML_P:
 255                 // Get the action name
 256                 if (elm.hasAttribute("quick_help_events"))
 257                 {
 258                         // This page is a quick help
 259                         _IsQuickHelp = true;
 260                         // Add a step
 261                         _Steps.push_back (CStep());
 262                         CStep &step = _Steps.back();
 263
 264                         // Get the event names
 265                         string events = elm.getAttribute("quick_help_events");
 266                         if (!events.empty())
 267                         {
 268                                 uint first = 0;
 269                                 while (first < events.size())
 270                                 {
 271                                         // String end
 272                                         string::size_type last = events.find_first_of(" ", first);
 273                                         if (last == string::npos)
 274                                                 last = events.size();
 275
 276                                         // Extract the string
 277                                         step.EventToComplete.insert (events.substr (first, last-first));
 278                                         first = (uint)last+1;
 279                                 }
 280                         }
 281
 282                         // Get the condition
 283                         step.Condition = elm.getAttribute("quick_help_condition");
 284
 285                         // Get the action handlers to run
 286                         step.URL = elm.getAttribute("quick_help_link");
 287                 }
 288                 break;
 289         }
 290 }
 291
 292 // ***************************************************************************
 293 std::string CGroupQuickHelp::getLanguageUrl(const std::string &href, std::string lang) const
 294 {
 295         std::string uri = href;
 296
 297         if (uri.size() < 5 || uri.substr(0, 5) == "http://" || uri.substr(0, 6) == "https://")
 298         {
 299                 return uri;
 300         }
 301
 302         // modify uri such that '_??.html' ending contains current user language
 303         if (uri.substr(uri.size()-5) == ".html")
 304         {
 305                 if (uri.rfind("_") == uri.size() - 8)
 306                 {
 307                         uri = uri.substr(0, uri.size() - 8);
 308                 }
 309                 else
 310                 {
 311                         uri = uri.substr(0, uri.size() - 5);
 312                 }
 313                 uri += "_" + lang + ".html";
 314
 315                 // files inside bnp (file:/gamedev.bnp@help_en.html) will always match with CPath::lookup()
 316                 std::string fname;
 317                 size_t pos = uri.find("@");
 318                 if (pos != std::string::npos)
 319                 {
 320                         fname = uri.substr(pos+1);
 321                 }
 322                 else
 323                 {
 324                         fname = uri;
 325                 }
 326                 if (CPath::lookup(fname, false) == "" && lang != "en")
 327                 {
 328                         uri = getLanguageUrl(href, "en");
 329                 }
 330         }
 331
 332         return uri;
 333 }
 334
 335 // ***************************************************************************
 336
 337 void CGroupQuickHelp::browse (const char *url)
 338 {
 339         // Reset the data
 340         _Steps.clear ();
 341         _CurrentStep = 0;
 342
 343         _IsQuickHelp = false;
 344
 345         string completeURL = getLanguageUrl(url, ClientCfg.getHtmlLanguageCode());
 346
 347         CGroupHTML::browse (completeURL.c_str());
 348 }
 349
 350 // ***************************************************************************
 351
 352 std::string     CGroupQuickHelp::home() const
 353 {
 354         string completeURL = getLanguageUrl(Home, ClientCfg.getHtmlLanguageCode());
 355
 356         return completeURL;
 357 }
 358
 359 // ***************************************************************************
 360
 361 void CGroupQuickHelp::endBuild ()
 362 {
 363         CGroupHTML::endBuild ();
 364
 365         if(_IsQuickHelp==false)
 366                 return;
 367
 368         // First step must run an action handler ?
 369         activateCurrentStep ();
 370         _UpdateParagraphNextUpdateCoords = true;
 371 }
 372
 373 // ***************************************************************************
 374
 375 void CGroupQuickHelp::activateCurrentStep ()
 376 {
 377         CInterfaceManager *pIM = CInterfaceManager::getInstance();
 378         for(;;)
 379         {
 380                 if (_CurrentStep < _Steps.size())
 381                 {
 382                         // Current step
 383                         CStep &step = _Steps[_CurrentStep];
 384
 385                         // A link to follow ?
 386                         if (!step.URL.empty())
 387                                 CAHManager::getInstance()->runActionHandler("browse", NULL, "url="+step.URL);
 388
 389                         // Test a skip condition
 390                         if (!step.Condition.empty() && evalExpression (step.Condition))
 391                         {
 392                                 // Next action handler
 393                                 _CurrentStep++;
 394                                 continue;
 395                         }
 396                 }
 397                 break;
 398         }
 399 }
 400
 401 // ***************************************************************************
 402
 403 bool CGroupQuickHelp::evalExpression (const std::string &condition)
 404 {
 405         // Add your conditions here :
 406
 407         if (condition == "always")
 408                 return true;
 409
 410         return false;
 411 }
 412
 413 // ***************************************************************************
 414 /** Submit a quick help action
 415  */
 416 class CHandlerSubmitQuickHelp : public IActionHandler
 417 {
 418         void execute (CCtrlBase * /* pCaller */, const std::string &sParams)
 419         {
 420                 CInterfaceElement *element = CWidgetManager::getInstance()->getElementFromId("ui:interface:quick_help:content:html");
 421                 if (element)
 422                 {
 423                         // Group HTML ?
 424                         CGroupQuickHelp *groupQH = dynamic_cast<CGroupQuickHelp*>(element);
 425                         if (groupQH)
 426                         {
 427                                 // Submit the form the url
 428                                 groupQH->submitEvent (sParams.c_str());
 429                         }
 430                 }
 431                 element = CWidgetManager::getInstance()->getElementFromId("ui:interface:help_browser:content:html");
 432                 if (element)
 433                 {
 434                         // Group HTML ?
 435                         CGroupQuickHelp *groupQH = dynamic_cast<CGroupQuickHelp*>(element);
 436                         if (groupQH)
 437                         {
 438                                 // Submit the form the url
 439                                 groupQH->submitEvent (sParams.c_str());
 440                         }
 441                 }
 442
 443         }
 444 };
 445 REGISTER_ACTION_HANDLER( CHandlerSubmitQuickHelp, "submit_quick_help");
 446
 447 // ***************************************************************************
 448 /** Run a quick help
 449  */
 450 class CHandlerRunQuickHelp : public IActionHandler
 451 {
 452         void execute (CCtrlBase * /* pCaller */, const std::string &sParams)
 453         {
 454                 CInterfaceManager *pIM = CInterfaceManager::getInstance();
 455
 456                 // Get the quick help radio buttons base id
 457                 string buttonId = CWidgetManager::getInstance()->getParser()->getDefine("quick_help_buttons");
 458                 if (!buttonId.empty())
 459                 {
 460                         // Get the button id
 461                         CInterfaceElement *element = CWidgetManager::getInstance()->getElementFromId(buttonId+":"+sParams);
 462                         if (element)
 463                         {
 464                                 // Button Ctrl ?
 465                                 CCtrlBaseButton *button = dynamic_cast<CCtrlBaseButton*>(element);
 466                                 if (button)
 467                                 {
 468                                         // Push the button
 469                                         button->setPushed(true);
 470
 471                                         // Run the left click action handler
 472                                         CAHManager::getInstance()->runActionHandler(button->getActionOnLeftClick(), button, button->getParamsOnLeftClick());
 473                                 }
 474                         }
 475                 }
 476         }
 477 };
 478 REGISTER_ACTION_HANDLER( CHandlerRunQuickHelp, "run_quick_help");
 479
 480 // ***************************************************************************
 481
 482 void CGroupQuickHelp::updateCoords()
 483 {
 484         CGroupHTML::updateCoords();
 485         if(_IsQuickHelp==false)
 486                 return;
 487         if (_UpdateParagraphNextUpdateCoords)
 488         {
 489                 _UpdateParagraphNextUpdateCoords = false;
 490                 updateParagraph ();
 491         }
 492 }
 493
 494 // ***************************************************************************