?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'main/rendor-staging' into fixes
[ryzomcore.git] / nel / src / gui / group_html.cpp
blob5b43c895e153faa5ebaddc897db23164a1664d10
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 //#include <crtdbg.h>
22
23 #include "stdpch.h"
24 #include "nel/gui/group_html.h"
25
26 #include <string>
27 #include "nel/misc/types_nl.h"
28 #include "nel/misc/rgba.h"
29 #include "nel/misc/algo.h"
30 #include "nel/misc/utf_string_view.h"
31 #include "nel/gui/libwww.h"
32 #include "nel/gui/group_html.h"
33 #include "nel/gui/group_list.h"
34 #include "nel/gui/group_menu.h"
35 #include "nel/gui/group_container.h"
36 #include "nel/gui/view_link.h"
37 #include "nel/gui/ctrl_scroll.h"
38 #include "nel/gui/ctrl_button.h"
39 #include "nel/gui/ctrl_text_button.h"
40 #include "nel/gui/action_handler.h"
41 #include "nel/gui/group_paragraph.h"
42 #include "nel/gui/group_editbox.h"
43 #include "nel/gui/widget_manager.h"
44 #include "nel/gui/lua_manager.h"
45 #include "nel/gui/view_bitmap.h"
46 #include "nel/gui/dbgroup_combo_box.h"
47 #include "nel/gui/lua_ihm.h"
48 #include "nel/misc/i18n.h"
49 #include "nel/misc/md5.h"
50 #include "nel/3d/texture_file.h"
51 #include "nel/misc/big_file.h"
52 #include "nel/gui/url_parser.h"
53 #include "nel/gui/http_cache.h"
54 #include "nel/gui/http_hsts.h"
55 #include "nel/web/curl_certificates.h"
56 #include "nel/gui/html_parser.h"
57 #include "nel/gui/html_element.h"
58 #include "nel/gui/css_style.h"
59 #include "nel/gui/css_parser.h"
60 #include "nel/gui/css_border_renderer.h"
61 #include "nel/gui/css_background_renderer.h"
62
63 #include <curl/curl.h>
64
65 using namespace std;
66 using namespace NLMISC;
67
68 #ifdef DEBUG_NEW
69 #define new DEBUG_NEW
70 #endif
71
72 // Default maximum time the request is allowed to take
73 #define DEFAULT_RYZOM_CONNECTION_TIMEOUT (300.0)
74 // Allow up to 10 redirects, then give up
75 #define DEFAULT_RYZOM_REDIRECT_LIMIT (10)
76 //
77 #define FONT_WEIGHT_NORMAL 400
78 #define FONT_WEIGHT_BOLD 700
79
80 namespace NLGUI
81 {
82
83 // Uncomment nlwarning() to see the log about curl downloads
84 #define LOG_DL(fmt, ...) //nlwarning(fmt, ## __VA_ARGS__)
85 // Uncomment to log curl progess
86 //#define LOG_CURL_PROGRESS 1
87
88 CGroupHTML::SWebOptions CGroupHTML::options;
89
90 // Return URL with https is host is in HSTS list
91 static std::string upgradeInsecureUrl(const std::string &url)
92 {
93 if (toLowerAscii(url.substr(0, 7)) != "http://") {
94 return url;
95 }
96
97 CUrlParser uri(url);
98 if (!CStrictTransportSecurity::getInstance()->isSecureHost(uri.host)){
99 return url;
100 }
101
102 LOG_DL("HSTS url : '%s', using https", url.c_str());
103 uri.scheme = "https";
104
105 return uri.toString();
106 }
107
108 // Active cURL www transfer
109 class CCurlWWWData
110 {
111 public:
112 CCurlWWWData(CURL *curl, const std::string &url)
113 : Request(curl), Url(url), Content(""), HeadersSent(NULL)
114 {
115 }
116 ~CCurlWWWData()
117 {
118 if (Request)
119 curl_easy_cleanup(Request);
120
121 if (HeadersSent)
122 curl_slist_free_all(HeadersSent);
123 }
124
125 void sendHeaders(const std::vector<std::string> headers)
126 {
127 for(uint i = 0; i < headers.size(); ++i)
128 {
129 HeadersSent = curl_slist_append(HeadersSent, headers[i].c_str());
130 }
131 curl_easy_setopt(Request, CURLOPT_HTTPHEADER, HeadersSent);
132 }
133
134 void setRecvHeader(const std::string &header)
135 {
136 size_t pos = header.find(": ");
137 if (pos == std::string::npos)
138 return;
139
140 std::string key = toLowerAscii(header.substr(0, pos));
141 if (pos != std::string::npos)
142 {
143 HeadersRecv[key] = header.substr(pos + 2);
144 //nlinfo(">> received header '%s' = '%s'", key.c_str(), HeadersRecv[key].c_str());
145 }
146 }
147
148 // return last received "Location: <url>" header or empty string if no header set
149 const std::string getLocationHeader()
150 {
151 if (HeadersRecv.count("location") > 0)
152 return HeadersRecv["location"];
153
154 return "";
155 }
156
157 const uint32 getExpires()
158 {
159 time_t ret = 0;
160 if (HeadersRecv.count("expires") > 0)
161 ret = curl_getdate(HeadersRecv["expires"].c_str(), NULL);
162
163 return ret > -1 ? ret : 0;
164 }
165
166 const std::string getLastModified()
167 {
168 if (HeadersRecv.count("last-modified") > 0)
169 {
170 return HeadersRecv["last-modified"];
171 }
172
173 return "";
174 }
175
176 const std::string getEtag()
177 {
178 if (HeadersRecv.count("etag") > 0)
179 {
180 return HeadersRecv["etag"];
181 }
182
183 return "";
184 }
185
186 bool hasHSTSHeader()
187 {
188 // ignore header if not secure connection
189 if (toLowerAscii(Url.substr(0, 8)) != "https://")
190 {
191 return false;
192 }
193
194 return HeadersRecv.count("strict-transport-security") > 0;
195 }
196
197 const std::string getHSTSHeader()
198 {
199 if (hasHSTSHeader())
200 {
201 return HeadersRecv["strict-transport-security"];
202 }
203
204 return "";
205 }
206
207 public:
208 CURL *Request;
209
210 std::string Url;
211 std::string Content;
212
213 private:
214 // headers sent with curl request, must be released after transfer
215 curl_slist * HeadersSent;
216
217 // headers received from curl transfer
218 std::map<std::string, std::string> HeadersRecv;
219 };
220
221 // cURL transfer callbacks
222 // ***************************************************************************
223 static size_t curlHeaderCallback(char *buffer, size_t size, size_t nmemb, void *pCCurlWWWData)
224 {
225 CCurlWWWData * me = static_cast<CCurlWWWData *>(pCCurlWWWData);
226 if (me)
227 {
228 std::string header;
229 header.append(buffer, size * nmemb);
230 me->setRecvHeader(header.substr(0, header.find_first_of("\n\r")));
231 }
232
233 return size * nmemb;
234 }
235
236 // ***************************************************************************
237 static size_t curlDataCallback(char *buffer, size_t size, size_t nmemb, void *pCCurlWWWData)
238 {
239 CCurlWWWData * me = static_cast<CCurlWWWData *>(pCCurlWWWData);
240 if (me)
241 me->Content.append(buffer, size * nmemb);
242
243 return size * nmemb;
244 }
245
246 // ***************************************************************************
247 static size_t curlProgressCallback(void *pCCurlWWWData, curl_off_t dltotal, curl_off_t dlnow, curl_off_t ultotal, curl_off_t ulnow)
248 {
249 CCurlWWWData * me = static_cast<CCurlWWWData *>(pCCurlWWWData);
250 if (me)
251 {
252 if (dltotal > 0 || dlnow > 0 || ultotal > 0 || ulnow > 0)
253 {
254 #ifdef LOG_CURL_PROGRESS
255 nlwarning("> dltotal %ld, dlnow %ld, ultotal %ld, ulnow %ld, url '%s'", dltotal, dlnow, ultotal, ulnow, me->Url.c_str());
256 #endif
257 }
258 }
259
260 // return 1 to cancel download
261 return 0;
262 }
263
264 CGroupHTML::CDataDownload::~CDataDownload()
265 {
266 delete data;
267 data = NULL;
268 }
269
270 void CGroupHTML::StylesheetDownloadCB::finish()
271 {
272 if (CFile::fileExists(tmpdest))
273 {
274 if (CFile::fileExists(dest))
275 {
276 CFile::deleteFile(dest);
277 }
278 CFile::moveFile(dest, tmpdest);
279 }
280 Parent->cssDownloadFinished(url, dest);
281 }
282
283 void CGroupHTML::ImageDownloadCB::addImage(CViewBase *img, const CStyleParams &style, TImageType type)
284 {
285 Images.push_back(SImageInfo(img, style, type));
286 }
287
288 void CGroupHTML::ImageDownloadCB::removeImage(CViewBase *img)
289 {
290 for(std::vector<SImageInfo>::iterator it = Images.begin(); it != Images.end(); ++it)
291 {
292 if (it->Image == img)
293 {
294 Images.erase(it);
295 break;
296 }
297 }
298 }
299
300 void CGroupHTML::ImageDownloadCB::finish()
301 {
302 // Image setTexture will remove itself from Images while iterating over it.
303 // Do the swap to keep iterator safe.
304 std::vector<SImageInfo> vec;
305 vec.swap(Images);
306
307 // tmpdest file does not exist if download skipped (ie cache was used)
308 if (CFile::fileExists(tmpdest) || CFile::getFileSize(tmpdest) == 0)
309 {
310 try {
311 // verify that image is not corrupted
312 uint32 w, h;
313 CBitmap::loadSize(tmpdest, w, h);
314 if (w != 0 && h != 0)
315 {
316 if (CFile::fileExists(dest))
317 CFile::deleteFile(dest);
318 }
319 }
320 catch(const NLMISC::Exception &e)
321 {
322 // exception message has .tmp file name, so keep it for further analysis
323 nlwarning("Invalid image (%s) from url (%s): %s", tmpdest.c_str(), url.c_str(), e.what());
324 }
325
326 // to reload image on page, the easiest seems to be changing texture
327 // to temp file temporarily. that forces driver to reload texture from disk
328 // ITexture::touch() seem not to do this.
329 // cache was updated, first set texture as temp file
330 for(std::vector<SImageInfo>::iterator it = vec.begin(); it != vec.end(); ++it)
331 {
332 SImageInfo &img = *it;
333 Parent->setImage(img.Image, tmpdest, img.Type);
334 Parent->setImageSize(img.Image, img.Style);
335 }
336
337 CFile::moveFile(dest, tmpdest);
338 }
339
340 if (!CFile::fileExists(dest) || CFile::getFileSize(dest) == 0)
341 {
342 // placeholder if cached image failed
343 dest = "web_del.tga";
344 }
345
346 // even if image was cached, incase there was 'http://' image set to CViewBitmap
347 for(std::vector<SImageInfo>::iterator it = vec.begin(); it != vec.end(); ++it)
348 {
349 SImageInfo &img = *it;
350 Parent->setImage(img.Image, dest, img.Type);
351 Parent->setImageSize(img.Image, img.Style);
352 }
353 }
354
355 void CGroupHTML::TextureDownloadCB::finish()
356 {
357 // tmpdest file does not exist if download skipped (ie cache was used)
358 if (CFile::fileExists(tmpdest) && CFile::getFileSize(tmpdest) > 0)
359 {
360 if (CFile::fileExists(dest))
361 CFile::deleteFile(dest);
362
363 CFile::moveFile(dest, tmpdest);
364 }
365
366 CViewRenderer &rVR = *CViewRenderer::getInstance();
367 for(uint i = 0; i < TextureIds.size(); i++)
368 {
369 rVR.reloadTexture(TextureIds[i].first, dest);
370 TextureIds[i].second->invalidateCoords();
371 }
372 }
373
374 void CGroupHTML::BnpDownloadCB::finish()
375 {
376 bool verified = false;
377 // no tmpfile if file was already in cache
378 if (CFile::fileExists(tmpdest))
379 {
380 verified = m_md5sum.empty() || (m_md5sum != getMD5(tmpdest).toString());
381 if (verified)
382 {
383 if (CFile::fileExists(dest))
384 {
385 CFile::deleteFile(dest);
386 }
387 CFile::moveFile(dest, tmpdest);
388 }
389 else
390 {
391 CFile::deleteFile(tmpdest);
392 }
393 }
394 else if (CFile::fileExists(dest))
395 {
396 verified = m_md5sum.empty() || (m_md5sum != getMD5(dest).toString());
397 }
398
399 if (!m_lua.empty())
400 {
401 std::string script = "\nlocal __CURRENT_WINDOW__ = \""+Parent->getId()+"\"";
402 script += toString("\nlocal __DOWNLOAD_STATUS__ = %s\n", verified ? "true" : "false");
403 script += m_lua;
404 CLuaManager::getInstance().executeLuaScript(script, true );
405 }
406 }
407
408 // Check if domain is on TrustedDomain
409 bool CGroupHTML::isTrustedDomain(const string &domain)
410 {
411 vector<string>::iterator it;
412 it = find ( options.trustedDomains.begin(), options.trustedDomains.end(), domain);
413 return it != options.trustedDomains.end();
414 }
415
416 // Update view after download has finished
417 void CGroupHTML::setImage(CViewBase * view, const string &file, const TImageType type)
418 {
419 CCtrlButton *btn = dynamic_cast<CCtrlButton*>(view);
420 if(btn)
421 {
422 if (type == NormalImage)
423 {
424 btn->setTexture (file);
425 btn->setTexturePushed(file);
426 btn->invalidateCoords();
427 btn->invalidateContent();
428 paragraphChange();
429 }
430 else
431 {
432 btn->setTextureOver(file);
433 }
434
435 return;
436 }
437
438 CViewBitmap *btm = dynamic_cast<CViewBitmap*>(view);
439 if(btm)
440 {
441 btm->setTexture (file);
442 btm->invalidateCoords();
443 btm->invalidateContent();
444 paragraphChange();
445
446 return;
447 }
448
449 CGroupCell *btgc = dynamic_cast<CGroupCell*>(view);
450 if(btgc)
451 {
452 btgc->setTexture (file);
453 btgc->invalidateCoords();
454 btgc->invalidateContent();
455 paragraphChange();
456
457 return;
458 }
459
460 CGroupTable *table = dynamic_cast<CGroupTable*>(view);
461 if (table)
462 {
463 table->setTexture(file);
464
465 return;
466 }
467 }
468
469 // Force image width, height
470 void CGroupHTML::setImageSize(CViewBase *view, const CStyleParams &style)
471 {
472 sint32 width = style.Width;
473 sint32 height = style.Height;
474 sint32 maxw = style.MaxWidth;
475 sint32 maxh = style.MaxHeight;
476
477 sint32 imageWidth, imageHeight;
478 bool changed = true;
479
480 // get image texture size
481 // if image is being downloaded, then correct size is set after thats done
482 CCtrlButton *btn = dynamic_cast<CCtrlButton*>(view);
483 if(btn)
484 {
485 btn->fitTexture();
486 imageWidth = btn->getW(false);
487 imageHeight = btn->getH(false);
488 }
489 else
490 {
491 CViewBitmap *btm = dynamic_cast<CViewBitmap*>(view);
492 if(btm)
493 {
494 btm->fitTexture();
495 imageWidth = btm->getW(false);
496 imageHeight = btm->getH(false);
497 }
498 else
499 {
500 // not supported
501 return;
502 }
503 }
504
505 // if width/height is not requested, then use image size
506 // else recalculate missing value, keep image ratio
507 if (width == -1 && height == -1)
508 {
509 width = imageWidth;
510 height = imageHeight;
511
512 changed = false;
513 }
514 else
515 if (width == -1 || height == -1) {
516 float ratio = (float) imageWidth / std::max(1, imageHeight);
517 if (width == -1)
518 width = height * ratio;
519 else
520 height = width / ratio;
521 }
522
523 // apply max-width, max-height rules if asked
524 if (maxw > -1 || maxh > -1)
525 {
526 _Style.applyCssMinMax(width, height, 0, 0, maxw, maxh);
527 changed = true;
528 }
529
530 if (changed)
531 {
532 CCtrlButton *btn = dynamic_cast<CCtrlButton*>(view);
533 if(btn)
534 {
535 btn->setScale(true);
536 btn->setW(width);
537 btn->setH(height);
538 }
539 else
540 {
541 CViewBitmap *image = dynamic_cast<CViewBitmap*>(view);
542 if(image)
543 {
544 image->setScale(true);
545 image->setW(width);
546 image->setH(height);
547 }
548 }
549 }
550 }
551
552 void CGroupHTML::setTextButtonStyle(CCtrlTextButton *ctrlButton, const CStyleParams &style)
553 {
554 // this will also set size for <a class="ryzom-ui-button"> treating it like "display: inline-block;"
555 if (style.Width > 0) ctrlButton->setWMin(style.Width);
556 if (style.Height > 0) ctrlButton->setHMin(style.Height);
557
558 CViewText *pVT = ctrlButton->getViewText();
559 if (pVT)
560 {
561 setTextStyle(pVT, style);
562 }
563
564 if (style.hasStyle("background-color"))
565 {
566 ctrlButton->setColor(style.Background.color);
567 if (style.hasStyle("-ryzom-background-color-over"))
568 {
569 ctrlButton->setColorOver(style.BackgroundColorOver);
570 }
571 else
572 {
573 ctrlButton->setColorOver(style.Background.color);
574 }
575 ctrlButton->setTexture("", "blank.tga", "", false);
576 ctrlButton->setTextureOver("", "blank.tga", "");
577 ctrlButton->setProperty("force_text_over", "true");
578 }
579 else if (style.hasStyle("-ryzom-background-color-over"))
580 {
581 ctrlButton->setColorOver(style.BackgroundColorOver);
582 ctrlButton->setProperty("force_text_over", "true");
583 ctrlButton->setTextureOver("blank.tga", "blank.tga", "blank.tga");
584 }
585 }
586
587 void CGroupHTML::setTextStyle(CViewText *pVT, const CStyleParams &style)
588 {
589 if (pVT)
590 {
591 pVT->setColor(style.TextColor);
592 pVT->setFontName(style.FontFamily);
593 pVT->setFontSize(style.FontSize, false);
594 pVT->setEmbolden(style.FontWeight >= FONT_WEIGHT_BOLD);
595 pVT->setOblique(style.FontOblique);
596 pVT->setUnderlined(style.Underlined);
597 pVT->setStrikeThrough(style.StrikeThrough);
598 if (style.TextShadow.Enabled)
599 {
600 pVT->setShadow(true);
601 pVT->setShadowColor(style.TextShadow.Color);
602 pVT->setShadowOutline(style.TextShadow.Outline);
603 pVT->setShadowOffset(style.TextShadow.X, style.TextShadow.Y);
604 }
605 }
606 }
607
608 // Get an url and return the local filename with the path where the url image should be
609 string CGroupHTML::localImageName(const string &url)
610 {
611 string dest = "cache/";
612 dest += getMD5((uint8 *)url.c_str(), (uint32)url.size()).toString();
613 dest += ".cache";
614 return dest;
615 }
616
617 void CGroupHTML::pumpCurlQueue()
618 {
619 if (RunningCurls < options.curlMaxConnections)
620 {
621 std::list<CDataDownload*>::iterator it=Curls.begin();
622 while(it != Curls.end() && RunningCurls < options.curlMaxConnections)
623 {
624 if ((*it)->data == NULL)
625 {
626 LOG_DL("(%s) starting new download '%s'", _Id.c_str(), it->url.c_str());
627 if (!startCurlDownload(*it))
628 {
629 LOG_DL("(%s) failed to start '%s)'", _Id.c_str(), it->url.c_str());
630 finishCurlDownload(*it);
631
632 it = Curls.erase(it);
633 continue;
634 }
635 }
636
637 ++it;
638 }
639 }
640
641 if (RunningCurls > 0 || !Curls.empty())
642 LOG_DL("(%s) RunningCurls %d, _Curls %d", _Id.c_str(), RunningCurls, Curls.size());
643 }
644
645 // Add url to MultiCurl queue and return cURL handle
646 bool CGroupHTML::startCurlDownload(CDataDownload *download)
647 {
648 if (!MultiCurl)
649 {
650 nlwarning("Invalid MultiCurl handle, unable to download '%s'", download->url.c_str());
651 return false;
652 }
653
654 time_t currentTime;
655 time(&currentTime);
656
657 CHttpCacheObject cache;
658 if (CFile::fileExists(download->dest))
659 cache = CHttpCache::getInstance()->lookup(download->dest);
660
661 if (cache.Expires > currentTime)
662 {
663 LOG_DL("Cache for (%s) is not expired (%s, expires:%d)", download->url.c_str(), download->dest.c_str(), cache.Expires - currentTime);
664 return false;
665 }
666
667 // use browser Id so that two browsers would not use same temp file
668 download->tmpdest = localImageName(_Id + download->dest) + ".tmp";
669
670 // erase the tmp file if exists
671 if (CFile::fileExists(download->tmpdest))
672 {
673 CFile::deleteFile(download->tmpdest);
674 }
675
676 FILE *fp = nlfopen (download->tmpdest, "wb");
677 if (fp == NULL)
678 {
679 nlwarning("Can't open file '%s' for writing: code=%d '%s'", download->tmpdest.c_str (), errno, strerror(errno));
680 return false;
681 }
682
683 CURL *curl = curl_easy_init();
684 if (!curl)
685 {
686 fclose(fp);
687 CFile::deleteFile(download->tmpdest);
688
689 nlwarning("Creating cURL handle failed, unable to download '%s'", download->url.c_str());
690 return false;
691 }
692 LOG_DL("curl easy handle %p created for '%s'", curl, download->url.c_str());
693
694 // https://
695 if (toLowerAscii(download->url.substr(0, 8)) == "https://")
696 {
697 // if supported, use custom SSL context function to load certificates
698 NLWEB::CCurlCertificates::useCertificates(curl);
699 }
700
701 download->data = new CCurlWWWData(curl, download->url);
702 download->fp = fp;
703
704 // initial connection timeout, curl default is 300sec
705 curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, download->ConnectionTimeout);
706
707 curl_easy_setopt(curl, CURLOPT_NOPROGRESS, true);
708 curl_easy_setopt(curl, CURLOPT_URL, download->url.c_str());
709
710 // limit curl to HTTP and HTTPS protocols only
711 curl_easy_setopt(curl, CURLOPT_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS);
712 curl_easy_setopt(curl, CURLOPT_REDIR_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS);
713
714 std::vector<std::string> headers;
715 if (!cache.Etag.empty())
716 headers.push_back("If-None-Match: " + cache.Etag);
717
718 if (!cache.LastModified.empty())
719 headers.push_back("If-Modified-Since: " + cache.LastModified);
720
721 if (headers.size() > 0)
722 download->data->sendHeaders(headers);
723
724 // catch headers
725 curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, NLGUI::curlHeaderCallback);
726 curl_easy_setopt(curl, CURLOPT_WRITEHEADER, download->data);
727
728 std::string userAgent = options.appName + "/" + options.appVersion;
729 curl_easy_setopt(curl, CURLOPT_USERAGENT, userAgent.c_str());
730
731 CUrlParser uri(download->url);
732 if (!uri.host.empty())
733 sendCookies(curl, uri.host, isTrustedDomain(uri.host));
734
735 curl_easy_setopt(curl, CURLOPT_WRITEDATA, fp);
736 curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, fwrite);
737
738 CURLMcode ret = curl_multi_add_handle(MultiCurl, curl);
739 if (ret != CURLM_OK)
740 {
741 nlwarning("cURL multi handle %p error %d on '%s'", curl, ret, download->url.c_str());
742 return false;
743 }
744
745 RunningCurls++;
746 return true;
747 }
748
749 void CGroupHTML::finishCurlDownload(CDataDownload *download)
750 {
751 if (download)
752 {
753 download->finish();
754 delete download;
755 }
756 else
757 {
758 nlwarning("Unknown CURL download (nullptr)");
759 }
760 }
761
762 // Add a image download request in the multi_curl
763 // return new textureId and download callback
764 ICurlDownloadCB *CGroupHTML::addTextureDownload(const string &url, sint32 &texId, CViewBase *view)
765 {
766 CViewRenderer &rVR = *CViewRenderer::getInstance();
767 // data:image/png;base64,AA...==
768 if (startsWith(url, "data:image/"))
769 {
770 texId = rVR.createTextureFromDataURL(url);
771 return NULL;
772 }
773
774 std::string finalUrl;
775 // load the image from local files/bnp
776 if (lookupLocalFile(finalUrl, std::string(CFile::getPath(url) + CFile::getFilenameWithoutExtension(url) + ".tga").c_str(), false))
777 {
778 texId = rVR.createTexture(finalUrl);
779 return NULL;
780 }
781
782 finalUrl = upgradeInsecureUrl(getAbsoluteUrl(url));
783
784 // use requested url for local name (cache)
785 string dest = localImageName(url);
786 LOG_DL("add to download '%s' dest '%s'", finalUrl.c_str(), dest.c_str());
787
788 if (CFile::fileExists(dest) && CFile::getFileSize(dest) > 0)
789 texId = rVR.createTexture(dest);
790 else
791 texId = rVR.newTextureId(dest);
792
793 // Search if we are not already downloading this url.
794 for(std::list<CDataDownload*>::iterator it = Curls.begin(); it != Curls.end(); ++it)
795 {
796 if((*it)->url == finalUrl)
797 {
798 LOG_DL("already downloading '%s' img %p", finalUrl.c_str(), img);
799 TextureDownloadCB *cb = dynamic_cast<TextureDownloadCB*>(*it);
800 if (cb)
801 {
802 cb->addTexture(texId, view);
803 // return pointer to shared ImageDownloadCB
804 return cb;
805 }
806 else
807 {
808 nlwarning("Found texture download '%s', but casting to TextureDownloadCB failed", finalUrl.c_str());
809 }
810 }
811 }
812
813 Curls.push_back(new TextureDownloadCB(finalUrl, dest, texId, this));
814 // as we return pointer to callback, skip starting downloads just now
815 //pumpCurlQueue();
816 return Curls.back();
817 }
818
819 // Add a image download request in the multi_curl
820 ICurlDownloadCB *CGroupHTML::addImageDownload(const string &url, CViewBase *img, const CStyleParams &style, TImageType type, const std::string &placeholder)
821 {
822 std::string finalUrl;
823 img->setModulateGlobalColor(style.GlobalColor);
824
825 // data:image/png;base64,AA...==
826 if (startsWith(url, "data:image/"))
827 {
828 setImage(img, decodeURIComponent(url), type);
829 setImageSize(img, style);
830 return NULL;
831 }
832
833 // load the image from local files/bnp
834 std::string image = CFile::getPath(url) + CFile::getFilenameWithoutExtension(url) + ".tga";
835 if (lookupLocalFile(finalUrl, image.c_str(), false))
836 {
837 setImage(img, image, type);
838 setImageSize(img, style);
839 return NULL;
840 }
841
842 finalUrl = upgradeInsecureUrl(getAbsoluteUrl(url));
843
844 // use requested url for local name (cache)
845 string dest = localImageName(url);
846 LOG_DL("add to download '%s' dest '%s' img %p", finalUrl.c_str(), dest.c_str(), img);
847
848 // Display cached image while downloading new
849 if (type != OverImage)
850 {
851 std::string temp = dest;
852 if (!CFile::fileExists(temp) || CFile::getFileSize(temp) == 0)
853 {
854 temp = placeholder;
855 }
856 setImage(img, temp, type);
857 setImageSize(img, style);
858 }
859
860 // Search if we are not already downloading this url.
861 for(std::list<CDataDownload*>::iterator it = Curls.begin(); it != Curls.end(); ++it)
862 {
863 if((*it)->url == finalUrl)
864 {
865 LOG_DL("already downloading '%s' img %p", finalUrl.c_str(), img);
866 ImageDownloadCB *cb = dynamic_cast<ImageDownloadCB*>(*it);
867 if (cb)
868 {
869 cb->addImage(img, style, type);
870 // return pointer to shared ImageDownloadCB
871 return cb;
872 }
873 else
874 {
875 nlwarning("Found image download '%s', but casting to ImageDownloadCB failed", finalUrl.c_str());
876 }
877 }
878 }
879
880 Curls.push_back(new ImageDownloadCB(finalUrl, dest, img, style, type, this));
881 // as we return pointer to callback, skip starting downloads just now
882 //pumpCurlQueue();
883 return Curls.back();
884 }
885
886 void CGroupHTML::removeImageDownload(ICurlDownloadCB *handle, CViewBase *img)
887 {
888 ImageDownloadCB *cb = dynamic_cast<ImageDownloadCB*>(handle);
889 if (!cb) {
890 nlwarning("Trying to remove image from downloads, but ICurlDownloadCB pointer did not cast to ImageDownloadCB");
891 return;
892 }
893 // image will be removed from handle, but handle is kept and image will be downloaded
894 cb->removeImage(img);
895 }
896
897 void CGroupHTML::initImageDownload()
898 {
899 LOG_DL("Init Image Download");
900
901 string pathName = "cache";
902 if ( ! CFile::isExists( pathName ) )
903 CFile::createDirectory( pathName );
904 }
905
906
907 // Get an url and return the local filename with the path where the bnp should be
908 string CGroupHTML::localBnpName(const string &url)
909 {
910 size_t lastIndex = url.find_last_of("/");
911 string dest = "user/"+url.substr(lastIndex+1);
912 return dest;
913 }
914
915 // Add a bnp download request in the multi_curl, return true if already downloaded
916 bool CGroupHTML::addBnpDownload(string url, const string &action, const string &script, const string &md5sum)
917 {
918 url = upgradeInsecureUrl(getAbsoluteUrl(url));
919
920 // Search if we are not already downloading this url.
921 for(std::list<CDataDownload*>::const_iterator it = Curls.begin(); it != Curls.end(); ++it)
922 {
923 if((*it)->url == url)
924 {
925 LOG_DL("already downloading '%s'", url.c_str());
926 return false;
927 }
928 }
929
930 string dest = localBnpName(url);
931 LOG_DL("add to download '%s' dest '%s'", url.c_str(), dest.c_str());
932
933 // create/delete the local file
934 if (NLMISC::CFile::fileExists(dest))
935 {
936 if (action == "override" || action == "delete")
937 {
938 CFile::setRWAccess(dest);
939 NLMISC::CFile::deleteFile(dest);
940 }
941 else
942 {
943 return true;
944 }
945 }
946 if (action != "delete")
947 {
948 Curls.push_back(new BnpDownloadCB(url, dest, md5sum, script, this));
949 pumpCurlQueue();
950 }
951 else
952 return true;
953
954 return false;
955 }
956
957 void CGroupHTML::initBnpDownload()
958 {
959 if (!_TrustedDomain)
960 return;
961
962 LOG_DL("Init Bnp Download");
963 string pathName = "user";
964 if ( ! CFile::isExists( pathName ) )
965 CFile::createDirectory( pathName );
966 }
967
968 void CGroupHTML::addStylesheetDownload(const std::vector<CHtmlParser::StyleLink> links)
969 {
970 for(uint i = 0; i < links.size(); ++i)
971 {
972 _StylesheetQueue.push_back(links[i]);
973 std::string url = getAbsoluteUrl(links[i].Url);
974 _StylesheetQueue.back().Url = url;
975
976 // push to the front of the queue
977 Curls.push_front(new StylesheetDownloadCB(url, localImageName(url), this));
978 }
979 pumpCurlQueue();
980 }
981
982 // Call this evenly to check if an element is downloaded and then manage it
983 void CGroupHTML::checkDownloads()
984 {
985 //nlassert(_CrtCheckMemory());
986
987 if(Curls.empty() && _CurlWWW == NULL)
988 {
989 return;
990 }
991
992 int NewRunningCurls = 0;
993 while(CURLM_CALL_MULTI_PERFORM == curl_multi_perform(MultiCurl, &NewRunningCurls))
994 {
995 LOG_DL("more to do now %d - %d curls", NewRunningCurls, Curls.size());
996 }
997
998 LOG_DL("NewRunningCurls:%d, RunningCurls:%d", NewRunningCurls, RunningCurls);
999
1000 // check which downloads are done
1001 CURLMsg *msg;
1002 int msgs_left;
1003 while ((msg = curl_multi_info_read(MultiCurl, &msgs_left)))
1004 {
1005 LOG_DL("> (%s) msgs_left %d", _Id.c_str(), msgs_left);
1006 if (msg->msg == CURLMSG_DONE)
1007 {
1008 if (_CurlWWW && _CurlWWW->Request && _CurlWWW->Request == msg->easy_handle)
1009 {
1010 std::string error;
1011 bool success = msg->data.result == CURLE_OK;
1012 if (!success)
1013 {
1014 error = curl_easy_strerror(msg->data.result);
1015 }
1016 LOG_DL("html download finished with curl code %d (%s)", (sint)msg->msg, error.c_str());
1017 htmlDownloadFinished(success, error);
1018 }
1019 else
1020 {
1021 for(std::list<CDataDownload*>::iterator it = Curls.begin(); it != Curls.end(); ++it)
1022 {
1023 if((*it)->data && (*it)->data->Request == msg->easy_handle)
1024 {
1025 std::string error;
1026 bool success = msg->data.result == CURLE_OK;
1027 if (!success)
1028 {
1029 error = curl_easy_strerror(msg->data.result);
1030 }
1031 LOG_DL("data download finished with curl code %d (%s)", (sint)msg->msg, error.c_str());
1032 dataDownloadFinished(success, error, *it);
1033
1034 Curls.erase(it);
1035 break;
1036 }
1037 }
1038 }
1039 }
1040 }
1041
1042 RunningCurls = NewRunningCurls;
1043 pumpCurlQueue();
1044 }
1045
1046
1047 void CGroupHTML::releaseDownloads()
1048 {
1049 LOG_DL("Release Downloads");
1050
1051 if (_CurlWWW)
1052 {
1053 LOG_DL("(%s) stop html url '%s'", _Id.c_str(), _CurlWWW->Url.c_str());
1054 if (MultiCurl)
1055 curl_multi_remove_handle(MultiCurl, _CurlWWW->Request);
1056
1057 delete _CurlWWW;
1058 _CurlWWW = NULL;
1059 }
1060
1061 releaseDataDownloads();
1062 }
1063
1064 void CGroupHTML::releaseDataDownloads()
1065 {
1066 LOG_DL("Clear pointers to %d curls", Curls.size());
1067
1068 // remove all queued and already started downloads
1069 for(std::list<CDataDownload*>::iterator it = Curls.begin(); it != Curls.end(); ++it)
1070 {
1071 CDataDownload &dl = *(*it);
1072 if (dl.data)
1073 {
1074 LOG_DL("(%s) stop data url '%s'", _Id.c_str(), dl.url.c_str());
1075 if (MultiCurl)
1076 {
1077 curl_multi_remove_handle(MultiCurl, dl.data->Request);
1078 }
1079
1080 // close and remove temp file
1081 if (dl.fp)
1082 {
1083 fclose(dl.fp);
1084
1085 if (CFile::fileExists(dl.tmpdest))
1086 {
1087 CFile::deleteFile(dl.tmpdest);
1088 }
1089 }
1090 }
1091 // release CDataDownload
1092 delete *it;
1093 }
1094 Curls.clear();
1095
1096 // also clear css queue as it depends on Curls
1097 _StylesheetQueue.clear();
1098 }
1099
1100 class CGroupListAdaptor : public CInterfaceGroup
1101 {
1102 public:
1103 CGroupListAdaptor(const TCtorParam &param)
1104 : CInterfaceGroup(param)
1105 {}
1106
1107 private:
1108 void updateCoords()
1109 {
1110 if (_Parent)
1111 {
1112 // Get the W max from the parent
1113 _W = std::min(_Parent->getMaxWReal(), _Parent->getWReal());
1114 _WReal = _W;
1115 }
1116 CInterfaceGroup::updateCoords();
1117 }
1118 };
1119
1120 // ***************************************************************************
1121
1122 template<class A> void popIfNotEmpty(A &vect) { if(!vect.empty()) vect.pop_back(); }
1123
1124 // ***************************************************************************
1125 TStyle CGroupHTML::parseStyle (const string &str_styles)
1126 {
1127 TStyle styles;
1128 vector<string> elements;
1129 NLMISC::splitString(str_styles, ";", elements);
1130
1131 for(uint i = 0; i < elements.size(); ++i)
1132 {
1133 vector<string> style;
1134 NLMISC::splitString(elements[i], ":", style);
1135 if (style.size() >= 2)
1136 {
1137 string fullstyle = style[1];
1138 for (uint j=2; j < style.size(); j++)
1139 fullstyle += ":"+style[j];
1140 styles[trim(style[0])] = trimSeparators(fullstyle);
1141 }
1142 }
1143
1144 return styles;
1145 }
1146
1147 // ***************************************************************************
1148
1149 void CGroupHTML::addText (const char *buf, int len)
1150 {
1151 if (_Browsing)
1152 {
1153 if (_IgnoreText)
1154 return;
1155
1156 // Build a UTF8 string
1157 if (_ParsingLua && _TrustedDomain)
1158 {
1159 // we are parsing a lua script
1160 _LuaScript += string(buf, buf + len);
1161 // no more to do
1162 return;
1163 }
1164
1165 // Build a unicode string
1166 CUtfStringView inputStringView(buf, len);
1167
1168 // Build the final unicode string
1169 string tmp;
1170 tmp.reserve(len);
1171 u32char lastChar = 0;
1172 u32char inputStringView0 = *inputStringView.begin();
1173 for (CUtfStringView::iterator it(inputStringView.begin()), end(inputStringView.end()); it != end; ++it)
1174 {
1175 u32char output;
1176 bool keep;
1177 // special treatment for 'nbsp' (which is returned as a discreet space)
1178 if (len == 1 && inputStringView0 == 32)
1179 {
1180 // this is a nbsp entity
1181 output = *it;
1182 keep = true;
1183 }
1184 else
1185 {
1186 // not nbsp, use normal white space removal routine
1187 keep = translateChar (output, *it, lastChar);
1188 }
1189
1190 if (keep)
1191 {
1192 CUtfStringView::append(tmp, output);
1193 lastChar = output;
1194 }
1195 }
1196
1197 if (!tmp.empty())
1198 addString(tmp);
1199 }
1200 }
1201
1202 // ***************************************************************************
1203
1204 #define registerAnchorName(prefix) \
1205 {\
1206 if (present[prefix##_ID] && value[prefix##_ID]) \
1207 _AnchorName.push_back(value[prefix##_ID]); \
1208 }
1209
1210 // ***************************************************************************
1211 void CGroupHTML::beginElement (CHtmlElement &elm)
1212 {
1213 _Style.pushStyle();
1214 _CurrentHTMLElement = &elm;
1215 _CurrentHTMLNextSibling = elm.nextSibling;
1216
1217 // set element style from css and style attribute
1218 _Style.getStyleFor(elm);
1219 if (!elm.Style.empty())
1220 {
1221 _Style.applyStyle(elm.Style);
1222 }
1223
1224 if (elm.hasNonEmptyAttribute("name"))
1225 {
1226 _AnchorName.push_back(elm.getAttribute("name"));
1227 }
1228 if (elm.hasNonEmptyAttribute("id"))
1229 {
1230 _AnchorName.push_back(elm.getAttribute("id"));
1231 }
1232
1233 if (_Style.Current.DisplayBlock)
1234 {
1235 endParagraph();
1236 }
1237
1238 switch(elm.ID)
1239 {
1240 case HTML_A: htmlA(elm); break;
1241 case HTML_BASE: htmlBASE(elm); break;
1242 case HTML_BODY: htmlBODY(elm); break;
1243 case HTML_BR: htmlBR(elm); break;
1244 case HTML_BUTTON: htmlBUTTON(elm); break;
1245 case HTML_DD: htmlDD(elm); break;
1246 case HTML_DEL: renderPseudoElement(":before", elm); break;
1247 case HTML_DIV: htmlDIV(elm); break;
1248 case HTML_DL: htmlDL(elm); break;
1249 case HTML_DT: htmlDT(elm); break;
1250 case HTML_EM: renderPseudoElement(":before", elm); break;
1251 case HTML_FONT: htmlFONT(elm); break;
1252 case HTML_FORM: htmlFORM(elm); break;
1253 case HTML_H1://no-break
1254 case HTML_H2://no-break
1255 case HTML_H3://no-break
1256 case HTML_H4://no-break
1257 case HTML_H5://no-break
1258 case HTML_H6: htmlH(elm); break;
1259 case HTML_HEAD: htmlHEAD(elm); break;
1260 case HTML_HR: htmlHR(elm); break;
1261 case HTML_HTML: htmlHTML(elm); break;
1262 case HTML_I: htmlI(elm); break;
1263 case HTML_IMG: htmlIMG(elm); break;
1264 case HTML_INPUT: htmlINPUT(elm); break;
1265 case HTML_LI: htmlLI(elm); break;
1266 case HTML_LUA: htmlLUA(elm); break;
1267 case HTML_META: htmlMETA(elm); break;
1268 case HTML_METER: htmlMETER(elm); break;
1269 case HTML_OBJECT: htmlOBJECT(elm); break;
1270 case HTML_OL: htmlOL(elm); break;
1271 case HTML_OPTION: htmlOPTION(elm); break;
1272 case HTML_P: htmlP(elm); break;
1273 case HTML_PRE: htmlPRE(elm); break;
1274 case HTML_PROGRESS: htmlPROGRESS(elm); break;
1275 case HTML_SCRIPT: htmlSCRIPT(elm); break;
1276 case HTML_SELECT: htmlSELECT(elm); break;
1277 case HTML_SMALL: renderPseudoElement(":before", elm); break;
1278 case HTML_SPAN: renderPseudoElement(":before", elm); break;
1279 case HTML_STRONG: renderPseudoElement(":before", elm); break;
1280 case HTML_STYLE: htmlSTYLE(elm); break;
1281 case HTML_TABLE: htmlTABLE(elm); break;
1282 case HTML_TBODY: renderPseudoElement(":before", elm); break;
1283 case HTML_TD: htmlTD(elm); break;
1284 case HTML_TEXTAREA: htmlTEXTAREA(elm); break;
1285 case HTML_TFOOT: renderPseudoElement(":before", elm); break;
1286 case HTML_TH: htmlTH(elm); break;
1287 case HTML_TITLE: htmlTITLE(elm); break;
1288 case HTML_TR: htmlTR(elm); break;
1289 case HTML_U: renderPseudoElement(":before", elm); break;
1290 case HTML_UL: htmlUL(elm); break;
1291 default:
1292 renderPseudoElement(":before", elm);
1293 break;
1294 }
1295 }
1296
1297 // ***************************************************************************
1298 void CGroupHTML::endElement(CHtmlElement &elm)
1299 {
1300 _CurrentHTMLElement = &elm;
1301
1302 switch(elm.ID)
1303 {
1304 case HTML_A: htmlAend(elm); break;
1305 case HTML_BASE: break;
1306 case HTML_BODY: renderPseudoElement(":after", elm); break;
1307 case HTML_BR: break;
1308 case HTML_BUTTON: htmlBUTTONend(elm); break;
1309 case HTML_DD: htmlDDend(elm); break;
1310 case HTML_DEL: renderPseudoElement(":after", elm); break;
1311 case HTML_DIV: htmlDIVend(elm); break;
1312 case HTML_DL: htmlDLend(elm); break;
1313 case HTML_DT: htmlDTend(elm); break;
1314 case HTML_EM: renderPseudoElement(":after", elm);break;
1315 case HTML_FONT: break;
1316 case HTML_FORM: htmlFORMend(elm); break;
1317 case HTML_H1://no-break
1318 case HTML_H2://no-break
1319 case HTML_H3://no-break
1320 case HTML_H4://no-break
1321 case HTML_H5://no-break
1322 case HTML_H6: htmlHend(elm); break;
1323 case HTML_HEAD: htmlHEADend(elm); break;
1324 case HTML_HR: break;
1325 case HTML_HTML: break;
1326 case HTML_I: htmlIend(elm); break;
1327 case HTML_IMG: break;
1328 case HTML_INPUT: break;
1329 case HTML_LI: htmlLIend(elm); break;
1330 case HTML_LUA: htmlLUAend(elm); break;
1331 case HTML_META: break;
1332 case HTML_METER: break;
1333 case HTML_OBJECT: htmlOBJECTend(elm); break;
1334 case HTML_OL: htmlOLend(elm); break;
1335 case HTML_OPTION: htmlOPTIONend(elm); break;
1336 case HTML_P: htmlPend(elm); break;
1337 case HTML_PRE: htmlPREend(elm); break;
1338 case HTML_SCRIPT: htmlSCRIPTend(elm); break;
1339 case HTML_SELECT: htmlSELECTend(elm); break;
1340 case HTML_SMALL: renderPseudoElement(":after", elm);break;
1341 case HTML_SPAN: renderPseudoElement(":after", elm);break;
1342 case HTML_STRONG: renderPseudoElement(":after", elm);break;
1343 case HTML_STYLE: htmlSTYLEend(elm); break;
1344 case HTML_TABLE: htmlTABLEend(elm); break;
1345 case HTML_TD: htmlTDend(elm); break;
1346 case HTML_TBODY: renderPseudoElement(":after", elm); break;
1347 case HTML_TEXTAREA: break;
1348 case HTML_TFOOT: renderPseudoElement(":after", elm); break;
1349 case HTML_TH: htmlTHend(elm); break;
1350 case HTML_TITLE: break;
1351 case HTML_TR: htmlTRend(elm); break;
1352 case HTML_U: renderPseudoElement(":after", elm); break;
1353 case HTML_UL: htmlULend(elm); break;
1354 default:
1355 renderPseudoElement(":after", elm);
1356 break;
1357 }
1358
1359 if (_Style.Current.DisplayBlock)
1360 {
1361 endParagraph();
1362 }
1363
1364 _Style.popStyle();
1365 }
1366
1367 // ***************************************************************************
1368 void CGroupHTML::renderPseudoElement(const std::string &pseudo, const CHtmlElement &elm)
1369 {
1370 if (pseudo != ":before" && pseudo != ":after")
1371 return;
1372
1373 if (!elm.hasPseudo(pseudo))
1374 return;
1375
1376 _Style.pushStyle();
1377 _Style.applyStyle(elm.getPseudo(pseudo));
1378
1379 // TODO: 'content' should already be tokenized in css parser as it has all the functions for that
1380 std::string content = trim(_Style.getStyle("content"));
1381 if (toLowerAscii(content) == "none" || toLowerAscii(content) == "normal")
1382 {
1383 _Style.popStyle();
1384 return;
1385 }
1386
1387 std::string::size_type pos = 0;
1388 // TODO: tokenize by whitespace
1389 while(pos < content.size())
1390 {
1391 std::string::size_type start;
1392 std::string token;
1393
1394 // not supported
1395 // counter, open-quote, close-quote, no-open-quote, no-close-quote
1396 if (content[pos] == '"' || content[pos] == '\'')
1397 {
1398 char quote = content[pos];
1399 pos++;
1400 start = pos;
1401 while(pos < content.size() && content[pos] != quote)
1402 {
1403 if (content[pos] == '\\') pos++;
1404 pos++;
1405 }
1406 token = content.substr(start, pos - start);
1407 addString(token);
1408
1409 // skip closing quote
1410 pos++;
1411 }
1412 else if (content[pos] == 'u' && pos < content.size() - 6 && toLowerAscii(content.substr(pos, 4)) == "url(")
1413 {
1414 // url(/path-to/image.jpg) / "Alt!"
1415 // url("/path to/image.jpg") / "Alt!"
1416 std::string tooltip;
1417
1418 start = pos + 4;
1419 // fails if url contains ')'
1420 pos = content.find(")", start);
1421 if (pos == std::string::npos)
1422 break;
1423
1424 token = trim(content.substr(start, pos - start));
1425 // skip ')'
1426 pos++;
1427
1428 // scan for tooltip
1429 start = pos;
1430 while(pos < content.size() && content[pos] == ' ' && content[pos] != '/')
1431 {
1432 pos++;
1433 }
1434 if (pos < content.size() && content[pos] == '/')
1435 {
1436 // skip '/'
1437 pos++;
1438
1439 // skip whitespace
1440 while(pos < content.size() && content[pos] == ' ')
1441 {
1442 pos++;
1443 }
1444 if (pos < content.size() && (content[pos] == '\'' || content[pos] == '"'))
1445 {
1446 char openQuote = content[pos];
1447 pos++;
1448 start = pos;
1449 while(pos < content.size() && content[pos] != openQuote)
1450 {
1451 if (content[pos] == '\\') pos++;
1452 pos++;
1453 }
1454 tooltip = content.substr(start, pos - start);
1455
1456 // skip closing quote
1457 pos++;
1458 }
1459 else
1460 {
1461 // tooltip should be quoted
1462 pos = start;
1463 tooltip.clear();
1464 }
1465 }
1466 else
1467 {
1468 // no tooltip
1469 pos = start;
1470 }
1471
1472 if (tooltip.empty())
1473 {
1474 addImage(getId() + pseudo, token, false, _Style.Current);
1475 }
1476 else
1477 {
1478 tooltip = trimQuotes(tooltip);
1479 addButton(CCtrlButton::PushButton, getId() + pseudo, token, token, "", "", "", tooltip.c_str(), _Style.Current);
1480 }
1481 }
1482 else if (content[pos] == 'a' && pos < content.size() - 7)
1483 {
1484 // attr(title)
1485 start = pos + 5;
1486 std::string::size_type end = 0;
1487 end = content.find(")", start);
1488 if (end != std::string::npos)
1489 {
1490 token = content.substr(start, end - start);
1491 // skip ')'
1492 pos = end + 1;
1493 if (elm.hasAttribute(token))
1494 {
1495 addString(elm.getAttribute(token));
1496 }
1497 }
1498 else
1499 {
1500 // skip over 'a'
1501 pos++;
1502 }
1503 }
1504 else
1505 {
1506 pos++;
1507 }
1508 }
1509
1510 _Style.popStyle();
1511 }
1512
1513 // ***************************************************************************
1514 void CGroupHTML::renderDOM(CHtmlElement &elm)
1515 {
1516 if (elm.Type == CHtmlElement::TEXT_NODE)
1517 {
1518 addText(elm.Value.c_str(), elm.Value.size());
1519 }
1520 else
1521 {
1522 beginElement(elm);
1523
1524 if (!_IgnoreChildElements)
1525 {
1526 std::list<CHtmlElement>::iterator it = elm.Children.begin();
1527 while(it != elm.Children.end())
1528 {
1529 renderDOM(*it);
1530
1531 ++it;
1532 }
1533 }
1534 _IgnoreChildElements = false;
1535
1536 endElement(elm);
1537 }
1538 }
1539
1540 // ***************************************************************************
1541 NLMISC_REGISTER_OBJECT(CViewBase, CGroupHTML, std::string, "html");
1542
1543
1544 // ***************************************************************************
1545 uint32 CGroupHTML::_GroupHtmlUIDPool= 0;
1546 CGroupHTML::TGroupHtmlByUIDMap CGroupHTML::_GroupHtmlByUID;
1547
1548
1549 // ***************************************************************************
1550 CGroupHTML::CGroupHTML(const TCtorParam &param)
1551 : CGroupScrollText(param),
1552 _TimeoutValue(DEFAULT_RYZOM_CONNECTION_TIMEOUT),
1553 _RedirectsRemaining(DEFAULT_RYZOM_REDIRECT_LIMIT),
1554 _CurrentHTMLElement(NULL)
1555 {
1556 // add it to map of group html created
1557 _GroupHtmlUID= ++_GroupHtmlUIDPool; // valid assigned Id begin to 1!
1558 _GroupHtmlByUID[_GroupHtmlUID]= this;
1559
1560 // init
1561 _TrustedDomain = false;
1562 _ParsingLua = false;
1563 _LuaHrefHack = false;
1564 _IgnoreText = false;
1565 _IgnoreChildElements = false;
1566 _BrowseNextTime = false;
1567 _PostNextTime = false;
1568 _Browsing = false;
1569 _CurrentViewLink = NULL;
1570 _CurrentViewImage = NULL;
1571 _Indent.clear();
1572 _LI = false;
1573 _SelectOption = false;
1574 _GroupListAdaptor = NULL;
1575 _UrlFragment.clear();
1576 _RefreshUrl.clear();
1577 _NextRefreshTime = 0.0;
1578 _LastRefreshTime = 0.0;
1579 _RenderNextTime = false;
1580 _WaitingForStylesheet = false;
1581 _AutoIdSeq = 0;
1582 _FormOpen = false;
1583
1584 // Register
1585 CWidgetManager::getInstance()->registerClockMsgTarget(this);
1586
1587 // HTML parameters
1588 ErrorColor = CRGBA(255, 0, 0);
1589 LinkColor = CRGBA(0, 0, 255);
1590 ErrorColorGlobalColor = false;
1591 LinkColorGlobalColor = false;
1592 TextColorGlobalColor = false;
1593 LIBeginSpace = 4;
1594 ULBeginSpace = 12;
1595 PBeginSpace = 12;
1596 TDBeginSpace = 0;
1597 ULIndent = 30;
1598 LineSpaceFontFactor = 0.5f;
1599 DefaultButtonGroup = "html_text_button";
1600 DefaultFormTextGroup = "edit_box_widget";
1601 DefaultFormTextAreaGroup = "edit_box_widget_multiline";
1602 DefaultFormSelectGroup = "html_form_select_widget";
1603 DefaultFormSelectBoxMenuGroup = "html_form_select_box_menu_widget";
1604 DefaultCheckBoxBitmapNormal = "checkbox_normal.tga";
1605 DefaultCheckBoxBitmapPushed = "checkbox_pushed.tga";
1606 DefaultCheckBoxBitmapOver = "checkbox_over.tga";
1607 DefaultRadioButtonBitmapNormal = "w_radiobutton.png";
1608 DefaultRadioButtonBitmapPushed = "w_radiobutton_pushed.png";
1609 DefaultBackgroundBitmapView = "bg";
1610 clearContext();
1611
1612 MultiCurl = curl_multi_init();
1613 #ifdef CURLMOPT_MAX_HOST_CONNECTIONS
1614 if (MultiCurl)
1615 {
1616 // added in libcurl 7.30.0
1617 curl_multi_setopt(MultiCurl, CURLMOPT_MAX_HOST_CONNECTIONS, options.curlMaxConnections);
1618 curl_multi_setopt(MultiCurl, CURLMOPT_PIPELINING, 1);
1619 }
1620 #endif
1621 RunningCurls = 0;
1622 _CurlWWW = NULL;
1623
1624 initImageDownload();
1625 initBnpDownload();
1626
1627 // setup default browser style
1628 setProperty("browser_css_file", "browser.css");
1629 }
1630
1631 // ***************************************************************************
1632
1633 CGroupHTML::~CGroupHTML()
1634 {
1635 //releaseImageDownload();
1636
1637 // TestYoyo
1638 //nlinfo("** CGroupHTML Destroy: %x, %s, uid%d", this, _Id.c_str(), _GroupHtmlUID);
1639
1640 /* Erase from map of Group HTML (thus requestTerminated() callback won't be called)
1641 Do it first, just because don't want requestTerminated() to be called while I'm destroying
1642 (useless and may be dangerous)
1643 */
1644 _GroupHtmlByUID.erase(_GroupHtmlUID);
1645
1646 clearContext();
1647 releaseDownloads();
1648
1649 if (_CurlWWW)
1650 delete _CurlWWW;
1651
1652 if(MultiCurl)
1653 curl_multi_cleanup(MultiCurl);
1654 }
1655
1656 std::string CGroupHTML::getProperty( const std::string &name ) const
1657 {
1658 if( name == "url" )
1659 {
1660 return _URL;
1661 }
1662 else
1663 if( name == "title_prefix" )
1664 {
1665 return _TitlePrefix;
1666 }
1667 else
1668 if( name == "error_color" )
1669 {
1670 return toString( ErrorColor );
1671 }
1672 else
1673 if( name == "link_color" )
1674 {
1675 return toString( LinkColor );
1676 }
1677 else
1678 if( name == "error_color_global_color" )
1679 {
1680 return toString( ErrorColorGlobalColor );
1681 }
1682 else
1683 if( name == "link_color_global_color" )
1684 {
1685 return toString( LinkColorGlobalColor );
1686 }
1687 else
1688 if( name == "text_color_global_color" )
1689 {
1690 return toString( TextColorGlobalColor );
1691 }
1692 else
1693 if( name == "td_begin_space" )
1694 {
1695 return toString( TDBeginSpace );
1696 }
1697 else
1698 if( name == "paragraph_begin_space" )
1699 {
1700 return toString( PBeginSpace );
1701 }
1702 else
1703 if( name == "li_begin_space" )
1704 {
1705 return toString( LIBeginSpace );
1706 }
1707 else
1708 if( name == "ul_begin_space" )
1709 {
1710 return toString( ULBeginSpace );
1711 }
1712 else
1713 if( name == "ul_indent" )
1714 {
1715 return toString( ULIndent );
1716 }
1717 else
1718 if( name == "multi_line_space_factor" )
1719 {
1720 return toString( LineSpaceFontFactor );
1721 }
1722 else
1723 if( name == "form_text_area_group" )
1724 {
1725 return DefaultFormTextGroup;
1726 }
1727 else
1728 if( name == "form_select_group" )
1729 {
1730 return DefaultFormSelectGroup;
1731 }
1732 else
1733 if( name == "checkbox_bitmap_normal" )
1734 {
1735 return DefaultCheckBoxBitmapNormal;
1736 }
1737 else
1738 if( name == "checkbox_bitmap_pushed" )
1739 {
1740 return DefaultCheckBoxBitmapPushed;
1741 }
1742 else
1743 if( name == "checkbox_bitmap_over" )
1744 {
1745 return DefaultCheckBoxBitmapOver;
1746 }
1747 else
1748 if( name == "radiobutton_bitmap_normal" )
1749 {
1750 return DefaultRadioButtonBitmapNormal;
1751 }
1752 else
1753 if( name == "radiobutton_bitmap_pushed" )
1754 {
1755 return DefaultRadioButtonBitmapPushed;
1756 }
1757 else
1758 if( name == "radiobutton_bitmap_over" )
1759 {
1760 return DefaultRadioButtonBitmapOver;
1761 }
1762 else
1763 if( name == "background_bitmap_view" )
1764 {
1765 return DefaultBackgroundBitmapView;
1766 }
1767 else
1768 if( name == "home" )
1769 {
1770 return Home;
1771 }
1772 else
1773 if( name == "browse_next_time" )
1774 {
1775 return toString( _BrowseNextTime );
1776 }
1777 else
1778 if( name == "browse_tree" )
1779 {
1780 return _BrowseTree;
1781 }
1782 else
1783 if( name == "browse_undo" )
1784 {
1785 return _BrowseUndoButton;
1786 }
1787 else
1788 if( name == "browse_redo" )
1789 {
1790 return _BrowseRedoButton;
1791 }
1792 else
1793 if( name == "browse_refresh" )
1794 {
1795 return _BrowseRefreshButton;
1796 }
1797 else
1798 if( name == "timeout" )
1799 {
1800 return toString( _TimeoutValue );
1801 }
1802 else
1803 if( name == "browser_css_file" )
1804 {
1805 return _BrowserCssFile;
1806 }
1807 else
1808 return CGroupScrollText::getProperty( name );
1809 }
1810
1811 void CGroupHTML::setProperty( const std::string &name, const std::string &value )
1812 {
1813 if( name == "url" )
1814 {
1815 _URL = value;
1816 return;
1817 }
1818 else
1819 if( name == "title_prefix" )
1820 {
1821 _TitlePrefix = value;
1822 return;
1823 }
1824 else
1825 if( name == "error_color" )
1826 {
1827 CRGBA c;
1828 if( fromString( value, c ) )
1829 ErrorColor = c;
1830 return;
1831 }
1832 else
1833 if( name == "link_color" )
1834 {
1835 CRGBA c;
1836 if( fromString( value, c ) )
1837 LinkColor = c;
1838 return;
1839 }
1840 else
1841 if( name == "error_color_global_color" )
1842 {
1843 bool b;
1844 if( fromString( value, b ) )
1845 ErrorColorGlobalColor = b;
1846 return;
1847 }
1848 else
1849 if( name == "link_color_global_color" )
1850 {
1851 bool b;
1852 if( fromString( value, b ) )
1853 LinkColorGlobalColor = b;
1854 return;
1855 }
1856 else
1857 if( name == "text_color_global_color" )
1858 {
1859 bool b;
1860 if( fromString( value, b ) )
1861 TextColorGlobalColor = b;
1862 return;
1863 }
1864 else
1865 if( name == "td_begin_space" )
1866 {
1867 uint i;
1868 if( fromString( value, i ) )
1869 TDBeginSpace = i;
1870 return;
1871 }
1872 else
1873 if( name == "paragraph_begin_space" )
1874 {
1875 uint i;
1876 if( fromString( value, i ) )
1877 PBeginSpace = i;
1878 return;
1879 }
1880 else
1881 if( name == "li_begin_space" )
1882 {
1883 uint i;
1884 if( fromString( value, i ) )
1885 LIBeginSpace = i;
1886 return;
1887 }
1888 else
1889 if( name == "ul_begin_space" )
1890 {
1891 uint i;
1892 if( fromString( value, i ) )
1893 ULBeginSpace = i;
1894 return;
1895 }
1896 else
1897 if( name == "ul_indent" )
1898 {
1899 uint i;
1900 if( fromString( value, i ) )
1901 ULIndent = i;
1902 return;
1903 }
1904 else
1905 if( name == "multi_line_space_factor" )
1906 {
1907 float f;
1908 if( fromString( value, f ) )
1909 LineSpaceFontFactor = f;
1910 return;
1911 }
1912 else
1913 if( name == "form_text_area_group" )
1914 {
1915 DefaultFormTextGroup = value;
1916 return;
1917 }
1918 else
1919 if( name == "form_select_group" )
1920 {
1921 DefaultFormSelectGroup = value;
1922 return;
1923 }
1924 else
1925 if( name == "checkbox_bitmap_normal" )
1926 {
1927 DefaultCheckBoxBitmapNormal = value;
1928 return;
1929 }
1930 else
1931 if( name == "checkbox_bitmap_pushed" )
1932 {
1933 DefaultCheckBoxBitmapPushed = value;
1934 return;
1935 }
1936 else
1937 if( name == "checkbox_bitmap_over" )
1938 {
1939 DefaultCheckBoxBitmapOver = value;
1940 return;
1941 }
1942 else
1943 if( name == "radiobutton_bitmap_normal" )
1944 {
1945 DefaultRadioButtonBitmapNormal = value;
1946 return;
1947 }
1948 else
1949 if( name == "radiobutton_bitmap_pushed" )
1950 {
1951 DefaultRadioButtonBitmapPushed = value;
1952 return;
1953 }
1954 else
1955 if( name == "radiobutton_bitmap_over" )
1956 {
1957 DefaultRadioButtonBitmapOver = value;
1958 return;
1959 }
1960 else
1961 if( name == "background_bitmap_view" )
1962 {
1963 DefaultBackgroundBitmapView = value;
1964 return;
1965 }
1966 else
1967 if( name == "home" )
1968 {
1969 Home = value;
1970 return;
1971 }
1972 else
1973 if( name == "browse_next_time" )
1974 {
1975 bool b;
1976 if( fromString( value, b ) )
1977 _BrowseNextTime = b;
1978 return;
1979 }
1980 else
1981 if( name == "browse_tree" )
1982 {
1983 _BrowseTree = value;
1984 return;
1985 }
1986 else
1987 if( name == "browse_undo" )
1988 {
1989 _BrowseUndoButton = value;
1990 return;
1991 }
1992 else
1993 if( name == "browse_redo" )
1994 {
1995 _BrowseRedoButton = value;
1996 return;
1997 }
1998 else
1999 if( name == "browse_refresh" )
2000 {
2001 _BrowseRefreshButton = value;
2002 return;
2003 }
2004 else
2005 if( name == "timeout" )
2006 {
2007 double d;
2008 if( fromString( value, d ) )
2009 _TimeoutValue = d;
2010 return;
2011 }
2012 else
2013 if( name == "browser_css_file")
2014 {
2015 _BrowserStyle.reset();
2016 _BrowserCssFile = value;
2017 if (!_BrowserCssFile.empty())
2018 {
2019 std::string filename = CPath::lookup(_BrowserCssFile, false, true, true);
2020 if (!filename.empty())
2021 {
2022 CIFile in;
2023 if (in.open(filename))
2024 {
2025 std::string css;
2026 if (in.readAll(css))
2027 _BrowserStyle.parseStylesheet(css);
2028 else
2029 nlwarning("Failed to read browser css from '%s'", filename.c_str());
2030 }
2031 else
2032 {
2033 nlwarning("Failed to open browser css file '%s'", filename.c_str());
2034 }
2035 }
2036 else
2037 {
2038 nlwarning("Browser css file '%s' not found", _BrowserCssFile.c_str());
2039 }
2040 }
2041 }
2042 else
2043 CGroupScrollText::setProperty( name, value );
2044 }
2045
2046 xmlNodePtr CGroupHTML::serialize( xmlNodePtr parentNode, const char *type ) const
2047 {
2048 xmlNodePtr node = CGroupScrollText::serialize( parentNode, type );
2049 if( node == NULL )
2050 return NULL;
2051
2052 xmlSetProp( node, BAD_CAST "type", BAD_CAST "html" );
2053 xmlSetProp( node, BAD_CAST "url", BAD_CAST _URL.c_str() );
2054 xmlSetProp( node, BAD_CAST "title_prefix", BAD_CAST _TitlePrefix.c_str() );
2055 xmlSetProp( node, BAD_CAST "error_color", BAD_CAST toString( ErrorColor ).c_str() );
2056 xmlSetProp( node, BAD_CAST "link_color", BAD_CAST toString( LinkColor ).c_str() );
2057
2058 xmlSetProp( node, BAD_CAST "error_color_global_color",
2059 BAD_CAST toString( ErrorColorGlobalColor ).c_str() );
2060 xmlSetProp( node, BAD_CAST "link_color_global_color",
2061 BAD_CAST toString( LinkColorGlobalColor ).c_str() );
2062 xmlSetProp( node, BAD_CAST "text_color_global_color",
2063 BAD_CAST toString( TextColorGlobalColor ).c_str() );
2064
2065 xmlSetProp( node, BAD_CAST "td_begin_space", BAD_CAST toString( TDBeginSpace ).c_str() );
2066 xmlSetProp( node, BAD_CAST "paragraph_begin_space", BAD_CAST toString( PBeginSpace ).c_str() );
2067 xmlSetProp( node, BAD_CAST "li_begin_space", BAD_CAST toString( LIBeginSpace ).c_str() );
2068 xmlSetProp( node, BAD_CAST "ul_begin_space", BAD_CAST toString( ULBeginSpace ).c_str() );
2069 xmlSetProp( node, BAD_CAST "ul_indent", BAD_CAST toString( ULIndent ).c_str() );
2070 xmlSetProp( node, BAD_CAST "multi_line_space_factor", BAD_CAST toString( LineSpaceFontFactor ).c_str() );
2071 xmlSetProp( node, BAD_CAST "form_text_area_group", BAD_CAST DefaultFormTextGroup.c_str() );
2072 xmlSetProp( node, BAD_CAST "form_select_group", BAD_CAST DefaultFormSelectGroup.c_str() );
2073 xmlSetProp( node, BAD_CAST "checkbox_bitmap_normal", BAD_CAST DefaultCheckBoxBitmapNormal.c_str() );
2074 xmlSetProp( node, BAD_CAST "checkbox_bitmap_pushed", BAD_CAST DefaultCheckBoxBitmapPushed.c_str() );
2075 xmlSetProp( node, BAD_CAST "checkbox_bitmap_over", BAD_CAST DefaultCheckBoxBitmapOver.c_str() );
2076 xmlSetProp( node, BAD_CAST "radiobutton_bitmap_normal", BAD_CAST DefaultRadioButtonBitmapNormal.c_str() );
2077 xmlSetProp( node, BAD_CAST "radiobutton_bitmap_pushed", BAD_CAST DefaultRadioButtonBitmapPushed.c_str() );
2078 xmlSetProp( node, BAD_CAST "radiobutton_bitmap_over", BAD_CAST DefaultRadioButtonBitmapOver.c_str() );
2079 xmlSetProp( node, BAD_CAST "background_bitmap_view", BAD_CAST DefaultBackgroundBitmapView.c_str() );
2080 xmlSetProp( node, BAD_CAST "home", BAD_CAST Home.c_str() );
2081 xmlSetProp( node, BAD_CAST "browse_next_time", BAD_CAST toString( _BrowseNextTime ).c_str() );
2082 xmlSetProp( node, BAD_CAST "browse_tree", BAD_CAST _BrowseTree.c_str() );
2083 xmlSetProp( node, BAD_CAST "browse_undo", BAD_CAST _BrowseUndoButton.c_str() );
2084 xmlSetProp( node, BAD_CAST "browse_redo", BAD_CAST _BrowseRedoButton.c_str() );
2085 xmlSetProp( node, BAD_CAST "browse_refresh", BAD_CAST _BrowseRefreshButton.c_str() );
2086 xmlSetProp( node, BAD_CAST "timeout", BAD_CAST toString( _TimeoutValue ).c_str() );
2087 xmlSetProp( node, BAD_CAST "browser_css_file", BAD_CAST _BrowserCssFile.c_str() );
2088
2089 return node;
2090 }
2091
2092 // ***************************************************************************
2093
2094 bool CGroupHTML::parse(xmlNodePtr cur,CInterfaceGroup *parentGroup)
2095 {
2096 nlassert( CWidgetManager::getInstance()->isClockMsgTarget(this));
2097
2098
2099 if(!CGroupScrollText::parse(cur, parentGroup))
2100 return false;
2101
2102 // TestYoyo
2103 //nlinfo("** CGroupHTML parsed Ok: %x, %s, %s, uid%d", this, _Id.c_str(), typeid(this).name(), _GroupHtmlUID);
2104
2105 CXMLAutoPtr ptr;
2106
2107 // Get the url
2108 ptr = xmlGetProp (cur, (xmlChar*)"url");
2109 if (ptr)
2110 _URL = (const char*)ptr;
2111
2112 // Bkup default for undo/redo
2113 _AskedUrl= _URL;
2114
2115 ptr = xmlGetProp (cur, (xmlChar*)"title_prefix");
2116 if (ptr)
2117 _TitlePrefix = CI18N::get((const char*)ptr);
2118
2119 // Parameters
2120 ptr = xmlGetProp (cur, (xmlChar*)"error_color");
2121 if (ptr)
2122 ErrorColor = convertColor(ptr);
2123 ptr = xmlGetProp (cur, (xmlChar*)"link_color");
2124 if (ptr)
2125 LinkColor = convertColor(ptr);
2126 ptr = xmlGetProp (cur, (xmlChar*)"error_color_global_color");
2127 if (ptr)
2128 ErrorColorGlobalColor = convertBool(ptr);
2129 ptr = xmlGetProp (cur, (xmlChar*)"link_color_global_color");
2130 if (ptr)
2131 LinkColorGlobalColor = convertBool(ptr);
2132 ptr = xmlGetProp (cur, (xmlChar*)"text_color_global_color");
2133 if (ptr)
2134 TextColorGlobalColor = convertBool(ptr);
2135 ptr = xmlGetProp (cur, (xmlChar*)"td_begin_space");
2136 if (ptr)
2137 fromString((const char*)ptr, TDBeginSpace);
2138 ptr = xmlGetProp (cur, (xmlChar*)"paragraph_begin_space");
2139 if (ptr)
2140 fromString((const char*)ptr, PBeginSpace);
2141 ptr = xmlGetProp (cur, (xmlChar*)"li_begin_space");
2142 if (ptr)
2143 fromString((const char*)ptr, LIBeginSpace);
2144 ptr = xmlGetProp (cur, (xmlChar*)"ul_begin_space");
2145 if (ptr)
2146 fromString((const char*)ptr, ULBeginSpace);
2147 ptr = xmlGetProp (cur, (xmlChar*)"ul_indent");
2148 if (ptr)
2149 fromString((const char*)ptr, ULIndent);
2150 ptr = xmlGetProp (cur, (xmlChar*)"multi_line_space_factor");
2151 if (ptr)
2152 fromString((const char*)ptr, LineSpaceFontFactor);
2153 ptr = xmlGetProp (cur, (xmlChar*)"form_text_group");
2154 if (ptr)
2155 DefaultFormTextGroup = (const char*)(ptr);
2156 ptr = xmlGetProp (cur, (xmlChar*)"form_text_area_group");
2157 if (ptr)
2158 DefaultFormTextAreaGroup = (const char*)(ptr);
2159 ptr = xmlGetProp (cur, (xmlChar*)"form_select_group");
2160 if (ptr)
2161 DefaultFormSelectGroup = (const char*)(ptr);
2162 ptr = xmlGetProp (cur, (xmlChar*)"checkbox_bitmap_normal");
2163 if (ptr)
2164 DefaultCheckBoxBitmapNormal = (const char*)(ptr);
2165 ptr = xmlGetProp (cur, (xmlChar*)"checkbox_bitmap_pushed");
2166 if (ptr)
2167 DefaultCheckBoxBitmapPushed = (const char*)(ptr);
2168 ptr = xmlGetProp (cur, (xmlChar*)"checkbox_bitmap_over");
2169 if (ptr)
2170 DefaultCheckBoxBitmapOver = (const char*)(ptr);
2171 ptr = xmlGetProp (cur, (xmlChar*)"radiobutton_bitmap_normal");
2172 if (ptr)
2173 DefaultRadioButtonBitmapNormal = (const char*)(ptr);
2174 ptr = xmlGetProp (cur, (xmlChar*)"radiobutton_bitmap_pushed");
2175 if (ptr)
2176 DefaultRadioButtonBitmapPushed = (const char*)(ptr);
2177 ptr = xmlGetProp (cur, (xmlChar*)"radiobutton_bitmap_over");
2178 if (ptr)
2179 DefaultRadioButtonBitmapOver = (const char*)(ptr);
2180 ptr = xmlGetProp (cur, (xmlChar*)"background_bitmap_view");
2181 if (ptr)
2182 DefaultBackgroundBitmapView = (const char*)(ptr);
2183 ptr = xmlGetProp (cur, (xmlChar*)"home");
2184 if (ptr)
2185 Home = (const char*)(ptr);
2186 ptr = xmlGetProp (cur, (xmlChar*)"browse_next_time");
2187 if (ptr)
2188 _BrowseNextTime = convertBool(ptr);
2189 ptr = xmlGetProp (cur, (xmlChar*)"browse_tree");
2190 if(ptr)
2191 _BrowseTree = (const char*)ptr;
2192 ptr = xmlGetProp (cur, (xmlChar*)"browse_undo");
2193 if(ptr)
2194 _BrowseUndoButton= (const char*)ptr;
2195 ptr = xmlGetProp (cur, (xmlChar*)"browse_redo");
2196 if(ptr)
2197 _BrowseRedoButton = (const char*)ptr;
2198 ptr = xmlGetProp (cur, (xmlChar*)"browse_refresh");
2199 if(ptr)
2200 _BrowseRefreshButton = (const char*)ptr;
2201 ptr = xmlGetProp (cur, (xmlChar*)"timeout");
2202 if(ptr)
2203 fromString((const char*)ptr, _TimeoutValue);
2204
2205 ptr = xmlGetProp (cur, (xmlChar*)"browser_css_file");
2206 if (ptr)
2207 {
2208 setProperty("browser_css_file", (const char *)ptr);
2209 }
2210
2211 return true;
2212 }
2213
2214 // ***************************************************************************
2215
2216 bool CGroupHTML::handleEvent (const NLGUI::CEventDescriptor& eventDesc)
2217 {
2218 bool traited = false;
2219
2220 if (eventDesc.getType() == NLGUI::CEventDescriptor::mouse)
2221 {
2222 const NLGUI::CEventDescriptorMouse &mouseEvent = (const NLGUI::CEventDescriptorMouse &)eventDesc;
2223 if (mouseEvent.getEventTypeExtended() == NLGUI::CEventDescriptorMouse::mousewheel)
2224 {
2225 // Check if mouse wheel event was on any of multiline select box widgets
2226 // Must do this before CGroupScrollText
2227 for (uint i=0; i<_Forms.size() && !traited; i++)
2228 {
2229 for (uint j=0; j<_Forms[i].Entries.size() && !traited; j++)
2230 {
2231 if (_Forms[i].Entries[j].SelectBox)
2232 {
2233 if (_Forms[i].Entries[j].SelectBox->handleEvent(eventDesc))
2234 {
2235 traited = true;
2236 break;
2237 }
2238 }
2239 }
2240 }
2241 }
2242 }
2243
2244 if (!traited)
2245 traited = CGroupScrollText::handleEvent (eventDesc);
2246
2247 if (eventDesc.getType() == NLGUI::CEventDescriptor::system)
2248 {
2249 const NLGUI::CEventDescriptorSystem &systemEvent = (const NLGUI::CEventDescriptorSystem &) eventDesc;
2250 if (systemEvent.getEventTypeExtended() == NLGUI::CEventDescriptorSystem::clocktick)
2251 {
2252 // Handle now
2253 handle ();
2254 }
2255 if (systemEvent.getEventTypeExtended() == NLGUI::CEventDescriptorSystem::activecalledonparent)
2256 {
2257 if (!((NLGUI::CEventDescriptorActiveCalledOnParent &) systemEvent).getActive())
2258 {
2259 // stop refresh when window gets hidden
2260 _NextRefreshTime = 0;
2261 }
2262 }
2263 }
2264 return traited;
2265 }
2266
2267 // ***************************************************************************
2268
2269 void CGroupHTML::endParagraph()
2270 {
2271 _Paragraph = NULL;
2272
2273 paragraphChange ();
2274 }
2275
2276 // ***************************************************************************
2277
2278 void CGroupHTML::newParagraph(uint beginSpace)
2279 {
2280 // Add a new paragraph
2281 CGroupParagraph *newParagraph = new CGroupParagraph(CViewBase::TCtorParam());
2282 newParagraph->setId(getCurrentGroup()->getId() + ":PARAGRAPH" + toString(getNextAutoIdSeq()));
2283 newParagraph->setResizeFromChildH(true);
2284
2285 newParagraph->setMarginLeft(getIndent());
2286 if (!_Style.Current.TextAlign.empty())
2287 {
2288 if (_Style.Current.TextAlign == "left")
2289 newParagraph->setTextAlign(CGroupParagraph::AlignLeft);
2290 else if (_Style.Current.TextAlign == "center")
2291 newParagraph->setTextAlign(CGroupParagraph::AlignCenter);
2292 else if (_Style.Current.TextAlign == "right")
2293 newParagraph->setTextAlign(CGroupParagraph::AlignRight);
2294 else if (_Style.Current.TextAlign == "justify")
2295 newParagraph->setTextAlign(CGroupParagraph::AlignJustify);
2296 }
2297
2298 // Add to the group
2299 addHtmlGroup (newParagraph, beginSpace);
2300 _Paragraph = newParagraph;
2301
2302 paragraphChange ();
2303 }
2304
2305 // ***************************************************************************
2306
2307 void CGroupHTML::browse(const char *url)
2308 {
2309 // modify undo/redo
2310 pushUrlUndoRedo(url);
2311
2312 // do the browse, with no undo/redo
2313 doBrowse(url);
2314 }
2315
2316 // ***************************************************************************
2317 void CGroupHTML::refresh()
2318 {
2319 if (!_URL.empty())
2320 doBrowse(_URL.c_str(), true);
2321 }
2322
2323 // ***************************************************************************
2324 void CGroupHTML::doBrowse(const char *url, bool force)
2325 {
2326 LOG_DL("(%s) Browsing URL : '%s'", _Id.c_str(), url);
2327
2328 CUrlParser uri(url);
2329 if (!uri.hash.empty())
2330 {
2331 // Anchor to scroll after page has loaded
2332 _UrlFragment = uri.hash;
2333
2334 uri.inherit(_DocumentUrl);
2335 uri.hash.clear();
2336
2337 // compare urls and see if we only navigating to new anchor
2338 if (!force && _DocumentUrl == uri.toString())
2339 {
2340 // scroll happens in updateCoords()
2341 invalidateCoords();
2342 return;
2343 }
2344 }
2345 else
2346 _UrlFragment.clear();
2347
2348 // go
2349 _URL = uri.toString();
2350 _BrowseNextTime = true;
2351 _WaitingForStylesheet = false;
2352
2353 // if a BrowseTree is bound to us, try to select the node that opens this URL (auto-locate)
2354 if(!_BrowseTree.empty())
2355 {
2356 CGroupTree *groupTree=dynamic_cast<CGroupTree*>(CWidgetManager::getInstance()->getElementFromId(_BrowseTree));
2357 if(groupTree)
2358 {
2359 string nodeId= selectTreeNodeRecurs(groupTree->getRootNode(), url);
2360 // select the node
2361 if(!nodeId.empty())
2362 {
2363 groupTree->selectNodeById(nodeId);
2364 }
2365 }
2366 }
2367 }
2368
2369 // ***************************************************************************
2370
2371 void CGroupHTML::browseError (const char *msg)
2372 {
2373 releaseDownloads();
2374
2375 // Get the list group from CGroupScrollText
2376 removeContent();
2377 newParagraph(0);
2378 CViewText *viewText = new CViewText ("", (string("Error : ")+msg).c_str());
2379 viewText->setColor (ErrorColor);
2380 viewText->setModulateGlobalColor(ErrorColorGlobalColor);
2381 viewText->setMultiLine (true);
2382 getParagraph()->addChild (viewText);
2383 if(!_TitlePrefix.empty())
2384 setTitle (_TitlePrefix);
2385
2386 updateRefreshButton();
2387 invalidateCoords();
2388 }
2389
2390 void CGroupHTML::browseErrorHtml(const std::string &html)
2391 {
2392 releaseDownloads();
2393 removeContent();
2394
2395 renderHtmlString(html);
2396
2397 updateRefreshButton();
2398 invalidateCoords();
2399 }
2400
2401 // ***************************************************************************
2402
2403 bool CGroupHTML::isBrowsing()
2404 {
2405 // do not show spinning cursor for image downloads (!Curls.empty())
2406 return _BrowseNextTime || _PostNextTime || _RenderNextTime ||
2407 _Browsing || _WaitingForStylesheet ||
2408 _CurlWWW;
2409 }
2410
2411 // ***************************************************************************
2412
2413 void CGroupHTML::updateCoords()
2414 {
2415 CGroupScrollText::updateCoords();
2416
2417 // all elements are in their correct place, tell scrollbar to scroll to anchor
2418 if (!_Browsing && !_UrlFragment.empty())
2419 {
2420 doBrowseAnchor(_UrlFragment);
2421 _UrlFragment.clear();
2422 }
2423
2424 if (!m_HtmlBackground.isEmpty() || !m_BodyBackground.isEmpty())
2425 {
2426 // get scroll offset from list
2427 CGroupList *list = getList();
2428 if (list)
2429 {
2430 CInterfaceElement* vp = list->getParentPos() ? list->getParentPos() : this;
2431 sint htmlW = std::max(vp->getWReal(), list->getWReal());
2432 sint htmlH = list->getHReal();
2433 sint htmlX = list->getXReal() + list->getOfsX();
2434 sint htmlY = list->getYReal() + list->getOfsY();
2435
2436 if (!m_HtmlBackground.isEmpty())
2437 {
2438 m_HtmlBackground.setFillViewport(true);
2439 m_HtmlBackground.setBorderArea(htmlX, htmlY, htmlW, htmlH);
2440 m_HtmlBackground.setPaddingArea(htmlX, htmlY, htmlW, htmlH);
2441 m_HtmlBackground.setContentArea(htmlX, htmlY, htmlW, htmlH);
2442 }
2443
2444 if (!m_BodyBackground.isEmpty())
2445 {
2446 // TODO: html padding + html border
2447 m_BodyBackground.setBorderArea(htmlX, htmlY, htmlW, htmlH);
2448 // TODO: html padding + html border + body border
2449 m_BodyBackground.setPaddingArea(htmlX, htmlY, htmlW, htmlH);
2450 // TODO: html padding + html_border + body padding
2451 m_BodyBackground.setContentArea(htmlX, htmlY, htmlW, htmlH);
2452 }
2453 }
2454 }
2455 }
2456
2457 // ***************************************************************************
2458
2459 bool CGroupHTML::translateChar(u32char &output, u32char input, u32char lastCharParam) const
2460 {
2461 // Keep this char ?
2462 bool keep = true;
2463
2464 // char is between table elements
2465 // TODO: only whitespace is handled, text is added to either TD, or after TABLE (should be before)
2466 bool tableWhitespace = getTable() && (_Cells.empty() || _Cells.back() == NULL);
2467
2468 switch (input)
2469 {
2470 // Return / tab only in <PRE> mode
2471 case '\t':
2472 case '\n':
2473 {
2474 if (tableWhitespace)
2475 {
2476 keep = false;
2477 }
2478 else
2479 {
2480 // Get the last char
2481 u32char lastChar = lastCharParam;
2482 if (lastChar == 0)
2483 lastChar = getLastChar();
2484 keep = ((lastChar != (u32char)' ') &&
2485 (lastChar != 0)) || getPRE() || (_CurrentViewImage && (lastChar == 0));
2486 if(!getPRE())
2487 input = (u32char)' ';
2488 }
2489 }
2490 break;
2491 case ' ':
2492 {
2493 if (tableWhitespace)
2494 {
2495 keep = false;
2496 }
2497 else
2498 {
2499 // Get the last char
2500 u32char lastChar = lastCharParam;
2501 if (lastChar == 0)
2502 lastChar = getLastChar();
2503 keep = ((lastChar != (u32char)' ') &&
2504 (lastChar != (u32char)'\n') &&
2505 (lastChar != 0)) || getPRE() || (_CurrentViewImage && (lastChar == 0));
2506 }
2507 }
2508 break;
2509 case 0xd:
2510 keep = false;
2511 break;
2512 }
2513
2514 if (keep)
2515 {
2516 output = input;
2517 }
2518
2519 return keep;
2520 }
2521
2522 // ***************************************************************************
2523
2524 void CGroupHTML::registerAnchor(CInterfaceElement* elm)
2525 {
2526 if (!_AnchorName.empty())
2527 {
2528 for(uint32 i=0; i < _AnchorName.size(); ++i)
2529 {
2530 // filter out duplicates and register only first
2531 if (!_AnchorName[i].empty() && _Anchors.count(_AnchorName[i]) == 0)
2532 {
2533 _Anchors[_AnchorName[i]] = elm;
2534 }
2535 }
2536
2537 _AnchorName.clear();
2538 }
2539 }
2540
2541 // ***************************************************************************
2542 bool CGroupHTML::isSameStyle(CViewLink *text, const CStyleParams &style) const
2543 {
2544 if (!text) return false;
2545
2546 bool embolden = style.FontWeight >= FONT_WEIGHT_BOLD;
2547 bool sameShadow = style.TextShadow.Enabled && text->getShadow();
2548 if (sameShadow && style.TextShadow.Enabled)
2549 {
2550 sint sx, sy;
2551 text->getShadowOffset(sx, sy);
2552 sameShadow = (style.TextShadow.Color == text->getShadowColor());
2553 sameShadow = sameShadow && (style.TextShadow.Outline == text->getShadowOutline());
2554 sameShadow = sameShadow && (style.TextShadow.X == sx) && (style.TextShadow.Y == sy);
2555 }
2556 // Compatible with current parameters ?
2557 return sameShadow &&
2558 (style.TextColor == text->getColor()) &&
2559 (style.FontFamily == text->getFontName()) &&
2560 (style.FontSize == (uint)text->getFontSize()) &&
2561 (style.Underlined == text->getUnderlined()) &&
2562 (style.StrikeThrough == text->getStrikeThrough()) &&
2563 (embolden == text->getEmbolden()) &&
2564 (style.FontOblique == text->getOblique()) &&
2565 (getLink() == text->Link) &&
2566 (style.GlobalColorText == text->getModulateGlobalColor());
2567 }
2568
2569 // ***************************************************************************
2570 void CGroupHTML::newTextButton(const std::string &text, const std::string &tpl)
2571 {
2572 _CurrentViewLink = NULL;
2573 _CurrentViewImage = NULL;
2574
2575 // Action handler parameters : "name=group_html_id|form=id_of_the_form|submit_button=button_name"
2576 string param = "name=" + this->_Id + "|url=" + getLink();
2577 string name;
2578 if (!_AnchorName.empty())
2579 name = _AnchorName.back();
2580
2581 typedef pair<string, string> TTmplParam;
2582 vector<TTmplParam> tmplParams;
2583 tmplParams.push_back(TTmplParam("id", ""));
2584 tmplParams.push_back(TTmplParam("onclick", "browse"));
2585 tmplParams.push_back(TTmplParam("onclick_param", param));
2586 tmplParams.push_back(TTmplParam("active", "true"));
2587 CInterfaceGroup *buttonGroup = CWidgetManager::getInstance()->getParser()->createGroupInstance(tpl, getId()+":"+name, tmplParams);
2588 if (!buttonGroup)
2589 {
2590 nlinfo("Text button template '%s' not found", tpl.c_str());
2591 return;
2592 }
2593 buttonGroup->setId(getId()+":"+name);
2594
2595 // Add the ctrl button
2596 CCtrlTextButton *ctrlButton = dynamic_cast<CCtrlTextButton*>(buttonGroup->getCtrl("button"));
2597 if (!ctrlButton) ctrlButton = dynamic_cast<CCtrlTextButton*>(buttonGroup->getCtrl("b"));
2598 if (!ctrlButton)
2599 {
2600 nlinfo("Text button template '%s' is missing :button or :b text element", tpl.c_str());
2601 return;
2602 }
2603 ctrlButton->setModulateGlobalColorAll(_Style.Current.GlobalColor);
2604 ctrlButton->setTextModulateGlobalColorNormal(_Style.Current.GlobalColorText);
2605 ctrlButton->setTextModulateGlobalColorOver(_Style.Current.GlobalColorText);
2606 ctrlButton->setTextModulateGlobalColorPushed(_Style.Current.GlobalColorText);
2607
2608 // Translate the tooltip
2609 ctrlButton->setText(text);
2610 ctrlButton->setDefaultContextHelp(std::string(getLinkTitle()));
2611 // empty url / button disabled
2612 ctrlButton->setFrozen(*getLink() == '\0');
2613
2614 setTextButtonStyle(ctrlButton, _Style.Current);
2615
2616 _Paragraph->addChild(buttonGroup);
2617 }
2618
2619 // ***************************************************************************
2620 void CGroupHTML::newTextLink(const std::string &text)
2621 {
2622 CViewLink *newLink = new CViewLink(CViewBase::TCtorParam());
2623 if (getA())
2624 {
2625 newLink->Link = getLink();
2626 newLink->LinkTitle = getLinkTitle();
2627 if (!newLink->Link.empty())
2628 {
2629 newLink->setHTMLView (this);
2630 newLink->setActionOnLeftClick("browse");
2631 newLink->setParamsOnLeftClick("name=" + getId() + "|url=" + newLink->Link);
2632 }
2633 }
2634 newLink->setText(text);
2635 newLink->setMultiLineSpace((uint)((float)(_Style.Current.FontSize)*LineSpaceFontFactor));
2636 newLink->setMultiLine(true);
2637 newLink->setModulateGlobalColor(_Style.Current.GlobalColorText);
2638 setTextStyle(newLink, _Style.Current);
2639
2640 registerAnchor(newLink);
2641
2642 if (getA() && !newLink->Link.empty())
2643 getParagraph()->addChildLink(newLink);
2644 else
2645 getParagraph()->addChild(newLink);
2646
2647 _CurrentViewLink = newLink;
2648 _CurrentViewImage = NULL;
2649 }
2650
2651 // ***************************************************************************
2652
2653 void CGroupHTML::addString(const std::string &str)
2654 {
2655 string tmpStr = str;
2656
2657 if (_Localize)
2658 {
2659 string _str = tmpStr;
2660 string::size_type p = _str.find('#');
2661 if (p == string::npos)
2662 {
2663 tmpStr = CI18N::get(_str);
2664 }
2665 else
2666 {
2667 string cmd = _str.substr(0, p);
2668 string arg = _str.substr(p+1);
2669
2670 if (cmd == "date")
2671 {
2672 uint year, month, day;
2673 sscanf(arg.c_str(), "%d/%d/%d", &year, &month, &day);
2674 tmpStr = CI18N::get( "uiMFIDate");
2675
2676 year += (year > 70 ? 1900 : 2000);
2677
2678 strFindReplace(tmpStr, "%year", toString("%d", year) );
2679 strFindReplace(tmpStr, "%month", CI18N::get(toString("uiMonth%02d", month)) );
2680 strFindReplace(tmpStr, "%day", toString("%d", day) );
2681 }
2682 else
2683 {
2684 tmpStr = arg;
2685 }
2686 }
2687 }
2688
2689 // In title ?
2690 if (_Object)
2691 {
2692 _ObjectScript += tmpStr;
2693 }
2694 else if (_SelectOption)
2695 {
2696 if (!(_Forms.empty()))
2697 {
2698 if (!_Forms.back().Entries.empty())
2699 {
2700 _SelectOptionStr += tmpStr;
2701 }
2702 }
2703 }
2704 else
2705 {
2706 // In a paragraph ?
2707 if (!_Paragraph)
2708 {
2709 newParagraph (0);
2710 paragraphChange ();
2711 }
2712
2713 CStyleParams &style = _Style.Current;
2714
2715 // Text added ?
2716 bool added = false;
2717
2718 if (_CurrentViewLink)
2719 {
2720 bool skipLine = !_CurrentViewLink->getText().empty() && *(_CurrentViewLink->getText().rbegin()) == '\n';
2721 if (!skipLine && isSameStyle(_CurrentViewLink, style))
2722 {
2723 // Concat the text
2724 _CurrentViewLink->setText(_CurrentViewLink->getText()+tmpStr);
2725 _CurrentViewLink->invalidateContent();
2726 added = true;
2727 }
2728 }
2729
2730 // Not added ?
2731 if (!added)
2732 {
2733 if (getA() && string(getLinkClass()) == "ryzom-ui-button")
2734 newTextButton(tmpStr, DefaultButtonGroup);
2735 else
2736 newTextLink(tmpStr);
2737 }
2738 }
2739 }
2740
2741 // ***************************************************************************
2742
2743 void CGroupHTML::addImage(const std::string &id, const std::string &img, bool reloadImg, const CStyleParams &style)
2744 {
2745 // In a paragraph ?
2746 if (!_Paragraph)
2747 {
2748 newParagraph (0);
2749 paragraphChange ();
2750 }
2751
2752 // No more text in this text view
2753 _CurrentViewLink = NULL;
2754
2755 // Not added ?
2756 CViewBitmap *newImage = new CViewBitmap (TCtorParam());
2757 newImage->setId(id);
2758
2759 addImageDownload(img, newImage, style, NormalImage);
2760 newImage->setRenderLayer(getRenderLayer()+1);
2761
2762 getParagraph()->addChild(newImage);
2763 paragraphChange ();
2764
2765 setImageSize(newImage, style);
2766 }
2767
2768 // ***************************************************************************
2769
2770 CInterfaceGroup *CGroupHTML::addTextArea(const std::string &templateName, const char *name, uint rows, uint cols, bool multiLine, const std::string &content, uint maxlength)
2771 {
2772 // In a paragraph ?
2773 if (!_Paragraph)
2774 {
2775 newParagraph (0);
2776 paragraphChange ();
2777 }
2778
2779 // No more text in this text view
2780 _CurrentViewLink = NULL;
2781
2782 CStyleParams &style = _Style.Current;
2783 {
2784 // override cols/rows values from style
2785 if (style.Width > 0) cols = style.Width / style.FontSize;
2786 if (style.Height > 0) rows = style.Height / style.FontSize;
2787
2788 // Not added ?
2789 std::vector<std::pair<std::string,std::string> > templateParams;
2790 templateParams.push_back (std::pair<std::string,std::string> ("w", toString (cols*style.FontSize)));
2791 templateParams.push_back (std::pair<std::string,std::string> ("id", name));
2792 templateParams.push_back (std::pair<std::string,std::string> ("prompt", ""));
2793 templateParams.push_back (std::pair<std::string,std::string> ("multiline", multiLine?"true":"false"));
2794 templateParams.push_back (std::pair<std::string,std::string> ("fontsize", toString (style.FontSize)));
2795 templateParams.push_back (std::pair<std::string,std::string> ("color", style.TextColor.toString()));
2796 if (style.FontWeight >= FONT_WEIGHT_BOLD)
2797 templateParams.push_back (std::pair<std::string,std::string> ("fontweight", "bold"));
2798 if (style.FontOblique)
2799 templateParams.push_back (std::pair<std::string,std::string> ("fontstyle", "oblique"));
2800 if (multiLine)
2801 templateParams.push_back (std::pair<std::string,std::string> ("multi_min_line", toString(rows)));
2802 templateParams.push_back (std::pair<std::string,std::string> ("want_return", multiLine?"true":"false"));
2803 templateParams.push_back (std::pair<std::string,std::string> ("onenter", ""));
2804 templateParams.push_back (std::pair<std::string,std::string> ("enter_recover_focus", "false"));
2805 if (maxlength > 0)
2806 templateParams.push_back (std::pair<std::string,std::string> ("max_num_chars", toString(maxlength)));
2807 templateParams.push_back (std::pair<std::string,std::string> ("shadow", toString(style.TextShadow.Enabled)));
2808 if (style.TextShadow.Enabled)
2809 {
2810 templateParams.push_back (std::pair<std::string,std::string> ("shadow_x", toString(style.TextShadow.X)));
2811 templateParams.push_back (std::pair<std::string,std::string> ("shadow_y", toString(style.TextShadow.Y)));
2812 templateParams.push_back (std::pair<std::string,std::string> ("shadow_color", style.TextShadow.Color.toString()));
2813 templateParams.push_back (std::pair<std::string,std::string> ("shadow_outline", toString(style.TextShadow.Outline)));
2814 }
2815
2816 CInterfaceGroup *textArea = CWidgetManager::getInstance()->getParser()->createGroupInstance (templateName.c_str(),
2817 getParagraph()->getId(), templateParams.empty()?NULL:&(templateParams[0]), (uint)templateParams.size());
2818
2819 // Group created ?
2820 if (textArea)
2821 {
2822 // Set the content
2823 CGroupEditBox *eb = dynamic_cast<CGroupEditBox*>(textArea->getGroup("eb"));
2824 if (eb)
2825 {
2826 eb->setInputString(decodeHTMLEntities(content));
2827 if (style.hasStyle("background-color"))
2828 {
2829 CViewBitmap *bg = dynamic_cast<CViewBitmap*>(eb->getView("bg"));
2830 if (bg)
2831 {
2832 bg->setTexture("blank.tga");
2833 bg->setColor(style.Background.color);
2834 }
2835 }
2836 }
2837
2838 textArea->invalidateCoords();
2839 getParagraph()->addChild (textArea);
2840 paragraphChange ();
2841
2842 return textArea;
2843 }
2844 }
2845
2846 // Not group created
2847 return NULL;
2848 }
2849
2850 // ***************************************************************************
2851 CDBGroupComboBox *CGroupHTML::addComboBox(const std::string &templateName, const char *name)
2852 {
2853 // In a paragraph ?
2854 if (!_Paragraph)
2855 {
2856 newParagraph (0);
2857 paragraphChange ();
2858 }
2859
2860
2861 {
2862 // Not added ?
2863 std::vector<std::pair<std::string,std::string> > templateParams;
2864 templateParams.push_back (std::pair<std::string,std::string> ("id", name));
2865 CInterfaceGroup *group = CWidgetManager::getInstance()->getParser()->createGroupInstance (templateName.c_str(),
2866 getParagraph()->getId(), templateParams.empty()?NULL:&(templateParams[0]), (uint)templateParams.size());
2867
2868 // Group created ?
2869 if (group)
2870 {
2871 // Set the content
2872 CDBGroupComboBox *cb = dynamic_cast<CDBGroupComboBox *>(group);
2873 if (!cb)
2874 {
2875 nlwarning("'%s' template has bad type, combo box expected", templateName.c_str());
2876 delete cb;
2877 return NULL;
2878 }
2879 else
2880 {
2881 getParagraph()->addChild (cb);
2882 paragraphChange ();
2883 return cb;
2884 }
2885 }
2886 }
2887
2888 // Not group created
2889 return NULL;
2890 }
2891
2892 // ***************************************************************************
2893 CGroupMenu *CGroupHTML::addSelectBox(const std::string &templateName, const char *name)
2894 {
2895 // In a paragraph ?
2896 if (!_Paragraph)
2897 {
2898 newParagraph (0);
2899 paragraphChange ();
2900 }
2901
2902 // Not added ?
2903 std::vector<std::pair<std::string,std::string> > templateParams;
2904 templateParams.push_back(std::pair<std::string,std::string> ("id", name));
2905 CInterfaceGroup *group = CWidgetManager::getInstance()->getParser()->createGroupInstance(templateName.c_str(),
2906 getParagraph()->getId(), &(templateParams[0]), (uint)templateParams.size());
2907
2908 // Group created ?
2909 if (group)
2910 {
2911 // Set the content
2912 CGroupMenu *sb = dynamic_cast<CGroupMenu *>(group);
2913 if (!sb)
2914 {
2915 nlwarning("'%s' template has bad type, CGroupMenu expected", templateName.c_str());
2916 delete sb;
2917 return NULL;
2918 }
2919 else
2920 {
2921 getParagraph()->addChild (sb);
2922 paragraphChange ();
2923 return sb;
2924 }
2925 }
2926
2927 // No group created
2928 return NULL;
2929 }
2930
2931 // ***************************************************************************
2932
2933 CCtrlButton *CGroupHTML::addButton(CCtrlButton::EType type, const std::string &name, const std::string &normalBitmap, const std::string &pushedBitmap,
2934 const std::string &overBitmap, const char *actionHandler, const char *actionHandlerParams,
2935 const std::string &tooltip, const CStyleParams &style)
2936 {
2937 // In a paragraph ?
2938 if (!_Paragraph)
2939 {
2940 newParagraph (0);
2941 paragraphChange ();
2942 }
2943
2944 // Add the ctrl button
2945 CCtrlButton *ctrlButton = new CCtrlButton(TCtorParam());
2946 if (!name.empty())
2947 {
2948 ctrlButton->setId(name);
2949 }
2950
2951 std::string normal;
2952 if (startsWith(normalBitmap, "data:image/"))
2953 {
2954 normal = decodeURIComponent(normalBitmap);
2955 }
2956 else
2957 {
2958 // Load only tga files.. (conversion in dds filename is done in the lookup procedure)
2959 normal = normalBitmap.empty()?"":CFile::getPath(normalBitmap) + CFile::getFilenameWithoutExtension(normalBitmap) + ".tga";
2960
2961 // if the image doesn't exist on local, we check in the cache
2962 if(!CPath::exists(normal))
2963 {
2964 // search in the compressed texture
2965 CViewRenderer &rVR = *CViewRenderer::getInstance();
2966 sint32 id = rVR.getTextureIdFromName(normal);
2967 if(id == -1)
2968 {
2969 normal = localImageName(normalBitmap);
2970 addImageDownload(normalBitmap, ctrlButton, style);
2971 }
2972 }
2973 }
2974
2975 std::string pushed;
2976 if (startsWith(pushedBitmap, "data:image/"))
2977 {
2978 pushed = decodeURIComponent(pushedBitmap);
2979 }
2980 else
2981 {
2982 pushed = pushedBitmap.empty()?"":CFile::getPath(pushedBitmap) + CFile::getFilenameWithoutExtension(pushedBitmap) + ".tga";
2983 // if the image doesn't exist on local, we check in the cache, don't download it because the "normal" will already setuped it
2984 if(!CPath::exists(pushed))
2985 {
2986 // search in the compressed texture
2987 CViewRenderer &rVR = *CViewRenderer::getInstance();
2988 sint32 id = rVR.getTextureIdFromName(pushed);
2989 if(id == -1)
2990 {
2991 pushed = localImageName(pushedBitmap);
2992 }
2993 }
2994 }
2995
2996 std::string over;
2997 if (startsWith(overBitmap, "data:image/"))
2998 {
2999 over = decodeURIComponent(overBitmap);
3000 }
3001 else
3002 {
3003 over = overBitmap.empty()?"":CFile::getPath(overBitmap) + CFile::getFilenameWithoutExtension(overBitmap) + ".tga";
3004 // schedule mouseover bitmap for download if its different from normal
3005 if (!over.empty() && !CPath::exists(over))
3006 {
3007 if (overBitmap != normalBitmap)
3008 {
3009 over = localImageName(overBitmap);
3010 addImageDownload(overBitmap, ctrlButton, style, OverImage);
3011 }
3012 }
3013 }
3014
3015 ctrlButton->setType (type);
3016 if (!normal.empty())
3017 ctrlButton->setTexture (normal);
3018 if (!pushed.empty())
3019 ctrlButton->setTexturePushed (pushed);
3020 if (!over.empty())
3021 ctrlButton->setTextureOver (over);
3022 ctrlButton->setModulateGlobalColorAll (style.GlobalColor);
3023 ctrlButton->setActionOnLeftClick (actionHandler);
3024 ctrlButton->setParamsOnLeftClick (actionHandlerParams);
3025
3026 // Translate the tooltip or display raw text (tooltip from webig)
3027 if (!tooltip.empty())
3028 {
3029 if (CI18N::hasTranslation(tooltip))
3030 {
3031 ctrlButton->setDefaultContextHelp(CI18N::get(tooltip));
3032 //ctrlButton->setOnContextHelp(CI18N::get(tooltip).toString());
3033 }
3034 else
3035 {
3036 ctrlButton->setDefaultContextHelp(tooltip);
3037 //ctrlButton->setOnContextHelp(string(tooltip));
3038 }
3039
3040 ctrlButton->setInstantContextHelp(true);
3041 ctrlButton->setToolTipParent(TTMouse);
3042 ctrlButton->setToolTipParentPosRef(Hotspot_TTAuto);
3043 ctrlButton->setToolTipPosRef(Hotspot_TTAuto);
3044 }
3045
3046 getParagraph()->addChild (ctrlButton);
3047 paragraphChange ();
3048
3049 setImageSize(ctrlButton, style);
3050
3051 return ctrlButton;
3052 }
3053
3054 // ***************************************************************************
3055
3056 void CGroupHTML::flushString()
3057 {
3058 _CurrentViewLink = NULL;
3059 }
3060
3061 // ***************************************************************************
3062
3063 void CGroupHTML::clearContext()
3064 {
3065 _Paragraph = NULL;
3066 _PRE.clear();
3067 _Indent.clear();
3068 _LI = false;
3069 _UL.clear();
3070 _DL.clear();
3071 _A.clear();
3072 _Link.clear();
3073 _LinkTitle.clear();
3074 _Tables.clear();
3075 _Cells.clear();
3076 _TR.clear();
3077 _Forms.clear();
3078 _FormOpen = false;
3079 _FormSubmit.clear();
3080 _Groups.clear();
3081 _Divs.clear();
3082 _Anchors.clear();
3083 _AnchorName.clear();
3084 _CellParams.clear();
3085 _Object = false;
3086 _Localize = false;
3087 _ReadingHeadTag = false;
3088 _IgnoreHeadTag = false;
3089 _IgnoreBaseUrlTag = false;
3090 _AutoIdSeq = 0;
3091 m_TableRowBackgroundColor.clear();
3092
3093 paragraphChange ();
3094
3095 releaseDataDownloads();
3096 }
3097
3098 // ***************************************************************************
3099
3100 u32char CGroupHTML::getLastChar() const
3101 {
3102 if (_CurrentViewLink)
3103 {
3104 ::u32string str = CUtfStringView(_CurrentViewLink->getText()).toUtf32(); // FIXME: Optimize reverse UTF iteration
3105 if (!str.empty())
3106 return str[str.length()-1];
3107 }
3108 return 0;
3109 }
3110
3111 // ***************************************************************************
3112
3113 void CGroupHTML::paragraphChange ()
3114 {
3115 _CurrentViewLink = NULL;
3116 _CurrentViewImage = NULL;
3117 CGroupParagraph *paragraph = getParagraph();
3118 if (paragraph)
3119 {
3120 // Number of child in this paragraph
3121 uint numChild = paragraph->getNumChildren();
3122 if (numChild)
3123 {
3124 // Get the last child
3125 CViewBase *child = paragraph->getChild(numChild-1);
3126
3127 // Is this a string view ?
3128 _CurrentViewLink = dynamic_cast<CViewLink*>(child);
3129 _CurrentViewImage = dynamic_cast<CViewBitmap*>(child);
3130 }
3131 }
3132 }
3133
3134 // ***************************************************************************
3135
3136 CInterfaceGroup *CGroupHTML::getCurrentGroup()
3137 {
3138 if (!_Cells.empty() && _Cells.back())
3139 return _Cells.back()->Group;
3140 else
3141 return _GroupListAdaptor;
3142 }
3143
3144 // ***************************************************************************
3145
3146 void CGroupHTML::addHtmlGroup (CInterfaceGroup *group, uint beginSpace)
3147 {
3148 if (!group)
3149 return;
3150
3151 registerAnchor(group);
3152
3153 if (!_DivName.empty())
3154 {
3155 group->setName(_DivName);
3156 _Groups.push_back(group);
3157 }
3158
3159 group->setSizeRef(CInterfaceElement::width);
3160
3161 // Compute begin space between paragraph and tables
3162 // * If first in group, no begin space
3163
3164 // Pointer on the current paragraph (can be a table too)
3165 CGroupParagraph *p = dynamic_cast<CGroupParagraph*>(group);
3166
3167 CInterfaceGroup *parentGroup = CGroupHTML::getCurrentGroup();
3168 const std::vector<CInterfaceGroup*> &groups = parentGroup->getGroups ();
3169 group->setParent(parentGroup);
3170 group->setParentSize(parentGroup);
3171 if (groups.empty())
3172 {
3173 group->setParentPos(parentGroup);
3174 group->setPosRef(Hotspot_TL);
3175 group->setParentPosRef(Hotspot_TL);
3176 beginSpace = 0;
3177 }
3178 else
3179 {
3180 // Last is a paragraph ?
3181 group->setParentPos(groups.back());
3182 group->setPosRef(Hotspot_TL);
3183 group->setParentPosRef(Hotspot_BL);
3184 }
3185
3186 // Set the begin space
3187 if (p)
3188 p->setTopSpace(beginSpace);
3189 else
3190 group->setY(-(sint32)beginSpace);
3191 parentGroup->addGroup (group);
3192 }
3193
3194 // ***************************************************************************
3195
3196 void CGroupHTML::setContainerTitle (const std::string &title)
3197 {
3198 CInterfaceElement *parent = getParent();
3199 if (parent)
3200 {
3201 if ((parent = parent->getParent()))
3202 {
3203 CGroupContainer *container = dynamic_cast<CGroupContainer*>(parent);
3204 if (container)
3205 {
3206 container->setTitle(title);
3207 }
3208 }
3209 }
3210 }
3211
3212 void CGroupHTML::setTitle(const std::string &title)
3213 {
3214 if(_TitlePrefix.empty())
3215 _TitleString = title;
3216 else
3217 _TitleString = _TitlePrefix + " - " + title;
3218
3219 setContainerTitle(_TitleString);
3220 }
3221
3222 std::string CGroupHTML::getTitle() const {
3223 return _TitleString;
3224 };
3225
3226 // ***************************************************************************
3227
3228 bool CGroupHTML::lookupLocalFile (string &result, const char *url, bool isUrl)
3229 {
3230 result = url;
3231 string tmp;
3232
3233 if (toLowerAscii(result).find("file:") == 0 && result.size() > 5)
3234 {
3235 result = result.substr(5, result.size()-5);
3236 }
3237 else if (result.find("://") != string::npos || result.find("//") == 0)
3238 {
3239 // http://, https://, etc or protocol-less url "//domain.com/image.png"
3240 return false;
3241 }
3242
3243 tmp = CPath::lookup (CFile::getFilename(result), false, false, false);
3244 if (tmp.empty())
3245 {
3246 // try to find in local directory
3247 tmp = CPath::lookup (result, false, false, true);
3248 }
3249
3250 if (!tmp.empty())
3251 {
3252 // Normalize the path
3253 if (isUrl)
3254 //result = "file:"+toLowerAscii(CPath::standardizePath (CPath::getFullPath (CFile::getPath(result)))+CFile::getFilename(result));*/
3255 result = "file:/"+tmp;
3256 else
3257 result = tmp;
3258 return true;
3259 }
3260 else
3261 {
3262 // Is it a texture in the big texture ?
3263 if (CViewRenderer::getInstance()->getTextureIdFromName (result) >= 0)
3264 {
3265 return true;
3266 }
3267 else
3268 {
3269 // This is not a file in the CPath, let libwww open this URL
3270 result = url;
3271 return false;
3272 }
3273 }
3274 }
3275
3276 // ***************************************************************************
3277
3278 void CGroupHTML::submitForm(uint button, sint32 x, sint32 y)
3279 {
3280 if (button >= _FormSubmit.size())
3281 return;
3282
3283 for(uint formId = 0; formId < _Forms.size(); formId++)
3284 {
3285 // case sensitive search (user id is lowecase, auto id is uppercase)
3286 if (_Forms[formId].id == _FormSubmit[button].form)
3287 {
3288 _PostNextTime = true;
3289 _PostFormId = formId;
3290 _PostFormAction = _FormSubmit[button].formAction;
3291 _PostFormSubmitType = _FormSubmit[button].type;
3292 _PostFormSubmitButton = _FormSubmit[button].name;
3293 _PostFormSubmitValue = _FormSubmit[button].value;
3294 _PostFormSubmitX = x;
3295 _PostFormSubmitY = y;
3296
3297 return;
3298 }
3299 }
3300
3301 nlwarning("Unable to find form '%s' to submit (button '%s')", _FormSubmit[button].form.c_str(), _FormSubmit[button].name.c_str());
3302 }
3303
3304 // ***************************************************************************
3305
3306 void CGroupHTML::setupBackground(CSSBackgroundRenderer *bg)
3307 {
3308 if (!bg) return;
3309
3310 bg->setModulateGlobalColor(_Style.Current.GlobalColor);
3311 bg->setBackground(_Style.Current.Background);
3312 bg->setFontSize(_Style.Root.FontSize, _Style.Current.FontSize);
3313
3314 bg->setViewport(getList()->getParentPos() ? getList()->getParentPos() : this);
3315
3316 if (!_Style.Current.Background.image.empty())
3317 addTextureDownload(_Style.Current.Background.image, bg->TextureId, this);
3318 }
3319
3320 // ***************************************************************************
3321
3322 void CGroupHTML::setBackgroundColor (const CRGBA &bgcolor)
3323 {
3324 // TODO: DefaultBackgroundBitmapView should be removed from interface xml
3325 CViewBase *view = getView (DefaultBackgroundBitmapView);
3326 if (view)
3327 view->setActive(false);
3328
3329 m_HtmlBackground.setColor(bgcolor);
3330 }
3331
3332 // ***************************************************************************
3333
3334 void CGroupHTML::setBackground (const string &bgtex, bool scale, bool tile)
3335 {
3336 // TODO: DefaultBackgroundBitmapView should be removed from interface xml
3337 CViewBase *view = getView (DefaultBackgroundBitmapView);
3338 if (view)
3339 view->setActive(false);
3340
3341 m_HtmlBackground.setImage(bgtex);
3342 m_HtmlBackground.setImageRepeat(tile);
3343 m_HtmlBackground.setImageCover(scale);
3344
3345 if (!bgtex.empty())
3346 addTextureDownload(bgtex, m_HtmlBackground.TextureId, this);
3347 }
3348
3349
3350 struct CButtonFreezer : public CInterfaceElementVisitor
3351 {
3352 virtual void visitCtrl(CCtrlBase *ctrl)
3353 {
3354 CCtrlBaseButton *textButt = dynamic_cast<CCtrlTextButton *>(ctrl);
3355 if (textButt)
3356 {
3357 textButt->setFrozen(true);
3358 }
3359 }
3360 };
3361
3362 // ***************************************************************************
3363
3364 void CGroupHTML::handle ()
3365 {
3366 H_AUTO(RZ_Interface_Html_handle)
3367
3368 const CWidgetManager::SInterfaceTimes &times = CWidgetManager::getInstance()->getInterfaceTimes();
3369
3370 // handle curl downloads
3371 checkDownloads();
3372
3373 // handle refresh timer
3374 if (_NextRefreshTime > 0 && _NextRefreshTime <= (times.thisFrameMs / 1000.0f) )
3375 {
3376 // there might be valid uses for 0sec refresh, but two in a row is probably a mistake
3377 if (_NextRefreshTime - _LastRefreshTime >= 1.0)
3378 {
3379 _LastRefreshTime = _NextRefreshTime;
3380 doBrowse(_RefreshUrl.c_str());
3381 }
3382 else
3383 nlwarning("Ignore second 0sec http-equiv refresh in a row (url '%s')", _URL.c_str());
3384
3385 _NextRefreshTime = 0;
3386 }
3387
3388 if (_CurlWWW)
3389 {
3390 // still transfering html page
3391 if (_TimeoutValue != 0 && _ConnectingTimeout <= ( times.thisFrameMs / 1000.0f ) )
3392 {
3393 browseError(("Connection timeout : "+_URL).c_str());
3394 }
3395 }
3396 else
3397 if (_RenderNextTime)
3398 {
3399 _RenderNextTime = false;
3400 renderHtmlString(_DocumentHtml);
3401 }
3402 else
3403 if (_WaitingForStylesheet)
3404 {
3405 renderDocument();
3406 }
3407 else
3408 if (_BrowseNextTime || _PostNextTime)
3409 {
3410 // Set timeout
3411 _ConnectingTimeout = ( times.thisFrameMs / 1000.0f ) + _TimeoutValue;
3412
3413 // freeze form buttons
3414 CButtonFreezer freezer;
3415 this->visit(&freezer);
3416
3417 // Home ?
3418 if (_URL == "home")
3419 _URL = home();
3420
3421 string finalUrl;
3422 bool isLocal = lookupLocalFile (finalUrl, _URL.c_str(), true);
3423
3424 _URL = finalUrl;
3425
3426 CUrlParser uri (_URL);
3427 _TrustedDomain = isTrustedDomain(uri.host);
3428 _DocumentDomain = uri.host;
3429
3430 // file is probably from bnp (ingame help)
3431 if (isLocal)
3432 {
3433 doBrowseLocalFile(finalUrl);
3434 }
3435 else
3436 {
3437 SFormFields formfields;
3438 if (_PostNextTime)
3439 {
3440 buildHTTPPostParams(formfields);
3441 // _URL is set from form.Action
3442 finalUrl = _URL;
3443 }
3444 else
3445 {
3446 // Add custom get params from child classes
3447 addHTTPGetParams (finalUrl, _TrustedDomain);
3448 }
3449
3450 doBrowseRemoteUrl(finalUrl, "", _PostNextTime, formfields);
3451 }
3452
3453 _BrowseNextTime = false;
3454 _PostNextTime = false;
3455 }
3456 }
3457
3458 // ***************************************************************************
3459 void CGroupHTML::buildHTTPPostParams (SFormFields &formfields)
3460 {
3461 // Add text area text
3462 uint i;
3463
3464 if (_PostFormId >= _Forms.size())
3465 {
3466 nlwarning("(%s) invalid form index %d, _Forms %d", _Id.c_str(), _PostFormId, _Forms.size());
3467 return;
3468 }
3469 // Ref the form
3470 CForm &form = _Forms[_PostFormId];
3471
3472 // button can override form action url (and methor, but we only do POST)
3473 _URL = _PostFormAction.empty() ? form.Action : _PostFormAction;
3474
3475 CUrlParser uri(_URL);
3476 _TrustedDomain = isTrustedDomain(uri.host);
3477 _DocumentDomain = uri.host;
3478
3479 for (i=0; i<form.Entries.size(); i++)
3480 {
3481 // Text area ?
3482 bool addEntry = false;
3483 string entryData;
3484 if (form.Entries[i].TextArea)
3485 {
3486 // Get the edit box view
3487 CInterfaceGroup *group = form.Entries[i].TextArea->getGroup ("eb");
3488 if (group)
3489 {
3490 // Should be a CGroupEditBox
3491 CGroupEditBox *editBox = dynamic_cast<CGroupEditBox*>(group);
3492 if (editBox)
3493 {
3494 entryData = editBox->getViewText()->getText();
3495 addEntry = true;
3496 }
3497 }
3498 }
3499 else if (form.Entries[i].Checkbox)
3500 {
3501 // todo handle unicode POST here
3502 if (form.Entries[i].Checkbox->getPushed ())
3503 {
3504 entryData = form.Entries[i].Value;
3505 addEntry = true;
3506 }
3507 }
3508 else if (form.Entries[i].ComboBox)
3509 {
3510 CDBGroupComboBox *cb = form.Entries[i].ComboBox;
3511 entryData = form.Entries[i].SelectValues[cb->getSelection()];
3512 addEntry = true;
3513 }
3514 else if (form.Entries[i].SelectBox)
3515 {
3516 CGroupMenu *sb = form.Entries[i].SelectBox;
3517 CGroupSubMenu *rootMenu = sb->getRootMenu();
3518 if (rootMenu)
3519 {
3520 for(uint j=0; j<rootMenu->getNumLine(); ++j)
3521 {
3522 CInterfaceGroup *ig = rootMenu->getUserGroupLeft(j);
3523 if (ig)
3524 {
3525 CCtrlBaseButton *cb = dynamic_cast<CCtrlBaseButton *>(ig->getCtrl("b"));
3526 if (cb && cb->getPushed())
3527 formfields.add(form.Entries[i].Name, form.Entries[i].SelectValues[j]);
3528 }
3529 }
3530 }
3531 }
3532 // This is a hidden value
3533 else
3534 {
3535 entryData = form.Entries[i].Value;
3536 addEntry = true;
3537 }
3538
3539 // Add this entry
3540 if (addEntry)
3541 {
3542 formfields.add(form.Entries[i].Name, entryData);
3543 }
3544 }
3545
3546 if (_PostFormSubmitType == "image")
3547 {
3548 // Add the button coordinates
3549 if (_PostFormSubmitButton.find_first_of("[") == string::npos)
3550 {
3551 formfields.add(_PostFormSubmitButton + "_x", NLMISC::toString(_PostFormSubmitX));
3552 formfields.add(_PostFormSubmitButton + "_y", NLMISC::toString(_PostFormSubmitY));
3553 }
3554 else
3555 {
3556 formfields.add(_PostFormSubmitButton, NLMISC::toString(_PostFormSubmitX));
3557 formfields.add(_PostFormSubmitButton, NLMISC::toString(_PostFormSubmitY));
3558 }
3559 }
3560 else
3561 formfields.add(_PostFormSubmitButton, _PostFormSubmitValue);
3562
3563 // Add custom params from child classes
3564 addHTTPPostParams(formfields, _TrustedDomain);
3565 }
3566
3567 // ***************************************************************************
3568 void CGroupHTML::doBrowseLocalFile(const std::string &uri)
3569 {
3570 releaseDownloads();
3571 updateRefreshButton();
3572
3573 std::string filename;
3574 if (toLowerAscii(uri).find("file:/") == 0)
3575 {
3576 filename = uri.substr(6, uri.size() - 6);
3577 }
3578 else
3579 {
3580 filename = uri;
3581 }
3582
3583 LOG_DL("browse local file '%s'", filename.c_str());
3584
3585 _TrustedDomain = true;
3586 _DocumentDomain = "localhost";
3587
3588 CIFile in;
3589 if (in.open(filename))
3590 {
3591 std::string html;
3592 while(!in.eof())
3593 {
3594 char buf[1024];
3595 in.getline(buf, 1024);
3596 html += std::string(buf) + "\n";
3597 }
3598 in.close();
3599
3600 if (!renderHtmlString(html))
3601 {
3602 browseError((string("Failed to parse html from file : ")+filename).c_str());
3603 }
3604 }
3605 else
3606 {
3607 browseError((string("The page address is malformed : ")+filename).c_str());
3608 }
3609 }
3610
3611 // ***************************************************************************
3612 void CGroupHTML::doBrowseRemoteUrl(std::string url, const std::string &referer, bool doPost, const SFormFields &formfields)
3613 {
3614 // stop all downloads from previous page
3615 releaseDownloads();
3616 updateRefreshButton();
3617
3618 // Reset the title
3619 if(_TitlePrefix.empty())
3620 setTitle (CI18N::get("uiPleaseWait"));
3621 else
3622 setTitle (_TitlePrefix + " - " + CI18N::get("uiPleaseWait"));
3623
3624 url = upgradeInsecureUrl(url);
3625
3626 LOG_DL("(%s) browse url (trusted=%s) '%s', referer='%s', post='%s', nb form values %d",
3627 _Id.c_str(), (_TrustedDomain ? "true" :"false"), url.c_str(), referer.c_str(), (doPost ? "true" : "false"), formfields.Values.size());
3628
3629 if (!MultiCurl)
3630 {
3631 browseError(string("Invalid MultCurl handle, loading url failed : "+url).c_str());
3632 return;
3633 }
3634
3635 CURL *curl = curl_easy_init();
3636 if (!curl)
3637 {
3638 nlwarning("(%s) failed to create curl handle", _Id.c_str());
3639 browseError(string("Failed to create cURL handle : " + url).c_str());
3640 return;
3641 }
3642
3643 // https://
3644 if (toLowerAscii(url.substr(0, 8)) == "https://")
3645 {
3646 // if supported, use custom SSL context function to load certificates
3647 NLWEB::CCurlCertificates::useCertificates(curl);
3648 }
3649
3650 // do not follow redirects, we have own handler
3651 curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 0);
3652 // after redirect
3653 curl_easy_setopt(curl, CURLOPT_FRESH_CONNECT, 1);
3654
3655 // tell curl to use compression if possible (gzip, deflate)
3656 // leaving this empty allows all encodings that curl supports
3657 //curl_easy_setopt(curl, CURLOPT_ACCEPT_ENCODING, "");
3658
3659 // limit curl to HTTP and HTTPS protocols only
3660 curl_easy_setopt(curl, CURLOPT_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS);
3661 curl_easy_setopt(curl, CURLOPT_REDIR_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS);
3662
3663 // Destination
3664 curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
3665
3666 // User-Agent:
3667 std::string userAgent = options.appName + "/" + options.appVersion;
3668 curl_easy_setopt(curl, CURLOPT_USERAGENT, userAgent.c_str());
3669
3670 // Cookies
3671 sendCookies(curl, _DocumentDomain, _TrustedDomain);
3672
3673 // Referer
3674 if (!referer.empty())
3675 {
3676 curl_easy_setopt(curl, CURLOPT_REFERER, referer.c_str());
3677 LOG_DL("(%s) set referer '%s'", _Id.c_str(), referer.c_str());
3678 }
3679
3680 if (doPost)
3681 {
3682 // serialize form data and add it to curl
3683 std::string data;
3684 for(uint i=0; i<formfields.Values.size(); ++i)
3685 {
3686 char * escapedName = curl_easy_escape(curl, formfields.Values[i].name.c_str(), formfields.Values[i].name.size());
3687 char * escapedValue = curl_easy_escape(curl, formfields.Values[i].value.c_str(), formfields.Values[i].value.size());
3688
3689 if (i>0)
3690 data += "&";
3691
3692 data += std::string(escapedName) + "=" + escapedValue;
3693
3694 curl_free(escapedName);
3695 curl_free(escapedValue);
3696 }
3697 curl_easy_setopt(curl, CURLOPT_POST, 1);
3698 curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, data.size());
3699 curl_easy_setopt(curl, CURLOPT_COPYPOSTFIELDS, data.c_str());
3700 }
3701 else
3702 {
3703 curl_easy_setopt(curl, CURLOPT_HTTPGET, 1);
3704 }
3705
3706 // transfer handle
3707 _CurlWWW = new CCurlWWWData(curl, url);
3708
3709 // set the language code used by the client
3710 std::vector<std::string> headers;
3711 headers.push_back("Accept-Language: "+options.languageCode);
3712 headers.push_back("Accept-Charset: utf-8");
3713 _CurlWWW->sendHeaders(headers);
3714
3715 // catch headers for redirect
3716 curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, NLGUI::curlHeaderCallback);
3717 curl_easy_setopt(curl, CURLOPT_WRITEHEADER, _CurlWWW);
3718
3719 // catch body
3720 curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, NLGUI::curlDataCallback);
3721 curl_easy_setopt(curl, CURLOPT_WRITEDATA, _CurlWWW);
3722
3723 #ifdef LOG_CURL_PROGRESS
3724 // progress callback
3725 curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0);
3726 curl_easy_setopt(curl, CURLOPT_XFERINFOFUNCTION, NLGUI::curlProgressCallback);
3727 curl_easy_setopt(curl, CURLOPT_XFERINFODATA, _CurlWWW);
3728 #else
3729 // progress off
3730 curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1);
3731 #endif
3732
3733 //
3734 curl_multi_add_handle(MultiCurl, curl);
3735
3736 // start the transfer
3737 int NewRunningCurls = 0;
3738 curl_multi_perform(MultiCurl, &NewRunningCurls);
3739 RunningCurls++;
3740
3741 _RedirectsRemaining = DEFAULT_RYZOM_REDIRECT_LIMIT;
3742 }
3743
3744 // ***************************************************************************
3745 void CGroupHTML::htmlDownloadFinished(bool success, const std::string &error)
3746 {
3747 if (!success)
3748 {
3749 CUrlParser uri(_CurlWWW->Url);
3750
3751 // potentially unwanted chars
3752 std::string url = _CurlWWW->Url;
3753 url = strFindReplaceAll(url, string("<"), string("%3C"));
3754 url = strFindReplaceAll(url, string(">"), string("%3E"));
3755 url = strFindReplaceAll(url, string("\""), string("%22"));
3756 url = strFindReplaceAll(url, string("'"), string("%27"));
3757
3758 std::string err;
3759 err = "<html><head><title>cURL error</title></head><body>";
3760 err += "<h1>Connection failed with cURL error</h1>";
3761 err += error;
3762 err += "<hr>(" + uri.scheme + "://" + uri.host + ") <a href=\"" + url + "\">reload</a>";
3763 err += "</body></html>";
3764 browseErrorHtml(err);
3765 return;
3766 }
3767
3768 // received content from remote
3769 std::string content = trim(_CurlWWW->Content);
3770
3771 // save HSTS header from all requests regardless of HTTP code
3772 if (_CurlWWW->hasHSTSHeader())
3773 {
3774 CUrlParser uri(_CurlWWW->Url);
3775 CStrictTransportSecurity::getInstance()->setFromHeader(uri.host, _CurlWWW->getHSTSHeader());
3776 }
3777
3778 receiveCookies(_CurlWWW->Request, _DocumentDomain, _TrustedDomain);
3779
3780 long code;
3781 curl_easy_getinfo(_CurlWWW->Request, CURLINFO_RESPONSE_CODE, &code);
3782 LOG_DL("(%s) web transfer '%p' completed with http code %d, url (len %d) '%s'", _Id.c_str(), _CurlWWW->Request, code, _CurlWWW->Url.size(), _CurlWWW->Url.c_str());
3783
3784 if ((code >= 301 && code <= 303) || code == 307 || code == 308)
3785 {
3786 if (_RedirectsRemaining < 0)
3787 {
3788 browseError(string("Redirect limit reached : " + _URL).c_str());
3789 return;
3790 }
3791
3792 // redirect, get the location and try browse again
3793 // we cant use curl redirection because 'addHTTPGetParams()' must be called on new destination
3794 std::string location(_CurlWWW->getLocationHeader());
3795 if (location.empty())
3796 {
3797 browseError(string("Request was redirected, but location was not set : "+_URL).c_str());
3798 return;
3799 }
3800
3801 LOG_DL("(%s) request (%d) redirected to (len %d) '%s'", _Id.c_str(), _RedirectsRemaining, location.size(), location.c_str());
3802 location = getAbsoluteUrl(location);
3803
3804 _PostNextTime = false;
3805 _RedirectsRemaining--;
3806
3807 doBrowse(location.c_str());
3808 }
3809 else if ( (code < 200 || code >= 300) )
3810 {
3811 // catches 304 not modified, but html is not in cache anyway
3812 // if server did not send any error back
3813 if (content.empty())
3814 {
3815 content = string("<html><head><title>ERROR</title></head><body><h1>Connection failed</h1><p>HTTP code '" + toString((sint32)code) + "'</p><p>URL '" + _CurlWWW->Url + "'</p></body></html>");
3816 }
3817 }
3818
3819 char *ch;
3820 std::string contentType;
3821 CURLcode res = curl_easy_getinfo(_CurlWWW->Request, CURLINFO_CONTENT_TYPE, &ch);
3822 if (res == CURLE_OK && ch != NULL)
3823 {
3824 contentType = ch;
3825 }
3826
3827 htmlDownloadFinished(content, contentType, code);
3828
3829 // clear curl handler
3830 if (MultiCurl)
3831 {
3832 curl_multi_remove_handle(MultiCurl, _CurlWWW->Request);
3833 }
3834
3835 delete _CurlWWW;
3836 _CurlWWW = NULL;
3837
3838 // refresh button uses _CurlWWW. refresh button may stay disabled if
3839 // there is no css files to download and page is rendered before _CurlWWW is freed
3840 updateRefreshButton();
3841 }
3842
3843 void CGroupHTML::dataDownloadFinished(bool success, const std::string &error, CDataDownload *data)
3844 {
3845 fclose(data->fp);
3846
3847 CUrlParser uri(data->url);
3848 if (!uri.host.empty())
3849 {
3850 receiveCookies(data->data->Request, uri.host, isTrustedDomain(uri.host));
3851 }
3852
3853 long code = -1;
3854 curl_easy_getinfo(data->data->Request, CURLINFO_RESPONSE_CODE, &code);
3855
3856 LOG_DL("(%s) transfer '%p' completed with http code %d, url (len %d) '%s'", _Id.c_str(), data->data->Request, code, data->url.size(), data->url.c_str());
3857 curl_multi_remove_handle(MultiCurl, data->data->Request);
3858
3859 // save HSTS header from all requests regardless of HTTP code
3860 if (success)
3861 {
3862 if (data->data->hasHSTSHeader())
3863 {
3864 CStrictTransportSecurity::getInstance()->setFromHeader(uri.host, data->data->getHSTSHeader());
3865 }
3866
3867 // 2XX success, 304 Not Modified
3868 if ((code >= 200 && code <= 204) || code == 304)
3869 {
3870 CHttpCacheObject obj;
3871 obj.Expires = data->data->getExpires();
3872 obj.Etag = data->data->getEtag();
3873 obj.LastModified = data->data->getLastModified();
3874
3875 CHttpCache::getInstance()->store(data->dest, obj);
3876 if (code == 304 && CFile::fileExists(data->tmpdest))
3877 {
3878 CFile::deleteFile(data->tmpdest);
3879 }
3880 }
3881 else if ((code >= 301 && code <= 303) || code == 307 || code == 308)
3882 {
3883 if (data->redirects < DEFAULT_RYZOM_REDIRECT_LIMIT)
3884 {
3885 std::string location(data->data->getLocationHeader());
3886 if (!location.empty())
3887 {
3888 CUrlParser uri(location);
3889 if (!uri.isAbsolute())
3890 {
3891 uri.inherit(data->url);
3892 location = uri.toString();
3893 }
3894
3895 // clear old request state, and curl easy handle
3896 delete data->data;
3897 data->data = NULL;
3898 data->fp = NULL;
3899 data->url = location;
3900 data->redirects++;
3901
3902 // push same request in the front of the queue
3903 // cache filename is based of original url
3904 Curls.push_front(data);
3905
3906 LOG_DL("Redirect '%s'", location.c_str());
3907 // no finished callback called, so cleanup old temp
3908 if (CFile::fileExists(data->tmpdest))
3909 {
3910 CFile::deleteFile(data->tmpdest);
3911 }
3912 return;
3913 }
3914
3915 nlwarning("Redirected to empty url '%s'", data->url.c_str());
3916 }
3917 else
3918 {
3919 nlwarning("Redirect limit reached for '%s'", data->url.c_str());
3920 }
3921 }
3922 else
3923 {
3924 nlwarning("HTTP request failed with code [%d] for '%s'\n",code, data->url.c_str());
3925 // 404, 500, etc
3926 if (CFile::fileExists(data->dest))
3927 {
3928 CFile::deleteFile(data->dest);
3929 }
3930 }
3931 }
3932 else
3933 {
3934 nlwarning("DATA download failed '%s', error '%s'", data->url.c_str(), error.c_str());
3935 }
3936
3937 finishCurlDownload(data);
3938 }
3939
3940 void CGroupHTML::htmlDownloadFinished(const std::string &content, const std::string &type, long code)
3941 {
3942 LOG_DL("(%s) HTML download finished, content length %d, type '%s', code %d", _Id.c_str(), content.size(), type.c_str(), code);
3943
3944 // create <html> markup for image downloads
3945 if (type.find("image/") == 0 && !content.empty())
3946 {
3947 try
3948 {
3949 std::string dest = localImageName(_URL);
3950 COFile out;
3951 out.open(dest);
3952 out.serialBuffer((uint8 *)(content.c_str()), content.size());
3953 out.close();
3954 LOG_DL("(%s) image saved to '%s', url '%s'", _Id.c_str(), dest.c_str(), _URL.c_str());
3955 }
3956 catch(...) { }
3957
3958 // create html code with image url inside and do the request again
3959 renderHtmlString("<html><head><title>"+_URL+"</title></head><body><img src=\"" + _URL + "\"></body></html>");
3960 }
3961 else if (_TrustedDomain && type.find("text/lua") == 0)
3962 {
3963 setTitle(_TitleString);
3964
3965 _LuaScript = "\nlocal __CURRENT_WINDOW__=\""+this->_Id+"\" \n"+content;
3966 CLuaManager::getInstance().executeLuaScript(_LuaScript, true);
3967 _LuaScript.clear();
3968
3969 // disable refresh button
3970 clearRefresh();
3971 // disable redo into this url
3972 _AskedUrl.clear();
3973 }
3974 else
3975 {
3976 // Sanitize downloaded HTML UTF-8 encoding, and render
3977 renderHtmlString(CUtfStringView(content).toUtf8(true));
3978 }
3979 }
3980
3981 // ***************************************************************************
3982 void CGroupHTML::cssDownloadFinished(const std::string &url, const std::string &local)
3983 {
3984 for(std::vector<CHtmlParser::StyleLink>::iterator it = _StylesheetQueue.begin();
3985 it != _StylesheetQueue.end(); ++it)
3986 {
3987 if (it->Url == url)
3988 {
3989 // read downloaded file into HtmlStyles
3990 if (CFile::fileExists(local) && it->Index < _HtmlStyles.size())
3991 {
3992 CIFile in;
3993 if (in.open(local))
3994 {
3995 if (!in.readAll(_HtmlStyles[it->Index]))
3996 {
3997 nlwarning("Failed to read downloaded css file(%s), url(%s)", local.c_str(), url.c_str());
3998 }
3999 }
4000 }
4001
4002 _StylesheetQueue.erase(it);
4003 break;
4004 }
4005 }
4006 }
4007
4008 void CGroupHTML::renderDocument()
4009 {
4010 if (!Curls.empty() && !_StylesheetQueue.empty())
4011 {
4012 // waiting for stylesheets to finish downloading
4013 return;
4014 }
4015 _WaitingForStylesheet = false;
4016
4017 //TGameTime renderStart = CTime::getLocalTime();
4018
4019 // clear previous state and page
4020 beginBuild();
4021 removeContent();
4022
4023 // process all <style> and <link rel=stylesheet> elements
4024 for(uint i = 0; i < _HtmlStyles.size(); ++i)
4025 {
4026 if (!_HtmlStyles[i].empty())
4027 {
4028 _Style.parseStylesheet(_HtmlStyles[i]);
4029 }
4030 }
4031 _HtmlStyles.clear();
4032
4033 std::list<CHtmlElement>::iterator it = _HtmlDOM.Children.begin();
4034 while(it != _HtmlDOM.Children.end())
4035 {
4036 renderDOM(*it);
4037 ++it;
4038 }
4039
4040 endBuild();
4041
4042 //TGameTime renderStop = CTime::getLocalTime();
4043 //nlwarning("[%s] render: %.1fms (%s)\n", _Id.c_str(), (renderStop - renderStart), _URL.c_str());
4044 }
4045
4046 // ***************************************************************************
4047
4048 bool CGroupHTML::renderHtmlString(const std::string &html)
4049 {
4050 bool success;
4051
4052 // if we are already rendering, then queue up the next page
4053 if (_Browsing)
4054 {
4055 _DocumentHtml = html;
4056 _RenderNextTime = true;
4057
4058 return true;
4059 }
4060
4061 //
4062 _DocumentUrl = _URL;
4063 _DocumentHtml = html;
4064 _NextRefreshTime = 0;
4065 _RefreshUrl.clear();
4066
4067 if (trim(html).empty())
4068 {
4069 // clear the page
4070 beginBuild();
4071
4072 // clear previous page and state
4073 removeContent();
4074
4075 endBuild();
4076
4077 success = false;
4078 }
4079 else
4080 {
4081 // browser.css
4082 resetCssStyle();
4083
4084 // start new rendering
4085 _HtmlDOM = CHtmlElement(CHtmlElement::NONE, "<root>");
4086 _CurrentHTMLElement = NULL;
4087 success = parseHtml(html);
4088 if (success)
4089 {
4090 _WaitingForStylesheet = !_StylesheetQueue.empty();
4091 renderDocument();
4092 }
4093 else
4094 {
4095 std::string error = "ERROR: HTML parse failed.";
4096 error += toString("\nsize %d bytes", html.size());
4097 error += toString("\n---start---\n%s\n---end---\n", html.c_str());
4098 browseError(error.c_str());
4099 }
4100 }
4101
4102 return success;
4103 }
4104
4105 // ***************************************************************************
4106 void CGroupHTML::doBrowseAnchor(const std::string &anchor)
4107 {
4108 if (_Anchors.count(anchor) == 0)
4109 {
4110 return;
4111 }
4112
4113 CInterfaceElement *pIE = _Anchors.find(anchor)->second;
4114 if (pIE)
4115 {
4116 // hotspot depends on vertical/horizontal scrollbar
4117 CCtrlScroll *pSB = getScrollBar();
4118 if (pSB)
4119 {
4120 pSB->ensureVisible(pIE, Hotspot_Tx, Hotspot_Tx);
4121 }
4122 }
4123 }
4124
4125 // ***************************************************************************
4126
4127 void CGroupHTML::draw ()
4128 {
4129 uint8 CurrentAlpha = 255;
4130 // search a parent container
4131 CInterfaceGroup *gr = getParent();
4132 while (gr)
4133 {
4134 if (gr->isGroupContainer())
4135 {
4136 CGroupContainer *gc = static_cast<CGroupContainer *>(gr);
4137 CurrentAlpha = gc->getCurrentContainerAlpha();
4138 break;
4139 }
4140 gr = gr->getParent();
4141 }
4142 m_HtmlBackground.CurrentAlpha = CurrentAlpha;
4143 m_BodyBackground.CurrentAlpha = CurrentAlpha;
4144
4145 m_HtmlBackground.draw();
4146 m_BodyBackground.draw();
4147 CGroupScrollText::draw ();
4148 }
4149
4150 // ***************************************************************************
4151
4152 void CGroupHTML::beginBuild ()
4153 {
4154 _Browsing = true;
4155 }
4156
4157 void CGroupHTML::endBuild ()
4158 {
4159 // set the browser as complete
4160 _Browsing = false;
4161 updateRefreshButton();
4162
4163 // check that the title is set, or reset it (in the case the page
4164 // does not provide a title)
4165 if (_TitleString.empty())
4166 {
4167 setTitle(_TitlePrefix);
4168 }
4169
4170 invalidateCoords();
4171 }
4172
4173 // ***************************************************************************
4174
4175 void CGroupHTML::addHTTPGetParams (string &/* url */, bool /*trustedDomain*/)
4176 {
4177 }
4178
4179 // ***************************************************************************
4180
4181 void CGroupHTML::addHTTPPostParams (SFormFields &/* formfields */, bool /*trustedDomain*/)
4182 {
4183 }
4184
4185 // ***************************************************************************
4186
4187 string CGroupHTML::home () const
4188 {
4189 return Home;
4190 }
4191
4192 // ***************************************************************************
4193
4194 void CGroupHTML::removeContent ()
4195 {
4196 // Remove old document
4197 if (!_GroupListAdaptor)
4198 {
4199 _GroupListAdaptor = new CGroupListAdaptor(CViewBase::TCtorParam()); // deleted by the list
4200 _GroupListAdaptor->setId(getList()->getId() + ":GLA");
4201 _GroupListAdaptor->setResizeFromChildH(true);
4202 getList()->addChild (_GroupListAdaptor, true);
4203 }
4204
4205 // Group list adaptor not exist ?
4206 _GroupListAdaptor->clearGroups();
4207 _GroupListAdaptor->clearControls();
4208 _GroupListAdaptor->clearViews();
4209 CWidgetManager::getInstance()->clearViewUnders();
4210 CWidgetManager::getInstance()->clearCtrlsUnders();
4211
4212 // Clear all the context
4213 clearContext();
4214
4215 // Reset default background
4216 m_HtmlBackground.clear();
4217 m_BodyBackground.clear();
4218
4219 // TODO: DefaultBackgroundBitmapView should be removed from interface xml
4220 CViewBase *view = getView (DefaultBackgroundBitmapView);
4221 if (view)
4222 view->setActive(false);
4223
4224 paragraphChange ();
4225 }
4226
4227 // ***************************************************************************
4228 const std::string &CGroupHTML::selectTreeNodeRecurs(CGroupTree::SNode *node, const std::string &url)
4229 {
4230 static std::string emptyString;
4231 if(!node)
4232 {
4233 return emptyString;
4234 }
4235
4236 // if this node match
4237 if(actionLaunchUrlRecurs(node->AHName, node->AHParams, url))
4238 {
4239 return node->Id;
4240 }
4241 // fails => look into children
4242 else
4243 {
4244 for(uint i=0;i<node->Children.size();i++)
4245 {
4246 const string &childRes= selectTreeNodeRecurs(node->Children[i], url);
4247 if(!childRes.empty())
4248 return childRes;
4249 }
4250
4251 // none match...
4252 return emptyString;
4253 }
4254 }
4255
4256 // ***************************************************************************
4257 bool CGroupHTML::actionLaunchUrlRecurs(const std::string &ah, const std::string &params, const std::string &url)
4258 {
4259 // check if this action match
4260 if( (ah=="launch_help" || ah=="browse") && IActionHandler::getParam (params, "url") == url)
4261 {
4262 return true;
4263 }
4264 // can be a proc that contains launch_help/browse => look recurs
4265 else if(ah=="proc")
4266 {
4267 const std::string &procName= params;
4268 // look into this proc
4269 uint numActions= CWidgetManager::getInstance()->getParser()->getProcedureNumActions(procName);
4270 for(uint i=0;i<numActions;i++)
4271 {
4272 string procAh, procParams;
4273 if( CWidgetManager::getInstance()->getParser()->getProcedureAction(procName, i, procAh, procParams))
4274 {
4275 // recurs proc if needed!
4276 if (actionLaunchUrlRecurs(procAh, procParams, url))
4277 return true;
4278 }
4279 }
4280 }
4281
4282 return false;
4283 }
4284
4285 // ***************************************************************************
4286 void CGroupHTML::clearRefresh()
4287 {
4288 _URL.clear();
4289 updateRefreshButton();
4290 }
4291
4292 // ***************************************************************************
4293 void CGroupHTML::clearUndoRedo()
4294 {
4295 // erase any undo/redo
4296 _BrowseUndo.clear();
4297 _BrowseRedo.clear();
4298
4299 // update buttons validation
4300 updateUndoRedoButtons();
4301 }
4302
4303 // ***************************************************************************
4304 void CGroupHTML::pushUrlUndoRedo(const std::string &url)
4305 {
4306 // if same url, no op
4307 if(url==_AskedUrl)
4308 return;
4309
4310 // erase any redo, push undo, set current
4311 _BrowseRedo.clear();
4312 if(!_AskedUrl.empty())
4313 _BrowseUndo.push_back(_AskedUrl);
4314 _AskedUrl= url;
4315
4316 // limit undo
4317 while(_BrowseUndo.size()>MaxUrlUndoRedo)
4318 _BrowseUndo.pop_front();
4319
4320 // update buttons validation
4321 updateUndoRedoButtons();
4322 }
4323
4324 // ***************************************************************************
4325 void CGroupHTML::browseUndo()
4326 {
4327 if(_BrowseUndo.empty())
4328 return;
4329
4330 // push to redo, pop undo, and set current
4331 if (!_AskedUrl.empty())
4332 _BrowseRedo.push_front(_AskedUrl);
4333
4334 _AskedUrl= _BrowseUndo.back();
4335 _BrowseUndo.pop_back();
4336
4337 // update buttons validation
4338 updateUndoRedoButtons();
4339
4340 // and then browse the undoed url, with no undo/redo
4341 doBrowse(_AskedUrl.c_str());
4342 }
4343
4344 // ***************************************************************************
4345 void CGroupHTML::browseRedo()
4346 {
4347 if(_BrowseRedo.empty())
4348 return;
4349
4350 // push to undo, pop redo, and set current
4351 _BrowseUndo.push_back(_AskedUrl);
4352 _AskedUrl= _BrowseRedo.front();
4353 _BrowseRedo.pop_front();
4354
4355 // update buttons validation
4356 updateUndoRedoButtons();
4357
4358 // and then browse the redoed url, with no undo/redo
4359 doBrowse(_AskedUrl.c_str());
4360 }
4361
4362 // ***************************************************************************
4363 void CGroupHTML::updateUndoRedoButtons()
4364 {
4365 CCtrlBaseButton *butUndo= dynamic_cast<CCtrlBaseButton *>(CWidgetManager::getInstance()->getElementFromId(_BrowseUndoButton));
4366 CCtrlBaseButton *butRedo= dynamic_cast<CCtrlBaseButton *>(CWidgetManager::getInstance()->getElementFromId(_BrowseRedoButton));
4367
4368 // gray according to list size
4369 if(butUndo)
4370 butUndo->setFrozen(_BrowseUndo.empty());
4371 if(butRedo)
4372 butRedo->setFrozen(_BrowseRedo.empty());
4373 }
4374
4375 // ***************************************************************************
4376 void CGroupHTML::updateRefreshButton()
4377 {
4378 CCtrlBaseButton *butRefresh = dynamic_cast<CCtrlBaseButton *>(CWidgetManager::getInstance()->getElementFromId(_BrowseRefreshButton));
4379 if(butRefresh)
4380 {
4381 // connecting, rendering, or is missing url
4382 bool frozen = _CurlWWW || _Browsing || _URL.empty();
4383 butRefresh->setFrozen(frozen);
4384 }
4385 }
4386
4387 // ***************************************************************************
4388
4389 NLMISC_REGISTER_OBJECT(CViewBase, CGroupHTMLInputOffset, std::string, "html_input_offset");
4390
4391 CGroupHTMLInputOffset::CGroupHTMLInputOffset(const TCtorParam &param)
4392 : CInterfaceGroup(param),
4393 Offset(0)
4394 {
4395 }
4396
4397 xmlNodePtr CGroupHTMLInputOffset::serialize( xmlNodePtr parentNode, const char *type ) const
4398 {
4399 xmlNodePtr node = CInterfaceGroup::serialize( parentNode, type );
4400 if( node == NULL )
4401 return NULL;
4402
4403 xmlSetProp( node, BAD_CAST "type", BAD_CAST "html_input_offset" );
4404 xmlSetProp( node, BAD_CAST "y_offset", BAD_CAST toString( Offset ).c_str() );
4405
4406 return node;
4407 }
4408
4409 // ***************************************************************************
4410 bool CGroupHTMLInputOffset::parse(xmlNodePtr cur, CInterfaceGroup *parentGroup)
4411 {
4412 if (!CInterfaceGroup::parse(cur, parentGroup)) return false;
4413 CXMLAutoPtr ptr;
4414 // Get the url
4415 ptr = xmlGetProp (cur, (xmlChar*)"y_offset");
4416 if (ptr)
4417 fromString((const char*)ptr, Offset);
4418 return true;
4419 }
4420
4421 // ***************************************************************************
4422 int CGroupHTML::luaParseHtml(CLuaState &ls)
4423 {
4424 const char *funcName = "parseHtml";
4425 CLuaIHM::checkArgCount(ls, funcName, 1);
4426 CLuaIHM::checkArgType(ls, funcName, 1, LUA_TSTRING);
4427 std::string html = ls.toString(1);
4428
4429 parseHtml(html);
4430
4431 return 0;
4432 }
4433
4434 int CGroupHTML::luaClearRefresh(CLuaState &ls)
4435 {
4436 const char *funcName = "clearRefresh";
4437 CLuaIHM::checkArgCount(ls, funcName, 0);
4438
4439 clearRefresh();
4440
4441 return 0;
4442 }
4443
4444 int CGroupHTML::luaClearUndoRedo(CLuaState &ls)
4445 {
4446 const char *funcName = "clearUndoRedo";
4447 CLuaIHM::checkArgCount(ls, funcName, 0);
4448
4449 clearUndoRedo();
4450 return 0;
4451 }
4452
4453 // ***************************************************************************
4454 int CGroupHTML::luaBrowse(CLuaState &ls)
4455 {
4456 const char *funcName = "browse";
4457 CLuaIHM::checkArgCount(ls, funcName, 1);
4458 CLuaIHM::checkArgType(ls, funcName, 1, LUA_TSTRING);
4459 browse(ls.toString(1));
4460 return 0;
4461 }
4462
4463 // ***************************************************************************
4464 int CGroupHTML::luaRefresh(CLuaState &ls)
4465 {
4466 const char *funcName = "refresh";
4467 CLuaIHM::checkArgCount(ls, funcName, 0);
4468 refresh();
4469 return 0;
4470 }
4471
4472 // ***************************************************************************
4473 int CGroupHTML::luaRemoveContent(CLuaState &ls)
4474 {
4475 const char *funcName = "removeContent";
4476 CLuaIHM::checkArgCount(ls, funcName, 0);
4477 removeContent();
4478 return 0;
4479 }
4480
4481 // ***************************************************************************
4482 int CGroupHTML::luaRenderHtml(CLuaState &ls)
4483 {
4484 const char *funcName = "renderHtml";
4485 CLuaIHM::checkArgCount(ls, funcName, 1);
4486 CLuaIHM::checkArgType(ls, funcName, 1, LUA_TSTRING);
4487 std::string html = ls.toString(1);
4488
4489 // Always trust domain if rendered from lua
4490 _TrustedDomain = true;
4491 renderHtmlString(html);
4492
4493 return 0;
4494 }
4495
4496 // ***************************************************************************
4497 int CGroupHTML::luaSetBackground(CLuaState &ls)
4498 {
4499 const char *funcName = "setBackground";
4500 CLuaIHM::checkArgCount(ls, funcName, 3);
4501 CLuaIHM::checkArgType(ls, funcName, 1, LUA_TSTRING);
4502 CLuaIHM::checkArgType(ls, funcName, 2, LUA_TBOOLEAN);
4503 CLuaIHM::checkArgType(ls, funcName, 3, LUA_TBOOLEAN);
4504 std::string image = ls.toString(1);
4505 bool scale = ls.toBoolean(2);
4506 bool repeat = ls.toBoolean(3);
4507
4508 setBackground(image, scale, repeat);
4509
4510 return 0;
4511 }
4512
4513 // ***************************************************************************
4514 int CGroupHTML::luaInsertText(CLuaState &ls)
4515 {
4516 const char *funcName = "insertText";
4517 CLuaIHM::checkArgCount(ls, funcName, 3);
4518 CLuaIHM::checkArgType(ls, funcName, 1, LUA_TSTRING);
4519 CLuaIHM::checkArgType(ls, funcName, 2, LUA_TSTRING);
4520 CLuaIHM::checkArgType(ls, funcName, 3, LUA_TBOOLEAN);
4521
4522 string name = ls.toString(1);
4523 string text = ls.toString(2);
4524
4525 if (!_Forms.empty())
4526 {
4527 for (uint i=0; i<_Forms.back().Entries.size(); i++)
4528 {
4529 if (_Forms.back().Entries[i].TextArea && _Forms.back().Entries[i].Name == name)
4530 {
4531 // Get the edit box view
4532 CInterfaceGroup *group = _Forms.back().Entries[i].TextArea->getGroup ("eb");
4533 if (group)
4534 {
4535 // Should be a CGroupEditBox
4536 CGroupEditBox *editBox = dynamic_cast<CGroupEditBox*>(group);
4537 if (editBox)
4538 editBox->writeString(text, false, ls.toBoolean(3));
4539 }
4540 }
4541 }
4542 }
4543
4544 return 0;
4545 }
4546
4547 // ***************************************************************************
4548 int CGroupHTML::luaAddString(CLuaState &ls)
4549 {
4550 const char *funcName = "addString";
4551 CLuaIHM::checkArgCount(ls, funcName, 1);
4552 CLuaIHM::checkArgType(ls, funcName, 1, LUA_TSTRING);
4553 addString(ls.toString(1));
4554 return 0;
4555 }
4556
4557 // ***************************************************************************
4558 int CGroupHTML::luaAddImage(CLuaState &ls)
4559 {
4560 const char *funcName = "addImage";
4561 CLuaIHM::checkArgCount(ls, funcName, 2);
4562 CLuaIHM::checkArgType(ls, funcName, 1, LUA_TSTRING);
4563 CLuaIHM::checkArgType(ls, funcName, 2, LUA_TBOOLEAN);
4564 if (!_Paragraph)
4565 {
4566 newParagraph(0);
4567 paragraphChange();
4568 }
4569
4570 CStyleParams style;
4571 style.GlobalColor = ls.toBoolean(2);
4572
4573 string url = getLink();
4574 if (!url.empty())
4575 {
4576 string params = "name=" + getId() + "|url=" + getLink ();
4577 addButton(CCtrlButton::PushButton, "", ls.toString(1), ls.toString(1),
4578 "", "browse", params.c_str(), "", style);
4579 }
4580 else
4581 {
4582 addImage("", ls.toString(1), false, style);
4583 }
4584
4585
4586 return 0;
4587 }
4588
4589 // ***************************************************************************
4590 int CGroupHTML::luaShowDiv(CLuaState &ls)
4591 {
4592 const char *funcName = "showDiv";
4593 CLuaIHM::checkArgCount(ls, funcName, 2);
4594 CLuaIHM::checkArgType(ls, funcName, 1, LUA_TSTRING);
4595 CLuaIHM::checkArgType(ls, funcName, 2, LUA_TBOOLEAN);
4596
4597 if (!_Groups.empty())
4598 {
4599 for (uint i=0; i<_Groups.size(); i++)
4600 {
4601 CInterfaceGroup *group = _Groups[i];
4602 if (group->getName() == ls.toString(1))
4603 {
4604 group->setActive(ls.toBoolean(2));
4605 }
4606 }
4607 }
4608 return 0;
4609 }
4610
4611 // ***************************************************************************
4612 void CGroupHTML::setURL(const std::string &url)
4613 {
4614 browse(url.c_str());
4615 }
4616
4617 void CGroupHTML::setHTML(const std::string &html)
4618 {
4619 renderHtmlString(html);
4620 }
4621
4622 void CGroupHTML::setHome(const std::string &home)
4623 {
4624 Home = home;
4625 }
4626
4627 // ***************************************************************************
4628 void CGroupHTML::parseStylesheetFile(const std::string &fname)
4629 {
4630 CIFile css;
4631 if (css.open(fname))
4632 {
4633 uint32 remaining = css.getFileSize();
4634 std::string content;
4635 try {
4636 while(!css.eof() && remaining > 0)
4637 {
4638 const uint BUF_SIZE = 4096;
4639 char buf[BUF_SIZE];
4640
4641 uint32 readJustNow = std::min(remaining, BUF_SIZE);
4642 css.serialBuffer((uint8 *)&buf, readJustNow);
4643 content.append(buf, readJustNow);
4644 remaining -= readJustNow;
4645 }
4646
4647 _Style.parseStylesheet(content);
4648 }
4649 catch(const Exception &e)
4650 {
4651 nlwarning("exception while reading css file '%s'", e.what());
4652 }
4653 }
4654 else
4655 {
4656 nlwarning("Stylesheet file '%s' not found (%s)", fname.c_str(), _URL.c_str());
4657 }
4658 }
4659
4660 // ***************************************************************************
4661 bool CGroupHTML::parseHtml(const std::string &htmlString)
4662 {
4663 CHtmlElement *parsedDOM;
4664 if (_CurrentHTMLElement == NULL)
4665 {
4666 // parse under <root> element (clean dom)
4667 parsedDOM = &_HtmlDOM;
4668 }
4669 else
4670 {
4671 // parse under currently rendered <lua> element
4672 parsedDOM = _CurrentHTMLElement;
4673 }
4674
4675 std::vector<CHtmlParser::StyleLink> links;
4676
4677 CHtmlParser parser;
4678 parser.getDOM(htmlString, *parsedDOM, _HtmlStyles, links);
4679
4680 // <link> elements inserted from lua::parseHtml are ignored
4681 if (_CurrentHTMLElement == NULL && !links.empty())
4682 {
4683 addStylesheetDownload(links);
4684 }
4685 else if (_CurrentHTMLElement != NULL)
4686 {
4687 // Called from active element (lua)
4688 // <style> order is not preserved as document is already being rendered
4689 for(uint i = 0; i < _HtmlStyles.size(); ++i)
4690 {
4691 if (!_HtmlStyles[i].empty())
4692 {
4693 _Style.parseStylesheet(_HtmlStyles[i]);
4694 }
4695 }
4696 _HtmlStyles.clear();
4697 }
4698
4699 // this should rarely fail as first element should be <html>
4700 bool success = parsedDOM->Children.size() > 0;
4701
4702 std::list<CHtmlElement>::iterator it = parsedDOM->Children.begin();
4703 while(it != parsedDOM->Children.end())
4704 {
4705 if (it->Type == CHtmlElement::ELEMENT_NODE && it->Value == "html")
4706 {
4707 // move newly parsed childs from <body> into siblings
4708 if (_CurrentHTMLElement) {
4709 std::list<CHtmlElement>::iterator it2 = it->Children.begin();
4710 while(it2 != it->Children.end())
4711 {
4712 if (it2->Type == CHtmlElement::ELEMENT_NODE && it2->Value == "body")
4713 {
4714 spliceFragment(it2);
4715 break;
4716 }
4717 ++it2;
4718 }
4719 // remove <html> fragment from current element child
4720 it = parsedDOM->Children.erase(it);
4721 }
4722 else
4723 {
4724 // remove link to <root> (html->parent == '<root>') or css selector matching will break
4725 it->parent = NULL;
4726 ++it;
4727 }
4728 continue;
4729 }
4730
4731 // skip over other non-handled element
4732 ++it;
4733 }
4734
4735 return success;
4736 }
4737
4738 void CGroupHTML::spliceFragment(std::list<CHtmlElement>::iterator src)
4739 {
4740 if(!_CurrentHTMLElement->parent)
4741 {
4742 nlwarning("BUG: Current node is missing parent element. unable to splice fragment");
4743 return;
4744 }
4745
4746 // get the iterators for current element (<lua>) and next sibling
4747 std::list<CHtmlElement>::iterator currentElement;
4748 currentElement = std::find(_CurrentHTMLElement->parent->Children.begin(), _CurrentHTMLElement->parent->Children.end(), *_CurrentHTMLElement);
4749 if (currentElement == _CurrentHTMLElement->parent->Children.end())
4750 {
4751 nlwarning("BUG: unable to find current element iterator from parent");
4752 return;
4753 }
4754
4755 // where fragment should be moved
4756 std::list<CHtmlElement>::iterator insertBefore;
4757 if (_CurrentHTMLNextSibling == NULL)
4758 {
4759 insertBefore = _CurrentHTMLElement->parent->Children.end();
4760 } else {
4761 // get iterator for nextSibling
4762 insertBefore = std::find(_CurrentHTMLElement->parent->Children.begin(), _CurrentHTMLElement->parent->Children.end(), *_CurrentHTMLNextSibling);
4763 }
4764
4765 _CurrentHTMLElement->parent->Children.splice(insertBefore, src->Children);
4766
4767 // reindex moved elements
4768 CHtmlElement *prev = NULL;
4769 uint childIndex = _CurrentHTMLElement->childIndex;
4770 while(currentElement != _CurrentHTMLElement->parent->Children.end())
4771 {
4772 if (currentElement->Type == CHtmlElement::ELEMENT_NODE)
4773 {
4774 if (prev != NULL)
4775 {
4776 currentElement->parent = _CurrentHTMLElement->parent;
4777 currentElement->childIndex = childIndex;
4778 currentElement->previousSibling = prev;
4779 prev->nextSibling = &(*currentElement);
4780 }
4781
4782 childIndex++;
4783 prev = &(*currentElement);
4784 }
4785 ++currentElement;
4786 }
4787 }
4788
4789 // ***************************************************************************
4790 inline bool isDigit(char c, uint base = 16)
4791 {
4792 if (c>='0' && c<='9') return true;
4793 if (base != 16) return false;
4794 if (c>='A' && c<='F') return true;
4795 if (c>='a' && c<='f') return true;
4796 return false;
4797 }
4798
4799 // ***************************************************************************
4800 inline char convertHexDigit(char c)
4801 {
4802 if (c>='0' && c<='9') return c-'0';
4803 if (c>='A' && c<='F') return c-'A'+10;
4804 if (c>='a' && c<='f') return c-'a'+10;
4805 return 0;
4806 }
4807
4808 // ***************************************************************************
4809 std::string CGroupHTML::decodeHTMLEntities(const std::string &str)
4810 {
4811 std::string result;
4812 result.reserve(str.size() + (str.size() >> 2));
4813 uint last, pos;
4814
4815 for (uint i=0; i<str.length(); ++i)
4816 {
4817 // HTML entity
4818 if (str[i] == '&' && (str.length()-i) >= 4)
4819 {
4820 pos = i+1;
4821
4822 // unicode character
4823 if (str[pos] == '#')
4824 {
4825 ++pos;
4826
4827 // using decimal by default
4828 uint base = 10;
4829
4830 // using hexadecimal if &#x
4831 if (str[pos] == 'x')
4832 {
4833 base = 16;
4834 ++pos;
4835 }
4836
4837 // setup "last" to point at the first character following "&#x?[0-9a-f]+"
4838 for (last = pos; last < str.length(); ++last) if (!isDigit(str[last], base)) break;
4839
4840 // make sure that at least 1 digit was found
4841 // and have the terminating ';' to complete the token: "&#x?[0-9a-f]+;"
4842 if (last == pos || str[last] != ';')
4843 {
4844 result += str[i];
4845 continue;
4846 }
4847
4848 u32char c = 0;
4849
4850 // convert digits to unicode character
4851 while (pos < last) c = convertHexDigit(str[pos++]) + (c * u32char(base));
4852
4853 // append our new character to the result string
4854 CUtfStringView::append(result, c);
4855
4856 // move 'i' forward to point at the ';' .. the for(...) will increment i to point to next char
4857 i = last;
4858
4859 continue;
4860 }
4861
4862 // special xml characters
4863 if (str.substr(i+1,5)=="quot;") { i+=5; result+='\"'; continue; }
4864 if (str.substr(i+1,4)=="amp;") { i+=4; result+='&'; continue; }
4865 if (str.substr(i+1,3)=="lt;") { i+=3; result+='<'; continue; }
4866 if (str.substr(i+1,3)=="gt;") { i+=3; result+='>'; continue; }
4867 }
4868
4869 // all the special cases are catered for... treat this as a normal character
4870 result += str[i];
4871 }
4872
4873 return result;
4874 }
4875
4876 // ***************************************************************************
4877 std::string CGroupHTML::getAbsoluteUrl(const std::string &url)
4878 {
4879 CUrlParser uri(url);
4880 if (uri.isAbsolute())
4881 return url;
4882
4883 uri.inherit(_URL);
4884
4885 return uri.toString();
4886 }
4887
4888 // ***************************************************************************
4889 void CGroupHTML::resetCssStyle()
4890 {
4891 _WaitingForStylesheet = false;
4892 _StylesheetQueue.clear();
4893 _Style.reset();
4894 _Style = _BrowserStyle;
4895 }
4896
4897 // ***************************************************************************
4898 std::string CGroupHTML::HTMLOListElement::getListMarkerText() const
4899 {
4900 std::string ret;
4901 sint32 number = Value;
4902
4903 if (Type == "disc")
4904 {
4905 // (ucchar)0x2219;
4906 ret = "\xe2\x88\x99 ";
4907 }
4908 else if (Type == "circle")
4909 {
4910 // (uchar)0x26AA;
4911 ret = "\xe2\x9a\xaa ";
4912 }
4913 else if (Type == "square")
4914 {
4915 // (ucchar)0x25AA;
4916 ret = "\xe2\x96\xaa ";
4917 }
4918 else if (Type == "a" || Type == "A")
4919 {
4920 // @see toAlphabeticOrNumeric in WebKit
4921 static const char lower[26] = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
4922 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z' };
4923 static const char upper[26] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
4924 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z' };
4925 uint size = 26;
4926 if (number < 1)
4927 {
4928 ret = toString(number);
4929 }
4930 else
4931 {
4932 const char* digits = (Type == "A" ? upper : lower);
4933 while(number > 0)
4934 {
4935 --number;
4936 ret.insert(ret.begin(), digits[number % size]);
4937 number /= size;
4938 }
4939 }
4940 ret += ". ";
4941 }
4942 else if (Type == "i" || Type == "I")
4943 {
4944 // @see toRoman in WebKit
4945 static const char lower[7] = {'i', 'v', 'x', 'l', 'c', 'd', 'm'};
4946 static const char upper[7] = {'I', 'V', 'X', 'L', 'C', 'D', 'M'};
4947
4948 if (number < 1 || number > 3999)
4949 {
4950 ret = toString(number);
4951 }
4952 else
4953 {
4954 const char* digits = (Type == "I" ? upper : lower);
4955 uint8 i, d=0;
4956 do
4957 {
4958 uint32 num = number % 10;
4959 if (num % 5 < 4)
4960 {
4961 for (i = num % 5; i > 0; i--)
4962 {
4963 ret.insert(ret.begin(), digits[d]);
4964 }
4965 }
4966 if (num >= 4 && num <= 8)
4967 {
4968 ret.insert(ret.begin(), digits[d + 1]);
4969 }
4970 if (num == 9)
4971 {
4972 ret.insert(ret.begin(), digits[d + 2]);
4973 }
4974 if (num % 5 == 4)
4975 {
4976 ret.insert(ret.begin(), digits[d]);
4977 }
4978 number /= 10;
4979 d += 2;
4980 }
4981 while (number > 0);
4982
4983 if (Type == "I")
4984 {
4985 ret = toUpper(ret);
4986 }
4987 }
4988 ret += ". ";
4989 }
4990 else
4991 {
4992 ret = toString(Value) + ". ";
4993 }
4994
4995 return ret;
4996 }
4997
4998 void CGroupHTML::HTMLMeterElement::readValues(const CHtmlElement &elm)
4999 {
5000 if (!elm.hasAttribute("value") || !fromString(elm.getAttribute("value"), value))
5001 value = 0.f;
5002 if (!elm.hasAttribute("min") || !fromString(elm.getAttribute("min"), min))
5003 min = 0.f;
5004 if (!elm.hasAttribute("max") || !fromString(elm.getAttribute("max"), max))
5005 max = 1.f;
5006
5007 // ensure min < max
5008 if (max < min)
5009 std::swap(min, max);
5010
5011 if (!elm.hasAttribute("low") || !fromString(elm.getAttribute("low"), low))
5012 low = min;
5013 if (!elm.hasAttribute("high") || !fromString(elm.getAttribute("high"), high))
5014 high = max;
5015
5016 if (!elm.hasAttribute("optimum") || !fromString(elm.getAttribute("optimum"), optimum))
5017 optimum = (max - min) / 2.f;
5018
5019 // ensure low < high
5020 if (high < low)
5021 std::swap(low, high);
5022 if (low < min)
5023 low = min;
5024 if (high > max)
5025 high = max;
5026 }
5027
5028 float CGroupHTML::HTMLMeterElement::getValueRatio() const
5029 {
5030 if (max <= min)
5031 return 0.f;
5032
5033 return (value - min) / (max - min);
5034 }
5035
5036 CGroupHTML::HTMLMeterElement::EValueRegion CGroupHTML::HTMLMeterElement::getValueRegion() const
5037 {
5038 if (optimum <= low)
5039 {
5040 // low region is optimum
5041 if (value <= low)
5042 return VALUE_OPTIMUM;
5043 else if (value <= high)
5044 return VALUE_SUB_OPTIMAL;
5045
5046 return VALUE_EVEN_LESS_GOOD;
5047 }
5048 else if (optimum >= high)
5049 {
5050 // high region is optimum
5051 if (value >= high)
5052 return VALUE_OPTIMUM;
5053 else if (value >= low)
5054 return VALUE_SUB_OPTIMAL;
5055
5056 return VALUE_EVEN_LESS_GOOD;
5057 }
5058
5059 // middle region is optimum
5060 if (value >= low && value <= high)
5061 return VALUE_OPTIMUM;
5062
5063 return VALUE_SUB_OPTIMAL;
5064 }
5065
5066 NLMISC::CRGBA CGroupHTML::HTMLMeterElement::getBarColor(const CHtmlElement &elm, CCssStyle &style) const
5067 {
5068 // color meter (inactive) bar segment
5069 // firefox:: meter { background:none; background-color: #555; },
5070 // webkit:: meter::-webkit-meter-bar { background:none; background-color: #555; }
5071 // webkit makes background color visible when padding is added
5072 CRGBA color(150, 150, 150, 255);
5073
5074 // use webkit pseudo elements as thats easier than firefox pseudo classes
5075 // background-color is expected to be set from browser.css
5076 style.pushStyle();
5077 style.applyStyle(elm.getPseudo(":-webkit-meter-bar"));
5078 if(style.hasStyle("background-color"))
5079 color = style.Current.Background.color;
5080 style.popStyle();
5081
5082 return color;
5083 }
5084
5085 NLMISC::CRGBA CGroupHTML::HTMLMeterElement::getValueColor(const CHtmlElement &elm, CCssStyle &style) const
5086 {
5087 // background-color is expected to be set from browser.css
5088 CRGBA color;
5089 style.pushStyle();
5090 switch(getValueRegion())
5091 {
5092 case VALUE_OPTIMUM:
5093 {
5094 style.applyStyle(elm.getPseudo(":-webkit-meter-optimum-value"));
5095 if (style.hasStyle("background-color"))
5096 color = style.Current.Background.color;
5097 break;
5098 }
5099 case VALUE_SUB_OPTIMAL:
5100 {
5101 style.applyStyle(elm.getPseudo(":-webkit-meter-suboptimum-value"));
5102 if (style.hasStyle("background-color"))
5103 color = style.Current.Background.color;
5104 break;
5105 }
5106 case VALUE_EVEN_LESS_GOOD: // fall through
5107 default:
5108 {
5109 style.applyStyle(elm.getPseudo(":-webkit-meter-even-less-good-value"));
5110 if (style.hasStyle("background-color"))
5111 color = style.Current.Background.color;
5112 break;
5113 }
5114 }//switch
5115 style.popStyle();
5116
5117 return color;
5118 }
5119
5120 // ****************************************************************************
5121 void CGroupHTML::HTMLProgressElement::readValues(const CHtmlElement &elm)
5122 {
5123 if (!elm.hasAttribute("value") || !fromString(elm.getAttribute("value"), value))
5124 value = 0.f;
5125 if (!elm.hasAttribute("max") || !fromString(elm.getAttribute("max"), max))
5126 max = 1.f;
5127
5128 if (value > max)
5129 value = max;
5130 }
5131
5132 // ****************************************************************************
5133 float CGroupHTML::HTMLProgressElement::getValueRatio() const
5134 {
5135 if (max > 0.f)
5136 return value / max;
5137 return 0.f;
5138 }
5139
5140 // ****************************************************************************
5141 NLMISC::CRGBA CGroupHTML::HTMLProgressElement::getBarColor(const CHtmlElement &elm, CCssStyle &style) const
5142 {
5143 CRGBA color;
5144
5145 style.pushStyle();
5146 style.applyStyle(elm.getPseudo(":-webkit-progress-bar"));
5147 if (style.hasStyle("background-color"))
5148 color = style.Current.Background.color;
5149 style.popStyle();
5150
5151 return color;
5152 }
5153
5154 // ****************************************************************************
5155 NLMISC::CRGBA CGroupHTML::HTMLProgressElement::getValueColor(const CHtmlElement &elm, CCssStyle &style) const
5156 {
5157 CRGBA color;
5158
5159 style.pushStyle();
5160 style.applyStyle(elm.getPseudo(":-webkit-progress-value"));
5161 if (style.hasStyle("background-color"))
5162 color = style.Current.Background.color;
5163 style.popStyle();
5164
5165 return color;
5166 }
5167
5168 // ****************************************************************************
5169 void CGroupHTML::getCellsParameters(const CHtmlElement &elm, bool inherit)
5170 {
5171 CGroupHTML::CCellParams cellParams;
5172 if (!_CellParams.empty() && inherit)
5173 cellParams = _CellParams.back();
5174
5175 if (!_Style.hasStyle("background-color") && elm.hasNonEmptyAttribute("bgcolor"))
5176 {
5177 CRGBA c;
5178 if (scanHTMLColor(elm.getAttribute("bgcolor").c_str(), c))
5179 _Style.Current.Background.color = c;
5180 }
5181 cellParams.BgColor = _Style.Current.Background.color;
5182
5183 if (elm.hasAttribute("nowrap") || _Style.Current.WhiteSpace == "nowrap")
5184 cellParams.NoWrap = true;
5185
5186 if (elm.hasNonEmptyAttribute("l_margin"))
5187 fromString(elm.getAttribute("l_margin"), cellParams.LeftMargin);
5188
5189 if (_Style.hasStyle("height"))
5190 cellParams.Height = _Style.Current.Height;
5191 else if (elm.hasNonEmptyAttribute("height"))
5192 fromString(elm.getAttribute("height"), cellParams.Height);
5193
5194 {
5195 std::string align;
5196 // having text-align on table/tr should not override td align attribute
5197 if (_Style.hasStyle("text-align"))
5198 align = _Style.Current.TextAlign;
5199 else if (elm.hasNonEmptyAttribute("align"))
5200 align = toLowerAscii(elm.getAttribute("align"));
5201
5202 if (align == "left")
5203 cellParams.Align = CGroupCell::Left;
5204 else if (align == "center")
5205 cellParams.Align = CGroupCell::Center;
5206 else if (align == "right")
5207 cellParams.Align = CGroupCell::Right;
5208 else if (align != "justify")
5209 align.clear();
5210
5211 // copy td align (can be empty) attribute back into css
5212 _Style.Current.TextAlign = align;
5213 }
5214
5215 {
5216 std::string valign;
5217 if (_Style.hasStyle("vertical-align"))
5218 valign = _Style.Current.VerticalAlign;
5219 else if (elm.hasNonEmptyAttribute("valign"))
5220 valign = toLowerAscii(elm.getAttribute("valign"));
5221
5222 if (valign == "top")
5223 cellParams.VAlign = CGroupCell::Top;
5224 else if (valign == "middle")
5225 cellParams.VAlign = CGroupCell::Middle;
5226 else if (valign == "bottom")
5227 cellParams.VAlign = CGroupCell::Bottom;
5228 }
5229
5230 _CellParams.push_back (cellParams);
5231 }
5232
5233 // ***************************************************************************
5234 void CGroupHTML::insertFormImageButton(const std::string &name, const std::string &tooltip, const std::string &src, const std::string &over, const std::string &formId, const std::string &action, uint32 minWidth, const std::string &templateName)
5235 {
5236 _FormSubmit.push_back(SFormSubmitButton(formId, name, "", "image", action));
5237 // Action handler parameters
5238 std::string param = "name=" + getId() + "|button=" + toString(_FormSubmit.size()-1);
5239
5240 // Add the ctrl button
5241 addButton (CCtrlButton::PushButton, name, src, src, over, "html_submit_form", param.c_str(), tooltip.c_str(), _Style.Current);
5242 }
5243
5244 // ***************************************************************************
5245 void CGroupHTML::insertFormTextButton(const std::string &name, const std::string &tooltip, const std::string &value, const std::string &formId, const std::string &formAction, uint32 minWidth, const std::string &templateName)
5246 {
5247 _FormSubmit.push_back(SFormSubmitButton(formId, name, value, "submit", formAction));
5248 // Action handler parameters
5249 string param = "name=" + getId() + "|button=" + toString(_FormSubmit.size()-1);
5250
5251 // Add the ctrl button
5252 if (!_Paragraph)
5253 {
5254 newParagraph (0);
5255 paragraphChange ();
5256 }
5257
5258 string buttonTemplate(!templateName.empty() ? templateName : DefaultButtonGroup);
5259 typedef pair<string, string> TTmplParam;
5260 vector<TTmplParam> tmplParams;
5261 tmplParams.push_back(TTmplParam("id", name));
5262 tmplParams.push_back(TTmplParam("onclick", "html_submit_form"));
5263 tmplParams.push_back(TTmplParam("onclick_param", param));
5264 tmplParams.push_back(TTmplParam("active", "true"));
5265 if (minWidth > 0) tmplParams.push_back(TTmplParam("wmin", toString(minWidth)));
5266 CInterfaceGroup *buttonGroup = CWidgetManager::getInstance()->getParser()->createGroupInstance(buttonTemplate, _Paragraph->getId(), tmplParams);
5267 if (buttonGroup)
5268 {
5269 // Add the ctrl button
5270 CCtrlTextButton *ctrlButton = dynamic_cast<CCtrlTextButton*>(buttonGroup->getCtrl("button"));
5271 if (!ctrlButton) ctrlButton = dynamic_cast<CCtrlTextButton*>(buttonGroup->getCtrl("b"));
5272 if (ctrlButton)
5273 {
5274 ctrlButton->setModulateGlobalColorAll (_Style.Current.GlobalColor);
5275 ctrlButton->setTextModulateGlobalColorNormal(_Style.Current.GlobalColorText);
5276 ctrlButton->setTextModulateGlobalColorOver(_Style.Current.GlobalColorText);
5277 ctrlButton->setTextModulateGlobalColorPushed(_Style.Current.GlobalColorText);
5278
5279 // Translate the tooltip
5280 if (!tooltip.empty())
5281 {
5282 if (CI18N::hasTranslation(tooltip))
5283 {
5284 ctrlButton->setDefaultContextHelp(CI18N::get(tooltip));
5285 }
5286 else
5287 {
5288 ctrlButton->setDefaultContextHelp(tooltip);
5289 }
5290 }
5291
5292 ctrlButton->setText(value);
5293
5294 setTextButtonStyle(ctrlButton, _Style.Current);
5295 }
5296 getParagraph()->addChild (buttonGroup);
5297 paragraphChange ();
5298 }
5299 }
5300
5301 // ***************************************************************************
5302 void CGroupHTML::htmlA(const CHtmlElement &elm)
5303 {
5304 _A.push_back(true);
5305 _Link.push_back ("");
5306 _LinkTitle.push_back("");
5307 _LinkClass.push_back("");
5308 if (elm.hasClass("ryzom-ui-button"))
5309 _LinkClass.back() = "ryzom-ui-button";
5310
5311 // #fragment works with both ID and NAME so register both
5312 if (elm.hasNonEmptyAttribute("name"))
5313 _AnchorName.push_back(elm.getAttribute("name"));
5314 if (elm.hasNonEmptyAttribute("title"))
5315 _LinkTitle.back() = elm.getAttribute("title");
5316 if (elm.hasNonEmptyAttribute("href"))
5317 {
5318 string suri = elm.getAttribute("href");
5319 if(suri.find("ah:") == 0)
5320 {
5321 if (_TrustedDomain || suri.find("ah:script:") == 0)
5322 _Link.back() = suri;
5323 }
5324 else
5325 {
5326 // convert href from "?key=val" into "http://domain.com/?key=val"
5327 _Link.back() = getAbsoluteUrl(suri);
5328 }
5329 }
5330
5331 renderPseudoElement(":before", elm);
5332 }
5333
5334 void CGroupHTML::htmlAend(const CHtmlElement &elm)
5335 {
5336 renderPseudoElement(":after", elm);
5337
5338 popIfNotEmpty(_A);
5339 popIfNotEmpty(_Link);
5340 popIfNotEmpty(_LinkTitle);
5341 popIfNotEmpty(_LinkClass);
5342 }
5343
5344 // ***************************************************************************
5345 void CGroupHTML::htmlBASE(const CHtmlElement &elm)
5346 {
5347 if (!_ReadingHeadTag || _IgnoreBaseUrlTag)
5348 return;
5349
5350 if (elm.hasNonEmptyAttribute("href"))
5351 {
5352 CUrlParser uri(elm.getAttribute("href"));
5353 if (uri.isAbsolute())
5354 {
5355 _URL = uri.toString();
5356 _IgnoreBaseUrlTag = true;
5357 }
5358 }
5359 }
5360
5361 // ***************************************************************************
5362 void CGroupHTML::htmlBODY(const CHtmlElement &elm)
5363 {
5364 // override <body> (or <html>) css style attribute
5365 if (elm.hasNonEmptyAttribute("bgcolor"))
5366 _Style.applyStyle("background-color: " + elm.getAttribute("bgcolor"));
5367
5368 if (m_HtmlBackground.isEmpty())
5369 setupBackground(&m_HtmlBackground);
5370 else
5371 setupBackground(&m_BodyBackground);
5372
5373 renderPseudoElement(":before", elm);
5374 }
5375
5376 // ***************************************************************************
5377 void CGroupHTML::htmlBR(const CHtmlElement &elm)
5378 {
5379 if (!_Paragraph || _Paragraph->getNumChildren() == 0)
5380 {
5381 addString("\n");
5382 }
5383 else
5384 {
5385 endParagraph();
5386 }
5387 }
5388
5389 // ***************************************************************************
5390 void CGroupHTML::htmlBUTTON(const CHtmlElement &elm)
5391 {
5392 std::string name = elm.getAttribute("name");
5393 std::string value = elm.getAttribute("value");
5394 std::string formId = elm.getAttribute("form");
5395 std::string formAction = elm.getAttribute("formaction");
5396 std::string tooltip = elm.getAttribute("tooltip");
5397 bool disabled = elm.hasAttribute("disabled");
5398
5399 if (formId.empty() && _FormOpen)
5400 {
5401 formId = _Forms.back().id;
5402 }
5403
5404 if (!formAction.empty())
5405 {
5406 formAction = getAbsoluteUrl(formAction);
5407 }
5408
5409 _FormSubmit.push_back(SFormSubmitButton(formId, name, value, "text", formAction));
5410 // Action handler parameters
5411 std::string param;
5412 if (!disabled)
5413 {
5414 if (elm.getAttribute("type") == "submit")
5415 {
5416 param = "ah:html_submit_form&name=" + getId() + "&button=" + toString(_FormSubmit.size()-1);
5417 }
5418 else
5419 {
5420 param = "ah:";
5421 }
5422 }
5423
5424 _A.push_back(true);
5425 _Link.push_back(param);
5426 _LinkTitle.push_back(tooltip);
5427 _LinkClass.push_back("ryzom-ui-button");
5428
5429 // TODO: this creates separate button element
5430 //renderPseudoElement(":before", elm);
5431 }
5432 void CGroupHTML::htmlBUTTONend(const CHtmlElement &elm)
5433 {
5434 // TODO: this creates separate button element
5435 //renderPseudoElement(":after", elm);
5436
5437 popIfNotEmpty(_A);
5438 popIfNotEmpty(_Link);
5439 popIfNotEmpty(_LinkTitle);
5440 popIfNotEmpty(_LinkClass);
5441 }
5442
5443 // ***************************************************************************
5444 void CGroupHTML::htmlDD(const CHtmlElement &elm)
5445 {
5446 if (_DL.empty())
5447 return;
5448
5449 // if there was no closing tag for <dt>, then remove <dt> style
5450 if (_DL.back().DT)
5451 {
5452 nlwarning("BUG: nested DT in DD");
5453 _DL.back().DT = false;
5454 }
5455
5456 if (_DL.back().DD)
5457 {
5458 nlwarning("BUG: nested DD in DD");
5459 _DL.back().DD = false;
5460 popIfNotEmpty(_Indent);
5461 }
5462
5463 _DL.back().DD = true;
5464 _Indent.push_back(getIndent() + ULIndent);
5465
5466 if (!_LI)
5467 {
5468 _LI = true;
5469 newParagraph(ULBeginSpace);
5470 }
5471 else
5472 {
5473 newParagraph(LIBeginSpace);
5474 }
5475
5476 renderPseudoElement(":before", elm);
5477 }
5478
5479 void CGroupHTML::htmlDDend(const CHtmlElement &elm)
5480 {
5481 if (_DL.empty())
5482 return;
5483
5484 renderPseudoElement(":after", elm);
5485
5486 // parser will process two DD in a row as nested when first DD is not closed
5487 if (_DL.back().DD)
5488 {
5489 _DL.back().DD = false;
5490 popIfNotEmpty(_Indent);
5491 }
5492 }
5493
5494 // ***************************************************************************
5495 void CGroupHTML::htmlDIV(const CHtmlElement &elm)
5496 {
5497 _DivName = elm.getAttribute("name");
5498
5499 string instClass = elm.getAttribute("class");
5500
5501 // use generic template system
5502 if (_TrustedDomain && !instClass.empty() && instClass == "ryzom-ui-grouptemplate")
5503 {
5504 string style = elm.getAttribute("style");
5505 string id = elm.getAttribute("id");
5506 if (id.empty())
5507 id = "DIV" + toString(getNextAutoIdSeq());
5508
5509 typedef pair<string, string> TTmplParam;
5510 vector<TTmplParam> tmplParams;
5511
5512 string templateName;
5513 if (!style.empty())
5514 {
5515 TStyle styles = parseStyle(style);
5516 TStyle::iterator it;
5517 for (it=styles.begin(); it != styles.end(); it++)
5518 {
5519 if ((*it).first == "template")
5520 templateName = (*it).second;
5521 else
5522 tmplParams.push_back(TTmplParam((*it).first, (*it).second));
5523 }
5524 }
5525
5526 if (!templateName.empty())
5527 {
5528 string parentId;
5529 bool haveParentDiv = getDiv() != NULL;
5530 if (haveParentDiv)
5531 parentId = getDiv()->getId();
5532 else
5533 {
5534 if (!_Paragraph)
5535 newParagraph (0);
5536
5537 parentId = _Paragraph->getId();
5538 }
5539
5540 CInterfaceGroup *inst = CWidgetManager::getInstance()->getParser()->createGroupInstance(templateName, parentId, tmplParams);
5541 if (inst)
5542 {
5543 inst->setId(parentId+":"+id);
5544 inst->updateCoords();
5545 if (haveParentDiv)
5546 {
5547 inst->setParent(getDiv());
5548 inst->setParentSize(getDiv());
5549 inst->setParentPos(getDiv());
5550 inst->setPosRef(Hotspot_TL);
5551 inst->setParentPosRef(Hotspot_TL);
5552 getDiv()->addGroup(inst);
5553 }
5554 else
5555 {
5556 getParagraph()->addChild(inst);
5557 paragraphChange();
5558 }
5559 _Divs.push_back(inst);
5560 }
5561 }
5562 }
5563
5564 renderPseudoElement(":before", elm);
5565 }
5566
5567 void CGroupHTML::htmlDIVend(const CHtmlElement &elm)
5568 {
5569 renderPseudoElement(":after", elm);
5570 _DivName.clear();
5571 popIfNotEmpty(_Divs);
5572 }
5573
5574 // ***************************************************************************
5575 void CGroupHTML::htmlDL(const CHtmlElement &elm)
5576 {
5577 _DL.push_back(HTMLDListElement());
5578 _LI = _DL.size() > 1 || !_UL.empty();
5579
5580 renderPseudoElement(":before", elm);
5581 }
5582
5583 void CGroupHTML::htmlDLend(const CHtmlElement &elm)
5584 {
5585 if (_DL.empty())
5586 return;
5587
5588 renderPseudoElement(":after", elm);
5589
5590 // unclosed DT
5591 if (_DL.back().DT)
5592 {
5593 nlwarning("BUG: unclosed DT in DL");
5594 }
5595
5596 // unclosed DD
5597 if (_DL.back().DD)
5598 {
5599 popIfNotEmpty(_Indent);
5600 nlwarning("BUG: unclosed DD in DL");
5601 }
5602
5603 popIfNotEmpty (_DL);
5604 }
5605
5606 // ***************************************************************************
5607 void CGroupHTML::htmlDT(const CHtmlElement &elm)
5608 {
5609 if (_DL.empty())
5610 return;
5611
5612 // TODO: check if nested tags still happen and fix it in parser
5613 // : remove special handling for nesting and let it happen
5614
5615 // html parser and libxml2 should prevent nested tags like these
5616 if (_DL.back().DD)
5617 {
5618 nlwarning("BUG: nested DD in DT");
5619
5620 _DL.back().DD = false;
5621 popIfNotEmpty(_Indent);
5622 }
5623
5624 // html parser and libxml2 should prevent nested tags like these
5625 if (_DL.back().DT)
5626 {
5627 nlwarning("BUG: nested DT in DT");
5628 }
5629
5630 _DL.back().DT = true;
5631
5632 if (!_LI)
5633 {
5634 _LI = true;
5635 newParagraph(ULBeginSpace);
5636 }
5637 else
5638 {
5639 newParagraph(LIBeginSpace);
5640 }
5641
5642 renderPseudoElement(":before", elm);
5643 }
5644
5645 void CGroupHTML::htmlDTend(const CHtmlElement &elm)
5646 {
5647 if (_DL.empty())
5648 return;
5649
5650 renderPseudoElement(":after", elm);
5651
5652 _DL.back().DT = false;
5653 }
5654
5655 // ***************************************************************************
5656 void CGroupHTML::htmlFONT(const CHtmlElement &elm)
5657 {
5658 if (elm.hasNonEmptyAttribute("color"))
5659 {
5660 CRGBA color;
5661 if (scanHTMLColor(elm.getAttribute("color").c_str(), color))
5662 _Style.Current.TextColor = color;
5663 }
5664
5665 if (elm.hasNonEmptyAttribute("size"))
5666 {
5667 uint fontsize;
5668 fromString(elm.getAttribute("size"), fontsize);
5669 _Style.Current.FontSize = fontsize;
5670 }
5671 }
5672
5673 // ***************************************************************************
5674 void CGroupHTML::htmlFORM(const CHtmlElement &elm)
5675 {
5676 _FormOpen = true;
5677
5678 // Build the form
5679 CGroupHTML::CForm form;
5680 // id check is case sensitive and auto id's are uppercase
5681 form.id = toLowerAscii(trim(elm.getAttribute("id")));
5682 if (form.id.empty())
5683 {
5684 form.id = toString("FORM%d", _Forms.size());
5685 }
5686
5687 // Get the action name
5688 if (elm.hasNonEmptyAttribute("action"))
5689 {
5690 form.Action = getAbsoluteUrl(elm.getAttribute("action"));
5691 }
5692 else
5693 {
5694 form.Action = _URL;
5695 }
5696
5697 _Forms.push_back(form);
5698
5699 renderPseudoElement(":before", elm);
5700 }
5701
5702 void CGroupHTML::htmlFORMend(const CHtmlElement &elm)
5703 {
5704 _FormOpen = false;
5705 renderPseudoElement(":after", elm);
5706 }
5707
5708 // ***************************************************************************
5709 void CGroupHTML::htmlH(const CHtmlElement &elm)
5710 {
5711 newParagraph(PBeginSpace);
5712 renderPseudoElement(":before", elm);
5713 }
5714
5715 void CGroupHTML::htmlHend(const CHtmlElement &elm)
5716 {
5717 renderPseudoElement(":after", elm);
5718 }
5719
5720 // ***************************************************************************
5721 void CGroupHTML::htmlHEAD(const CHtmlElement &elm)
5722 {
5723 _ReadingHeadTag = !_IgnoreHeadTag;
5724 _IgnoreHeadTag = true;
5725 }
5726
5727 void CGroupHTML::htmlHEADend(const CHtmlElement &elm)
5728 {
5729 _ReadingHeadTag = false;
5730 }
5731
5732 // ***************************************************************************
5733 void CGroupHTML::htmlHR(const CHtmlElement &elm)
5734 {
5735 CInterfaceGroup *sep = CWidgetManager::getInstance()->getParser()->createGroupInstance("html_hr", "", NULL, 0);
5736 if (sep)
5737 {
5738 CViewBitmap *bitmap = dynamic_cast<CViewBitmap*>(sep->getView("hr"));
5739 if (bitmap)
5740 {
5741 bitmap->setColor(_Style.Current.TextColor);
5742 if (_Style.Current.Width > 0)
5743 {
5744 clamp(_Style.Current.Width, 1, 32000);
5745 bitmap->setW(_Style.Current.Width);
5746 bitmap->setSizeRef(CInterfaceElement::none);
5747 }
5748 if (_Style.Current.Height > 0)
5749 {
5750 clamp(_Style.Current.Height, 1, 1000);
5751 bitmap->setH(_Style.Current.Height);
5752 }
5753 }
5754
5755 renderPseudoElement(":before", elm);
5756 addHtmlGroup(sep, 0);
5757 renderPseudoElement(":after", elm);
5758 }
5759 }
5760
5761 // ***************************************************************************
5762 void CGroupHTML::htmlHTML(const CHtmlElement &elm)
5763 {
5764 if (elm.hasNonEmptyAttribute("style"))
5765 _Style.applyStyle(elm.getAttribute("style"));
5766
5767 _Style.Root = _Style.Current;
5768
5769 setupBackground(&m_HtmlBackground);
5770 }
5771
5772 // ***************************************************************************
5773 void CGroupHTML::htmlI(const CHtmlElement &elm)
5774 {
5775 _Localize = true;
5776 renderPseudoElement(":before", elm);
5777 }
5778
5779 void CGroupHTML::htmlIend(const CHtmlElement &elm)
5780 {
5781 renderPseudoElement(":after", elm);
5782 _Localize = false;
5783 }
5784
5785 // ***************************************************************************
5786 void CGroupHTML::htmlIMG(const CHtmlElement &elm)
5787 {
5788 std::string src = trim(elm.getAttribute("src"));
5789 if (src.empty())
5790 {
5791 // no 'src' attribute, or empty
5792 return;
5793 }
5794
5795 float tmpf;
5796 std::string id = elm.getAttribute("id");
5797
5798 if (elm.hasNonEmptyAttribute("width"))
5799 getPercentage(_Style.Current.Width, tmpf, elm.getAttribute("width").c_str());
5800 if (elm.hasNonEmptyAttribute("height"))
5801 getPercentage(_Style.Current.Height, tmpf, elm.getAttribute("height").c_str());
5802
5803 // Get the global color name
5804 if (elm.hasAttribute("global_color"))
5805 _Style.Current.GlobalColor = true;
5806
5807 // Tooltip
5808 // keep "alt" attribute for backward compatibility
5809 std::string tooltip = elm.getAttribute("alt");
5810 // tooltip
5811 if (elm.hasNonEmptyAttribute("title"))
5812 tooltip = elm.getAttribute("title");
5813
5814 // Mouse over image
5815 string overSrc = elm.getAttribute("data-over-src");
5816
5817 // inside a/button with valid url (ie, button is not disabled)
5818 string url = getLink();
5819 if (getA() && !url.empty() && getParent() && getParent()->getParent())
5820 {
5821 string params = "name=" + getId() + "|url=" + url;
5822 addButton(CCtrlButton::PushButton, id, src, src, overSrc, "browse", params.c_str(), tooltip, _Style.Current);
5823 }
5824 else
5825 if (!tooltip.empty() || !overSrc.empty())
5826 {
5827 addButton(CCtrlButton::PushButton, id, src, src, overSrc, "", "", tooltip, _Style.Current);
5828 }
5829 else
5830 {
5831 // Get the option to reload (class==reload)
5832 bool reloadImg = false;
5833
5834 if (elm.hasNonEmptyAttribute("style"))
5835 {
5836 string styleString = elm.getAttribute("style");
5837 TStyle styles = parseStyle(styleString);
5838 TStyle::iterator it;
5839
5840 it = styles.find("reload");
5841 if (it != styles.end() && (*it).second == "1")
5842 reloadImg = true;
5843 }
5844
5845 addImage(id, elm.getAttribute("src"), reloadImg, _Style.Current);
5846 }
5847 }
5848
5849 // ***************************************************************************
5850 void CGroupHTML::htmlINPUT(const CHtmlElement &elm)
5851 {
5852 if (_Forms.empty())
5853 return;
5854
5855 // read general property
5856 string id = elm.getAttribute("id");
5857
5858 // Widget template name (old)
5859 string templateName = elm.getAttribute("z_btn_tmpl");
5860 // Input name is the new
5861 if (elm.hasNonEmptyAttribute("z_input_tmpl"))
5862 templateName = elm.getAttribute("z_input_tmpl");
5863
5864 // Widget minimal width
5865 uint32 minWidth = 0;
5866 fromString(elm.getAttribute("z_input_width"), minWidth);
5867
5868 // <input type="...">
5869 std::string type = trim(elm.getAttribute("type"));
5870 if (type.empty())
5871 {
5872 // no 'type' attribute, or empty
5873 return;
5874 }
5875
5876 // Global color flag
5877 if (elm.hasAttribute("global_color"))
5878 _Style.Current.GlobalColor = true;
5879
5880 // Tooltip
5881 std::string tooltip = elm.getAttribute("alt");
5882
5883 if (type == "image")
5884 {
5885 string name = elm.getAttribute("name");
5886 string src = elm.getAttribute("src");
5887 string over = elm.getAttribute("data-over-src");
5888 string formId = elm.getAttribute("form");
5889 string formAction = elm.getAttribute("formaction");
5890
5891 if (formId.empty() && _FormOpen) {
5892 formId = _Forms.back().id;
5893 }
5894
5895 insertFormImageButton(name, tooltip, src, over, formId, formAction, minWidth, templateName);
5896 }
5897 else if (type == "button" || type == "submit")
5898 {
5899 string name = elm.getAttribute("name");
5900 string value = elm.getAttribute("value");
5901 string formId = elm.getAttribute("form");
5902 string formAction = elm.getAttribute("formaction");
5903
5904 if (formId.empty() && _FormOpen) {
5905 formId = _Forms.back().id;
5906 }
5907
5908 insertFormTextButton(name, tooltip, value, formId, formAction, minWidth, templateName);
5909 }
5910 else if (type == "text")
5911 {
5912 // Get the string name
5913 string name = elm.getAttribute("name");
5914 string ucValue = elm.getAttribute("value");
5915
5916 uint size = 20;
5917 uint maxlength = 1024;
5918 if (elm.hasNonEmptyAttribute("size"))
5919 fromString(elm.getAttribute("size"), size);
5920 if (elm.hasNonEmptyAttribute("maxlength"))
5921 fromString(elm.getAttribute("maxlength"), maxlength);
5922
5923 // ryzom client used to have 'size' attribute in pixels, (12 == was default font size)
5924 if (_Style.hasStyle("-ryzom-input-size-px") && _Style.getStyle("-ryzom-input-size-px") == "true")
5925 size = size / 12;
5926
5927 string textTemplate(!templateName.empty() ? templateName : DefaultFormTextGroup);
5928 // Add the editbox
5929 CInterfaceGroup *textArea = addTextArea (textTemplate, name.c_str (), 1, size, false, ucValue, maxlength);
5930 if (textArea)
5931 {
5932 // Add the text area to the form
5933 CGroupHTML::CForm::CEntry entry;
5934 entry.Name = name;
5935 entry.TextArea = textArea;
5936 _Forms.back().Entries.push_back (entry);
5937 }
5938 }
5939 else if (type == "checkbox" || type == "radio")
5940 {
5941 renderPseudoElement(":before", elm);
5942
5943 CCtrlButton::EType btnType;
5944 string name = elm.getAttribute("name");
5945 string normal = elm.getAttribute("src");
5946 string pushed;
5947 string over;
5948 string ucValue = "on";
5949 bool checked = elm.hasAttribute("checked");
5950
5951 // TODO: unknown if empty attribute should override or not
5952 if (elm.hasNonEmptyAttribute("value"))
5953 ucValue = elm.getAttribute("value");
5954
5955 if (type == "radio")
5956 {
5957 btnType = CCtrlButton::RadioButton;
5958 normal = DefaultRadioButtonBitmapNormal;
5959 pushed = DefaultRadioButtonBitmapPushed;
5960 over = DefaultRadioButtonBitmapOver;
5961 }
5962 else
5963 {
5964 btnType = CCtrlButton::ToggleButton;
5965 normal = DefaultCheckBoxBitmapNormal;
5966 pushed = DefaultCheckBoxBitmapPushed;
5967 over = DefaultCheckBoxBitmapOver;
5968 }
5969
5970 // Add the ctrl button
5971 CCtrlButton *checkbox = addButton (btnType, name, normal, pushed, over, "", "", tooltip, _Style.Current);
5972 if (checkbox)
5973 {
5974 if (btnType == CCtrlButton::RadioButton)
5975 {
5976 // override with 'id' because radio buttons share same name
5977 if (!id.empty())
5978 checkbox->setId(id);
5979
5980 // group together buttons with same name
5981 CForm &form = _Forms.back();
5982 bool notfound = true;
5983 for (uint i=0; i<form.Entries.size(); i++)
5984 {
5985 if (form.Entries[i].Name == name && form.Entries[i].Checkbox != NULL && form.Entries[i].Checkbox->getType() == CCtrlButton::RadioButton)
5986 {
5987 checkbox->initRBRefFromRadioButton(form.Entries[i].Checkbox);
5988 notfound = false;
5989 break;
5990 }
5991 }
5992 if (notfound)
5993 {
5994 // this will start a new group (initRBRef() would take first button in group container otherwise)
5995 checkbox->initRBRefFromRadioButton(checkbox);
5996 }
5997 }
5998
5999 checkbox->setPushed (checked);
6000
6001 // Add the button to the form
6002 CGroupHTML::CForm::CEntry entry;
6003 entry.Name = name;
6004 entry.Value = decodeHTMLEntities(ucValue);
6005 entry.Checkbox = checkbox;
6006 _Forms.back().Entries.push_back (entry);
6007 }
6008 renderPseudoElement(":after", elm);
6009 }
6010 else if (type == "hidden")
6011 {
6012 if (elm.hasNonEmptyAttribute("name"))
6013 {
6014 // Get the name
6015 string name = elm.getAttribute("name");
6016
6017 // Get the value
6018 string ucValue = elm.getAttribute("value");
6019
6020 // Add an entry
6021 CGroupHTML::CForm::CEntry entry;
6022 entry.Name = name;
6023 entry.Value = decodeHTMLEntities(ucValue);
6024 _Forms.back().Entries.push_back (entry);
6025 }
6026 }
6027 }
6028
6029 // ***************************************************************************
6030 void CGroupHTML::htmlLI(const CHtmlElement &elm)
6031 {
6032 if (_UL.empty())
6033 return;
6034
6035 // UL, OL top margin if this is the first LI
6036 if (!_LI)
6037 {
6038 _LI = true;
6039 newParagraph(ULBeginSpace);
6040 }
6041 else
6042 {
6043 newParagraph(LIBeginSpace);
6044 }
6045
6046 // OL list index can be overridden by <li value="1"> attribute
6047 if (elm.hasNonEmptyAttribute("value"))
6048 fromString(elm.getAttribute("value"), _UL.back().Value);
6049
6050 string str = _UL.back().getListMarkerText();
6051 addString (str);
6052
6053 // list-style-type: outside
6054 if (_CurrentViewLink)
6055 {
6056 getParagraph()->setFirstViewIndent(-_CurrentViewLink->getMaxUsedW());
6057 }
6058
6059 flushString ();
6060
6061 // after marker
6062 renderPseudoElement(":before", elm);
6063
6064 _UL.back().Value++;
6065 }
6066
6067 void CGroupHTML::htmlLIend(const CHtmlElement &elm)
6068 {
6069 renderPseudoElement(":after", elm);
6070 }
6071
6072 // ***************************************************************************
6073 void CGroupHTML::htmlLUA(const CHtmlElement &elm)
6074 {
6075 // we receive an embeded lua script
6076 _ParsingLua = _TrustedDomain; // Only parse lua if TrustedDomain
6077 _LuaScript.clear();
6078 }
6079
6080 void CGroupHTML::htmlLUAend(const CHtmlElement &elm)
6081 {
6082 if (_ParsingLua && _TrustedDomain)
6083 {
6084 _ParsingLua = false;
6085 // execute the embeded lua script
6086 _LuaScript = "\nlocal __CURRENT_WINDOW__=\""+this->_Id+"\" \n"+_LuaScript;
6087 CLuaManager::getInstance().executeLuaScript(_LuaScript, true);
6088 }
6089 }
6090
6091 // ***************************************************************************
6092 void CGroupHTML::htmlMETA(const CHtmlElement &elm)
6093 {
6094 if (!_ReadingHeadTag)
6095 return;
6096
6097 std::string httpEquiv = elm.getAttribute("http-equiv");
6098 std::string httpContent = elm.getAttribute("content");
6099 if (httpEquiv.empty() || httpContent.empty())
6100 {
6101 return;
6102 }
6103
6104 // only first http-equiv="refresh" should be handled
6105 if (_RefreshUrl.empty() && httpEquiv == "refresh")
6106 {
6107 const CWidgetManager::SInterfaceTimes &times = CWidgetManager::getInstance()->getInterfaceTimes();
6108 double timeSec = times.thisFrameMs / 1000.0f;
6109
6110 string::size_type pos = httpContent.find_first_of(";");
6111 if (pos == string::npos)
6112 {
6113 fromString(httpContent, _NextRefreshTime);
6114 _RefreshUrl = _URL;
6115 }
6116 else
6117 {
6118 fromString(httpContent.substr(0, pos), _NextRefreshTime);
6119
6120 pos = toLowerAscii(httpContent).find("url=");
6121 if (pos != string::npos)
6122 _RefreshUrl = getAbsoluteUrl(httpContent.substr(pos + 4));
6123 }
6124
6125 _NextRefreshTime += timeSec;
6126 }
6127 }
6128
6129 // ***************************************************************************
6130 void CGroupHTML::htmlMETER(const CHtmlElement &elm)
6131 {
6132 HTMLMeterElement meter;
6133 meter.readValues(elm);
6134
6135 std::string id = "meter";
6136 if (elm.hasAttribute("id"))
6137 id = elm.getAttribute("id");
6138
6139 // width: 5em, height: 1em
6140 uint32 width = _Style.Current.Width > -1 ? _Style.Current.Width : _Style.Current.FontSize * 5;
6141 uint32 height = _Style.Current.Height > -1 ? _Style.Current.Height : _Style.Current.FontSize;
6142 // FIXME: only using border-top
6143 uint32 border = _Style.Current.Border.Top.Width.getValue() > -1 ? _Style.Current.Border.Top.Width.getValue() : 0;
6144
6145 uint barw = (uint) (width * meter.getValueRatio());
6146 CRGBA bgColor = meter.getBarColor(elm, _Style);
6147 CRGBA valueColor = meter.getValueColor(elm, _Style);
6148
6149 typedef pair<string, string> TTmplParam;
6150 vector<TTmplParam> tmplParams;
6151 tmplParams.push_back(TTmplParam("id", id));
6152 tmplParams.push_back(TTmplParam("active", "true"));
6153 tmplParams.push_back(TTmplParam("w", toString(width)));
6154 tmplParams.push_back(TTmplParam("h", toString(height)));
6155 tmplParams.push_back(TTmplParam("border_x2", toString(border*2)));
6156 tmplParams.push_back(TTmplParam("bgtexture", "blank.tga"));
6157 tmplParams.push_back(TTmplParam("bgcolor", bgColor.toString()));
6158 tmplParams.push_back(TTmplParam("value_w", toString(barw)));
6159 tmplParams.push_back(TTmplParam("value_texture", "blank.tga"));
6160 tmplParams.push_back(TTmplParam("value_color", valueColor.toString()));
6161
6162 CInterfaceGroup *gr = CWidgetManager::getInstance()->getParser()->createGroupInstance("html_meter", getParagraph()->getId(), &tmplParams[0], (uint)tmplParams.size());
6163 if (gr)
6164 {
6165 renderPseudoElement(":before", elm);
6166 getParagraph()->addChild(gr);
6167 renderPseudoElement(":after", elm);
6168
6169 // ignore any inner elements
6170 _IgnoreChildElements = true;
6171 }
6172 }
6173
6174 // ***************************************************************************
6175 void CGroupHTML::htmlOBJECT(const CHtmlElement &elm)
6176 {
6177 _ObjectType = elm.getAttribute("type");
6178 _ObjectData = elm.getAttribute("data");
6179 _ObjectMD5Sum = elm.getAttribute("id");
6180 _ObjectAction = elm.getAttribute("standby");
6181 _Object = true;
6182 }
6183
6184 void CGroupHTML::htmlOBJECTend(const CHtmlElement &elm)
6185 {
6186
6187
6188 if (_ObjectType=="application/ryzom-data")
6189 {
6190 if (!_TrustedDomain)
6191 return;
6192
6193 if (!_ObjectData.empty())
6194 {
6195 if (addBnpDownload(_ObjectData, _ObjectAction, _ObjectScript, _ObjectMD5Sum))
6196 {
6197 CLuaManager::getInstance().executeLuaScript("\nlocal __ALLREADYDL__=true\n"+_ObjectScript, true);
6198 }
6199 _ObjectScript.clear();
6200 }
6201 }
6202 else if (_ObjectType=="application/ryzom-tutorial")
6203 {
6204 while(strFindReplace(_ObjectScript, "[", "〈"));
6205 while(strFindReplace(_ObjectScript, "]", "〉"));
6206 CLuaManager::getInstance().executeLuaScript("\ngame:executeTutorial([["+_ObjectScript+"]])\n", true);
6207 _ObjectScript.clear();
6208 }
6209 else if (_ObjectType=="application/ryzom-script")
6210 {
6211 while(strFindReplace(_ObjectScript, "[", "〈"));
6212 while(strFindReplace(_ObjectScript, "]", "〉"));
6213 CLuaManager::getInstance().executeLuaScript("\ngame:executeRyzomScript([["+_ObjectScript+"]])\n", true);
6214 _ObjectScript.clear();
6215 }
6216 _Object = false;
6217 }
6218
6219 // ***************************************************************************
6220 void CGroupHTML::htmlOL(const CHtmlElement &elm)
6221 {
6222 sint32 start = 1;
6223 std::string type("1");
6224
6225 if (elm.hasNonEmptyAttribute("start"))
6226 fromString(elm.getAttribute("start"), start);
6227 if (elm.hasNonEmptyAttribute("type"))
6228 type = elm.getAttribute("type");
6229
6230 _UL.push_back(HTMLOListElement(start, type));
6231 // if LI is already present
6232 _LI = _UL.size() > 1 || _DL.size() > 1;
6233 _Indent.push_back(getIndent() + ULIndent);
6234
6235 renderPseudoElement(":before", elm);
6236 }
6237
6238 void CGroupHTML::htmlOLend(const CHtmlElement &elm)
6239 {
6240 htmlULend(elm);
6241 }
6242
6243 // ***************************************************************************
6244 void CGroupHTML::htmlOPTION(const CHtmlElement &elm)
6245 {
6246 _SelectOption = true;
6247 _SelectOptionStr.clear();
6248
6249 // Got one form ?
6250 if (_Forms.empty() || _Forms.back().Entries.empty())
6251 return;
6252
6253 _Forms.back().Entries.back().SelectValues.push_back(elm.getAttribute("value"));
6254
6255 if (elm.hasAttribute("selected"))
6256 _Forms.back().Entries.back().InitialSelection = (sint)_Forms.back().Entries.back().SelectValues.size() - 1;
6257
6258 if (elm.hasAttribute("disabled"))
6259 _Forms.back().Entries.back().sbOptionDisabled = (sint)_Forms.back().Entries.back().SelectValues.size() - 1;
6260 }
6261
6262 void CGroupHTML::htmlOPTIONend(const CHtmlElement &elm)
6263 {
6264 if (_Forms.empty() || _Forms.back().Entries.empty())
6265 return;
6266
6267 // use option text as value
6268 if (!elm.hasAttribute("value"))
6269 {
6270 _Forms.back().Entries.back().SelectValues.back() = _SelectOptionStr;
6271 }
6272
6273 // insert the parsed text into the select control
6274 CDBGroupComboBox *cb = _Forms.back().Entries.back().ComboBox;
6275 if (cb)
6276 {
6277 uint lineIndex = cb->getNumTexts();
6278 cb->addText(_SelectOptionStr);
6279 if (_Forms.back().Entries.back().sbOptionDisabled == lineIndex)
6280 {
6281 cb->setGrayed(lineIndex, true);
6282 }
6283 }
6284 else
6285 {
6286 CGroupMenu *sb = _Forms.back().Entries.back().SelectBox;
6287 if (sb)
6288 {
6289 uint lineIndex = sb->getNumLine();
6290 sb->addLine(_SelectOptionStr, "", "");
6291
6292 if (_Forms.back().Entries.back().sbOptionDisabled == lineIndex)
6293 {
6294 sb->setGrayedLine(lineIndex, true);
6295 }
6296 else
6297 {
6298 // create option line checkbox, CGroupMenu is taking ownership of the checbox
6299 CInterfaceGroup *ig = CWidgetManager::getInstance()->getParser()->createGroupInstance("menu_checkbox", "", NULL, 0);
6300 if (ig)
6301 {
6302 CCtrlButton *cb = dynamic_cast<CCtrlButton *>(ig->getCtrl("b"));
6303 if (cb)
6304 {
6305 if (_Forms.back().Entries.back().sbMultiple)
6306 {
6307 cb->setType(CCtrlButton::ToggleButton);
6308 cb->setTexture(DefaultCheckBoxBitmapNormal);
6309 cb->setTexturePushed(DefaultCheckBoxBitmapPushed);
6310 cb->setTextureOver(DefaultCheckBoxBitmapOver);
6311 }
6312 else
6313 {
6314 cb->setType(CCtrlButton::RadioButton);
6315 cb->setTexture(DefaultRadioButtonBitmapNormal);
6316 cb->setTexturePushed(DefaultRadioButtonBitmapPushed);
6317 cb->setTextureOver(DefaultRadioButtonBitmapOver);
6318
6319 if (_Forms.back().Entries.back().sbRBRef == NULL)
6320 _Forms.back().Entries.back().sbRBRef = cb;
6321
6322 cb->initRBRefFromRadioButton(_Forms.back().Entries.back().sbRBRef);
6323 }
6324
6325 cb->setPushed(_Forms.back().Entries.back().InitialSelection == lineIndex);
6326 sb->setUserGroupLeft(lineIndex, ig);
6327 }
6328 else
6329 {
6330 nlwarning("Failed to get 'b' element from 'menu_checkbox' template");
6331 delete ig;
6332 }
6333 }
6334 }
6335 }
6336 }
6337 }
6338
6339 // ***************************************************************************
6340 void CGroupHTML::htmlP(const CHtmlElement &elm)
6341 {
6342 newParagraph(PBeginSpace);
6343 renderPseudoElement(":before", elm);
6344 }
6345
6346 void CGroupHTML::htmlPend(const CHtmlElement &elm)
6347 {
6348 renderPseudoElement(":after", elm);
6349 }
6350
6351 // ***************************************************************************
6352 void CGroupHTML::htmlPRE(const CHtmlElement &elm)
6353 {
6354 _PRE.push_back(true);
6355 newParagraph(0);
6356
6357 renderPseudoElement(":before", elm);
6358 }
6359
6360 void CGroupHTML::htmlPREend(const CHtmlElement &elm)
6361 {
6362 renderPseudoElement(":after", elm);
6363
6364 popIfNotEmpty(_PRE);
6365 }
6366
6367 // ***************************************************************************
6368 void CGroupHTML::htmlPROGRESS(const CHtmlElement &elm)
6369 {
6370 HTMLProgressElement progress;
6371 progress.readValues(elm);
6372
6373 std::string id = "progress";
6374 if (elm.hasAttribute("id"))
6375 id = elm.getAttribute("id");
6376
6377 // width: 10em, height: 1em
6378 uint32 width = _Style.Current.Width > -1 ? _Style.Current.Width : _Style.Current.FontSize * 10;
6379 uint32 height = _Style.Current.Height > -1 ? _Style.Current.Height : _Style.Current.FontSize;
6380 // FIXME: only using border-top
6381 uint32 border = _Style.Current.Border.Top.Width.getValue() > -1 ? _Style.Current.Border.Top.Width.getValue() : 0;
6382
6383 uint barw = (uint) (width * progress.getValueRatio());
6384 CRGBA bgColor = progress.getBarColor(elm, _Style);
6385 CRGBA valueColor = progress.getValueColor(elm, _Style);
6386
6387 typedef pair<string, string> TTmplParam;
6388 vector<TTmplParam> tmplParams;
6389 tmplParams.push_back(TTmplParam("id", id));
6390 tmplParams.push_back(TTmplParam("active", "true"));
6391 tmplParams.push_back(TTmplParam("w", toString(width)));
6392 tmplParams.push_back(TTmplParam("h", toString(height)));
6393 tmplParams.push_back(TTmplParam("border_x2", toString(border*2)));
6394 tmplParams.push_back(TTmplParam("bgtexture", "blank.tga"));
6395 tmplParams.push_back(TTmplParam("bgcolor", bgColor.toString()));
6396 tmplParams.push_back(TTmplParam("value_w", toString(barw)));
6397 tmplParams.push_back(TTmplParam("value_texture", "blank.tga"));
6398 tmplParams.push_back(TTmplParam("value_color", valueColor.toString()));
6399
6400 CInterfaceGroup *gr = CWidgetManager::getInstance()->getParser()->createGroupInstance("html_progress", getParagraph()->getId(), &tmplParams[0], (uint)tmplParams.size());
6401 if (gr)
6402 {
6403 renderPseudoElement(":before", elm);
6404 getParagraph()->addChild(gr);
6405 renderPseudoElement(":after", elm);
6406
6407 // ignore any inner elements
6408 _IgnoreChildElements = true;
6409 }
6410 }
6411
6412 // ***************************************************************************
6413 void CGroupHTML::htmlSCRIPT(const CHtmlElement &elm)
6414 {
6415 _IgnoreText = true;
6416 }
6417
6418 void CGroupHTML::htmlSCRIPTend(const CHtmlElement &elm)
6419 {
6420 _IgnoreText = false;
6421 }
6422
6423 // ***************************************************************************
6424 void CGroupHTML::htmlSELECT(const CHtmlElement &elm)
6425 {
6426 if (_Forms.empty())
6427 return;
6428
6429 // A select box
6430 string name = elm.getAttribute("name");
6431 bool multiple = elm.hasAttribute("multiple");
6432 sint32 size = 0;
6433
6434 if (elm.hasNonEmptyAttribute("size"))
6435 fromString(elm.getAttribute("size"), size);
6436
6437 CGroupHTML::CForm::CEntry entry;
6438 entry.Name = name;
6439 entry.sbMultiple = multiple;
6440 if (size > 1 || multiple)
6441 {
6442 entry.InitialSelection = -1;
6443 CGroupMenu *sb = addSelectBox(DefaultFormSelectBoxMenuGroup, name.c_str());
6444 if (sb)
6445 {
6446 if (size < 1)
6447 size = 4;
6448
6449 if (_Style.Current.Width > -1)
6450 sb->setMinW(_Style.Current.Width);
6451
6452 if (_Style.Current.Height > -1)
6453 sb->setMinH(_Style.Current.Height);
6454
6455 sb->setMaxVisibleLine(size);
6456 sb->setFontSize(_Style.Current.FontSize, false);
6457 }
6458
6459 entry.SelectBox = sb;
6460 }
6461 else
6462 {
6463 CDBGroupComboBox *cb = addComboBox(DefaultFormSelectGroup, name.c_str());
6464 entry.ComboBox = cb;
6465
6466 if (cb)
6467 {
6468 // create view text
6469 cb->updateCoords();
6470 setTextStyle(cb->getViewText(), _Style.Current);
6471 }
6472 }
6473 _Forms.back().Entries.push_back (entry);
6474 }
6475
6476 void CGroupHTML::htmlSELECTend(const CHtmlElement &elm)
6477 {
6478 _SelectOption = false;
6479 if (_Forms.empty() || _Forms.back().Entries.empty())
6480 return;
6481
6482 CDBGroupComboBox *cb = _Forms.back().Entries.back().ComboBox;
6483 if (cb)
6484 {
6485 cb->setSelectionNoTrigger(_Forms.back().Entries.back().InitialSelection);
6486 // TODO: magic padding
6487 cb->setW(cb->evalContentWidth() + 16);
6488 }
6489 }
6490
6491 // ***************************************************************************
6492 void CGroupHTML::htmlSTYLE(const CHtmlElement &elm)
6493 {
6494 _IgnoreText = true;
6495 }
6496
6497 void CGroupHTML::htmlSTYLEend(const CHtmlElement &elm)
6498 {
6499 _IgnoreText = false;
6500 }
6501
6502 // ***************************************************************************
6503 void CGroupHTML::htmlTABLE(const CHtmlElement &elm)
6504 {
6505 // Get cells parameters
6506 getCellsParameters(elm, false);
6507
6508 CGroupTable *table = new CGroupTable(TCtorParam());
6509
6510 if (elm.hasNonEmptyAttribute("id"))
6511 table->setId(getCurrentGroup()->getId() + ":" + elm.getAttribute("id"));
6512 else
6513 table->setId(getCurrentGroup()->getId() + ":TABLE" + toString(getNextAutoIdSeq()));
6514
6515 // TODO: border-spacing: 2em;
6516 {
6517 if (elm.hasNonEmptyAttribute("cellspacing"))
6518 fromString(elm.getAttribute("cellspacing"), table->CellSpacing);
6519
6520 // TODO: cssLength, horiz/vert values
6521 if (_Style.hasStyle("border-spacing"))
6522 fromString(_Style.getStyle("border-spacing"), table->CellSpacing);
6523
6524 // overrides border-spacing if set to 'collapse'
6525 if (_Style.checkStyle("border-collapse", "collapse"))
6526 table->CellSpacing = 0;
6527 }
6528
6529 if (elm.hasNonEmptyAttribute("cellpadding"))
6530 fromString(elm.getAttribute("cellpadding"), table->CellPadding);
6531
6532 if (_Style.hasStyle("width"))
6533 {
6534 // _Style.Width does not handle '%' unit currently
6535 if (_Style.Current.Width > 0)
6536 {
6537 table->ForceWidthMin = _Style.Current.Width;
6538 table->TableRatio = 0;
6539 }
6540 else
6541 {
6542 getPercentage (table->ForceWidthMin, table->TableRatio, _Style.getStyle("width").c_str());
6543 }
6544 }
6545 else if (elm.hasNonEmptyAttribute("width"))
6546 {
6547 getPercentage (table->ForceWidthMin, table->TableRatio, elm.getAttribute("width").c_str());
6548 }
6549
6550 // border from css or from attribute
6551 {
6552 CSSRect<CSSBorder> border;
6553 border.Top.Color = _Style.Current.TextColor;
6554 border.Right.Color = _Style.Current.TextColor;
6555 border.Bottom.Color = _Style.Current.TextColor;
6556 border.Left.Color = _Style.Current.TextColor;
6557
6558 if (elm.hasAttribute("border"))
6559 {
6560 uint32 borderWidth = 0;
6561 CRGBA borderColor = CRGBA::Transparent;
6562
6563 std::string s = elm.getAttribute("border");
6564 if (s.empty())
6565 borderWidth = 1;
6566 else
6567 fromString(elm.getAttribute("border"), borderWidth);
6568
6569 if (elm.hasNonEmptyAttribute("bordercolor"))
6570 scanHTMLColor(elm.getAttribute("bordercolor").c_str(), borderColor);
6571 else
6572 borderColor = CRGBA(128, 128, 128, 255);
6573
6574 table->CellBorder = (borderWidth > 0);
6575
6576 border.Top.set(borderWidth, CSS_LINE_STYLE_OUTSET, borderColor);
6577 border.Right.set(borderWidth, CSS_LINE_STYLE_OUTSET, borderColor);
6578 border.Bottom.set(borderWidth, CSS_LINE_STYLE_OUTSET, borderColor);
6579 border.Left.set(borderWidth, CSS_LINE_STYLE_OUTSET, borderColor);
6580 }
6581
6582 if (_Style.hasStyle("border-top-width")) border.Top.Width = _Style.Current.Border.Top.Width;
6583 if (_Style.hasStyle("border-right-width")) border.Right.Width = _Style.Current.Border.Right.Width;
6584 if (_Style.hasStyle("border-bottom-width")) border.Bottom.Width = _Style.Current.Border.Bottom.Width;
6585 if (_Style.hasStyle("border-left-width")) border.Left.Width = _Style.Current.Border.Left.Width;
6586
6587 if (_Style.hasStyle("border-top-color")) border.Top.Color = _Style.Current.Border.Top.Color;
6588 if (_Style.hasStyle("border-right-color")) border.Right.Color = _Style.Current.Border.Right.Color;
6589 if (_Style.hasStyle("border-bottom-color")) border.Bottom.Color = _Style.Current.Border.Bottom.Color;
6590 if (_Style.hasStyle("border-left-color")) border.Left.Color = _Style.Current.Border.Left.Color;
6591
6592 if (_Style.hasStyle("border-top-style")) border.Top.Style = _Style.Current.Border.Top.Style;
6593 if (_Style.hasStyle("border-right-style")) border.Right.Style = _Style.Current.Border.Right.Style;
6594 if (_Style.hasStyle("border-bottom-style")) border.Bottom.Style = _Style.Current.Border.Bottom.Style;
6595 if (_Style.hasStyle("border-left-style")) border.Left.Style = _Style.Current.Border.Left.Style;
6596
6597 table->Border->setBorder(border);
6598 table->Border->setFontSize(_Style.Root.FontSize, _Style.Current.FontSize);
6599 table->Border->setViewport(getList()->getParentPos() ? getList()->getParentPos() : this);
6600 }
6601
6602 setupBackground(table->Background);
6603 table->setModulateGlobalColor(_Style.Current.GlobalColor);
6604
6605 table->setMarginLeft(getIndent());
6606 addHtmlGroup (table, 0);
6607
6608 renderPseudoElement(":before", elm);
6609
6610 _Tables.push_back(table);
6611
6612 // Add a cell pointer
6613 _Cells.push_back(NULL);
6614 _TR.push_back(false);
6615 _Indent.push_back(0);
6616 }
6617
6618 void CGroupHTML::htmlTABLEend(const CHtmlElement &elm)
6619 {
6620 popIfNotEmpty(_CellParams);
6621 popIfNotEmpty(_TR);
6622 popIfNotEmpty(_Cells);
6623 popIfNotEmpty(_Tables);
6624 popIfNotEmpty(_Indent);
6625
6626 renderPseudoElement(":after", elm);
6627 }
6628
6629 // ***************************************************************************
6630 void CGroupHTML::htmlTD(const CHtmlElement &elm)
6631 {
6632 // Get cells parameters
6633 getCellsParameters(elm, true);
6634
6635 if (!m_TableRowBackgroundColor.empty() && m_TableRowBackgroundColor.back().A > 0)
6636 _Style.Current.Background.color.blendFromui(m_TableRowBackgroundColor.back(), _Style.Current.Background.color, _Style.Current.Background.color.A);
6637
6638 if (elm.ID == HTML_TH)
6639 {
6640 if (!_Style.hasStyle("font-weight"))
6641 _Style.Current.FontWeight = FONT_WEIGHT_BOLD;
6642 // center if not specified otherwise.
6643 if (!elm.hasNonEmptyAttribute("align") && !_Style.hasStyle("text-align"))
6644 _CellParams.back().Align = CGroupCell::Center;
6645 }
6646
6647 CGroupTable *table = getTable();
6648 if (!table)
6649 {
6650 // <td> appears to be outside <table>
6651 return;
6652 }
6653
6654 if (_Cells.empty())
6655 {
6656 // <table> not started
6657 return;
6658 }
6659
6660 _Cells.back() = new CGroupCell(CViewBase::TCtorParam());
6661 if (elm.hasNonEmptyAttribute("id"))
6662 _Cells.back()->setId(table->getId() + ":" + elm.getAttribute("id"));
6663 else
6664 _Cells.back()->setId(table->getId() + ":TD" + toString(getNextAutoIdSeq()));
6665 // inner cell content
6666 _Cells.back()->Group->setId(_Cells.back()->getId() + ":CELL");
6667
6668 setupBackground(_Cells.back()->Background);
6669 _Cells.back()->setModulateGlobalColor(_Style.Current.GlobalColor);
6670
6671 if (elm.hasNonEmptyAttribute("colspan"))
6672 fromString(elm.getAttribute("colspan"), _Cells.back()->ColSpan);
6673 if (elm.hasNonEmptyAttribute("rowspan"))
6674 fromString(elm.getAttribute("rowspan"), _Cells.back()->RowSpan);
6675
6676 _Cells.back()->Align = _CellParams.back().Align;
6677 _Cells.back()->VAlign = _CellParams.back().VAlign;
6678 _Cells.back()->LeftMargin = _CellParams.back().LeftMargin;
6679 _Cells.back()->NoWrap = _CellParams.back().NoWrap;
6680 _Cells.back()->ColSpan = std::max(1, _Cells.back()->ColSpan);
6681 _Cells.back()->RowSpan = std::max(1, _Cells.back()->RowSpan);
6682 _Cells.back()->Height = _CellParams.back().Height;
6683
6684 float temp;
6685 if (_Style.hasStyle("width"))
6686 {
6687 // _Style.Width does not handle '%' unit currently
6688 if (_Style.Current.Width > 0)
6689 {
6690 _Cells.back()->WidthWanted = _Style.Current.Width;
6691 _Cells.back()->TableRatio = 0;
6692 }
6693 else
6694 {
6695 getPercentage (_Cells.back()->WidthWanted, _Cells.back()->TableRatio, _Style.getStyle("width").c_str());
6696 }
6697 }
6698 else if (elm.hasNonEmptyAttribute("width"))
6699 {
6700 getPercentage (_Cells.back()->WidthWanted, _Cells.back()->TableRatio, elm.getAttribute("width").c_str());
6701 }
6702
6703 _Cells.back()->NewLine = getTR();
6704
6705 CSSRect<CSSBorder> border;
6706 border.Top.set( table->CellBorder ? 1 : 0, CSS_LINE_STYLE_INSET, _Style.Current.TextColor);
6707 border.Right.set( table->CellBorder ? 1 : 0, CSS_LINE_STYLE_INSET, _Style.Current.TextColor);
6708 border.Bottom.set(table->CellBorder ? 1 : 0, CSS_LINE_STYLE_INSET, _Style.Current.TextColor);
6709 border.Left.set( table->CellBorder ? 1 : 0, CSS_LINE_STYLE_INSET, _Style.Current.TextColor);
6710
6711 if (_Style.hasStyle("border-top-width")) border.Top.Width = _Style.Current.Border.Top.Width;
6712 if (_Style.hasStyle("border-right-width")) border.Right.Width = _Style.Current.Border.Right.Width;
6713 if (_Style.hasStyle("border-bottom-width")) border.Bottom.Width = _Style.Current.Border.Bottom.Width;
6714 if (_Style.hasStyle("border-left-width")) border.Left.Width = _Style.Current.Border.Left.Width;
6715
6716 if (_Style.hasStyle("border-top-color")) border.Top.Color = _Style.Current.Border.Top.Color;
6717 if (_Style.hasStyle("border-right-color")) border.Right.Color = _Style.Current.Border.Right.Color;
6718 if (_Style.hasStyle("border-bottom-color")) border.Bottom.Color = _Style.Current.Border.Bottom.Color;
6719 if (_Style.hasStyle("border-left-color")) border.Left.Color = _Style.Current.Border.Left.Color;
6720
6721 if (_Style.hasStyle("border-top-style")) border.Top.Style = _Style.Current.Border.Top.Style;
6722 if (_Style.hasStyle("border-right-style")) border.Right.Style = _Style.Current.Border.Right.Style;
6723 if (_Style.hasStyle("border-bottom-style")) border.Bottom.Style = _Style.Current.Border.Bottom.Style;
6724 if (_Style.hasStyle("border-left-style")) border.Left.Style = _Style.Current.Border.Left.Style;
6725
6726 _Cells.back()->Border->setBorder(border);
6727 _Cells.back()->Border->setFontSize(_Style.Root.FontSize, _Style.Current.FontSize);
6728 _Cells.back()->Border->setViewport(getList()->getParentPos() ? getList()->getParentPos() : this);
6729
6730 // padding from <table cellpadding="1">
6731 if (table->CellPadding)
6732 {
6733 // FIXME: padding is ignored by vertical align
6734 _Cells.back()->PaddingTop = table->CellPadding;
6735 _Cells.back()->PaddingRight = table->CellPadding;
6736 _Cells.back()->PaddingBottom = table->CellPadding;
6737 _Cells.back()->PaddingLeft = table->CellPadding;
6738 }
6739
6740 if (_Style.hasStyle("padding-top")) _Cells.back()->PaddingTop = _Style.Current.PaddingTop;
6741 if (_Style.hasStyle("padding-right")) _Cells.back()->PaddingRight = _Style.Current.PaddingRight;
6742 if (_Style.hasStyle("padding-bottom")) _Cells.back()->PaddingBottom = _Style.Current.PaddingBottom;
6743 if (_Style.hasStyle("padding-left")) _Cells.back()->PaddingLeft = _Style.Current.PaddingLeft;
6744
6745 table->addChild (_Cells.back());
6746
6747 // reusing indent pushed by table
6748 _Indent.back() = 0;
6749
6750 newParagraph(TDBeginSpace);
6751 // indent is already 0, getParagraph()->setMarginLeft(0); // maybe setIndent(0) if LI is using one
6752
6753 // Reset TR flag
6754 if (!_TR.empty())
6755 _TR.back() = false;
6756
6757 renderPseudoElement(":before", elm);
6758 }
6759
6760 void CGroupHTML::htmlTDend(const CHtmlElement &elm)
6761 {
6762 renderPseudoElement(":after", elm);
6763
6764 popIfNotEmpty(_CellParams);
6765 if (!_Cells.empty())
6766 _Cells.back() = NULL;
6767 }
6768
6769 // ***************************************************************************
6770 void CGroupHTML::htmlTEXTAREA(const CHtmlElement &elm)
6771 {
6772 _IgnoreChildElements = true;
6773
6774 // TODO: allow textarea without form
6775 if (_Forms.empty())
6776 return;
6777
6778 // read general property
6779 string templateName;
6780
6781 // Widget template name
6782 if (elm.hasNonEmptyAttribute("z_input_tmpl"))
6783 templateName = elm.getAttribute("z_input_tmpl");
6784
6785 // Get the string name
6786 _TextAreaName.clear();
6787 _TextAreaRow = 1;
6788 _TextAreaCols = 10;
6789 _TextAreaMaxLength = 1024;
6790 if (elm.hasNonEmptyAttribute("name"))
6791 _TextAreaName = elm.getAttribute("name");
6792 if (elm.hasNonEmptyAttribute("rows"))
6793 fromString(elm.getAttribute("rows"), _TextAreaRow);
6794 if (elm.hasNonEmptyAttribute("cols"))
6795 fromString(elm.getAttribute("cols"), _TextAreaCols);
6796 if (elm.hasNonEmptyAttribute("maxlength"))
6797 fromString(elm.getAttribute("maxlength"), _TextAreaMaxLength);
6798
6799 _TextAreaTemplate = !templateName.empty() ? templateName : DefaultFormTextAreaGroup;
6800
6801 std::string content = strFindReplaceAll(elm.serializeChilds(false), std::string("\r"), std::string(""));
6802
6803 CInterfaceGroup *textArea = addTextArea (_TextAreaTemplate, _TextAreaName.c_str (), _TextAreaRow, _TextAreaCols, true, content, _TextAreaMaxLength);
6804 if (textArea)
6805 {
6806 // Add the text area to the form
6807 CGroupHTML::CForm::CEntry entry;
6808 entry.Name = _TextAreaName;
6809 entry.TextArea = textArea;
6810 _Forms.back().Entries.push_back (entry);
6811 }
6812 }
6813
6814 // ***************************************************************************
6815 void CGroupHTML::htmlTH(const CHtmlElement &elm)
6816 {
6817 htmlTD(elm);
6818 }
6819
6820 void CGroupHTML::htmlTHend(const CHtmlElement &elm)
6821 {
6822 htmlTDend(elm);
6823 }
6824
6825 // ***************************************************************************
6826 void CGroupHTML::htmlTITLE(const CHtmlElement &elm)
6827 {
6828 _IgnoreChildElements = true;
6829
6830 // TODO: only from <head>
6831 // if (!_ReadingHeadTag) return;
6832
6833 // consume all child elements
6834 _TitleString = strFindReplaceAll(elm.serializeChilds(false), std::string("\t"), std::string(" "));
6835 _TitleString = strFindReplaceAll(_TitleString, std::string("\n"), std::string(" "));
6836 setTitle(_TitleString);
6837 }
6838
6839 // ***************************************************************************
6840 void CGroupHTML::htmlTR(const CHtmlElement &elm)
6841 {
6842 // prevent inheriting from table
6843 if (!_CellParams.empty())
6844 {
6845 _CellParams.back().BgColor = CRGBA::Transparent;
6846 _CellParams.back().Height = 0;
6847 }
6848
6849 // Get cells parameters
6850 getCellsParameters(elm, true);
6851
6852 m_TableRowBackgroundColor.push_back(_CellParams.back().BgColor);
6853 _CellParams.back().BgColor = CRGBA::Transparent;
6854
6855 // TODO: this probably ends up in first cell
6856 renderPseudoElement(":before", elm);
6857
6858 // Set TR flag
6859 if (!_TR.empty())
6860 _TR.back() = true;
6861 }
6862
6863 void CGroupHTML::htmlTRend(const CHtmlElement &elm)
6864 {
6865 // TODO: this probably ends up in last cell
6866 renderPseudoElement(":after", elm);
6867
6868 popIfNotEmpty(_CellParams);
6869 popIfNotEmpty(m_TableRowBackgroundColor);
6870 }
6871
6872 // ***************************************************************************
6873 void CGroupHTML::htmlUL(const CHtmlElement &elm)
6874 {
6875 if (_UL.empty())
6876 _UL.push_back(HTMLOListElement(1, "disc"));
6877 else if (_UL.size() == 1)
6878 _UL.push_back(HTMLOListElement(1, "circle"));
6879 else
6880 _UL.push_back(HTMLOListElement(1, "square"));
6881
6882 // if LI is already present
6883 _LI = _UL.size() > 1 || _DL.size() > 1;
6884 _Indent.push_back(getIndent() + ULIndent);
6885
6886 renderPseudoElement(":before", elm);
6887 }
6888
6889 void CGroupHTML::htmlULend(const CHtmlElement &elm)
6890 {
6891 if (_UL.empty())
6892 return;
6893
6894 renderPseudoElement(":after", elm);
6895
6896 popIfNotEmpty(_UL);
6897 popIfNotEmpty(_Indent);
6898 }
6899
6900 }
6901