src/html/winpars.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        winpars.cpp
   3 // Purpose:     wxHtmlParser class (generic parser)
   4 // Author:      Vaclav Slavik
   5 // RCS-ID:      $Id$
   6 // Copyright:   (c) 1999 Vaclav Slavik
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10
  11 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  12 #pragma implementation "winpars.h"
  13 #endif
  14
  15 #include "wx/wxprec.h"
  16
  17 #include "wx/defs.h"
  18 #if wxUSE_HTML && wxUSE_STREAMS
  19
  20 #ifdef __BORLANDC__
  21 #pragma hdrstop
  22 #endif
  23
  24 #ifndef WXPRECOMP
  25     #include "wx/intl.h"
  26     #include "wx/dc.h"
  27 #endif
  28
  29 #include "wx/html/htmldefs.h"
  30 #include "wx/html/winpars.h"
  31 #include "wx/html/htmlwin.h"
  32 #include "wx/fontmap.h"
  33 #include "wx/log.h"
  34 #include "wx/settings.h"
  35 #include "wx/url.h"
  36
  37
  38 //-----------------------------------------------------------------------------
  39 // wxHtmlWinParser
  40 //-----------------------------------------------------------------------------
  41
  42 IMPLEMENT_ABSTRACT_CLASS(wxHtmlWinParser, wxHtmlParser)
  43
  44 wxList wxHtmlWinParser::m_Modules;
  45
  46 wxHtmlWinParser::wxHtmlWinParser(wxHtmlWindow *wnd) : wxHtmlParser()
  47 {
  48     m_tmpStrBuf = NULL;
  49     m_tmpStrBufSize = 0;
  50     m_Window = wnd;
  51     m_Container = NULL;
  52     m_DC = NULL;
  53     m_CharHeight = m_CharWidth = 0;
  54     m_UseLink = false;
  55 #if !wxUSE_UNICODE
  56     m_EncConv = NULL;
  57     m_InputEnc = wxFONTENCODING_ISO8859_1;
  58     m_OutputEnc = wxFONTENCODING_DEFAULT;
  59 #endif
  60     m_lastWordCell = NULL;
  61
  62     {
  63         int i, j, k, l, m;
  64         for (i = 0; i < 2; i++)
  65             for (j = 0; j < 2; j++)
  66                 for (k = 0; k < 2; k++)
  67                     for (l = 0; l < 2; l++)
  68                         for (m = 0; m < 7; m++)
  69                         {
  70                             m_FontsTable[i][j][k][l][m] = NULL;
  71                             m_FontsFacesTable[i][j][k][l][m] = wxEmptyString;
  72 #if !wxUSE_UNICODE
  73                             m_FontsEncTable[i][j][k][l][m] = wxFONTENCODING_DEFAULT;
  74 #endif
  75                         }
  76
  77         SetFonts(wxEmptyString, wxEmptyString, NULL);
  78     }
  79
  80     // fill in wxHtmlParser's tables:
  81     wxList::compatibility_iterator node = m_Modules.GetFirst();
  82     while (node)
  83     {
  84         wxHtmlTagsModule *mod = (wxHtmlTagsModule*) node->GetData();
  85         mod->FillHandlersTable(this);
  86         node = node->GetNext();
  87     }
  88 }
  89
  90 wxHtmlWinParser::~wxHtmlWinParser()
  91 {
  92     int i, j, k, l, m;
  93
  94     for (i = 0; i < 2; i++)
  95         for (j = 0; j < 2; j++)
  96             for (k = 0; k < 2; k++)
  97                 for (l = 0; l < 2; l++)
  98                     for (m = 0; m < 7; m++)
  99                     {
 100                         if (m_FontsTable[i][j][k][l][m] != NULL)
 101                             delete m_FontsTable[i][j][k][l][m];
 102                     }
 103 #if !wxUSE_UNICODE
 104     delete m_EncConv;
 105 #endif
 106     delete[] m_tmpStrBuf;
 107 }
 108
 109 void wxHtmlWinParser::AddModule(wxHtmlTagsModule *module)
 110 {
 111     m_Modules.Append(module);
 112 }
 113
 114 void wxHtmlWinParser::RemoveModule(wxHtmlTagsModule *module)
 115 {
 116     m_Modules.DeleteObject(module);
 117 }
 118
 119 void wxHtmlWinParser::SetFonts(wxString normal_face, wxString fixed_face,
 120                                const int *sizes)
 121 {
 122     static int default_sizes[7] =
 123         {
 124             wxHTML_FONT_SIZE_1,
 125             wxHTML_FONT_SIZE_2,
 126             wxHTML_FONT_SIZE_3,
 127             wxHTML_FONT_SIZE_4,
 128             wxHTML_FONT_SIZE_5,
 129             wxHTML_FONT_SIZE_6,
 130             wxHTML_FONT_SIZE_7
 131         };
 132
 133     if (sizes == NULL) sizes = default_sizes;
 134
 135     int i, j, k, l, m;
 136
 137     for (i = 0; i < 7; i++) m_FontsSizes[i] = sizes[i];
 138     m_FontFaceFixed = fixed_face;
 139     m_FontFaceNormal = normal_face;
 140
 141 #if !wxUSE_UNICODE
 142     SetInputEncoding(m_InputEnc);
 143 #endif
 144
 145     for (i = 0; i < 2; i++)
 146         for (j = 0; j < 2; j++)
 147             for (k = 0; k < 2; k++)
 148                 for (l = 0; l < 2; l++)
 149                     for (m = 0; m < 7; m++) {
 150                         if (m_FontsTable[i][j][k][l][m] != NULL)
 151                         {
 152                             delete m_FontsTable[i][j][k][l][m];
 153                             m_FontsTable[i][j][k][l][m] = NULL;
 154                         }
 155                     }
 156 }
 157
 158 void wxHtmlWinParser::SetStandardFonts(int size,
 159                                        const wxString& normal_face,
 160                                        const wxString& fixed_face)
 161 {
 162     wxFont defaultFont = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
 163
 164     int f_sizes[7];
 165     if (size == -1)
 166         size = defaultFont.GetPointSize();
 167
 168     f_sizes[0] = int(size * 0.6);
 169     f_sizes[1] = int(size * 0.8);
 170     f_sizes[2] = size;
 171     f_sizes[3] = int(size * 1.2);
 172     f_sizes[4] = int(size * 1.4);
 173     f_sizes[5] = int(size * 1.6);
 174     f_sizes[6] = int(size * 1.8);
 175
 176     wxString normal = normal_face.empty() ?
 177                       defaultFont.GetFaceName() : normal_face;
 178
 179     SetFonts(normal, fixed_face, f_sizes);
 180 }
 181
 182 void wxHtmlWinParser::InitParser(const wxString& source)
 183 {
 184     wxHtmlParser::InitParser(source);
 185     wxASSERT_MSG(m_DC != NULL, wxT("no DC assigned to wxHtmlWinParser!!"));
 186
 187     m_FontBold = m_FontItalic = m_FontUnderlined = m_FontFixed = FALSE;
 188     m_FontSize = 3; //default one
 189     CreateCurrentFont();           // we're selecting default font into
 190     m_DC->GetTextExtent( wxT("H"), &m_CharWidth, &m_CharHeight);
 191                 /* NOTE : we're not using GetCharWidth/Height() because
 192                    of differences under X and win
 193                  */
 194
 195     m_UseLink = false;
 196     m_Link = wxHtmlLinkInfo( wxT(""), wxT("") );
 197     m_LinkColor.Set(0, 0, 0xFF);
 198     m_ActualColor.Set(0, 0, 0);
 199     m_Align = wxHTML_ALIGN_LEFT;
 200     m_tmpLastWasSpace = false;
 201     m_lastWordCell = NULL;
 202
 203     OpenContainer();
 204     OpenContainer();
 205
 206 #if !wxUSE_UNICODE
 207     wxString charset = ExtractCharsetInformation(source);
 208     if (!charset.empty())
 209     {
 210         wxFontEncoding enc = wxFontMapper::Get()->CharsetToEncoding(charset);
 211         if (enc != wxFONTENCODING_SYSTEM)
 212           SetInputEncoding(enc);
 213     }
 214 #endif
 215
 216     m_Container->InsertCell(new wxHtmlColourCell(m_ActualColor));
 217     wxColour windowColour = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW) ;
 218     m_Container->InsertCell(
 219             new wxHtmlColourCell(GetWindow() ?
 220                                      GetWindow()->GetBackgroundColour() :
 221                                      windowColour,
 222                                  wxHTML_CLR_BACKGROUND));
 223     m_Container->InsertCell(new wxHtmlFontCell(CreateCurrentFont()));
 224 }
 225
 226 void wxHtmlWinParser::DoneParser()
 227 {
 228     m_Container = NULL;
 229 #if !wxUSE_UNICODE
 230     SetInputEncoding(wxFONTENCODING_ISO8859_1); // for next call
 231 #endif
 232     wxHtmlParser::DoneParser();
 233 }
 234
 235 wxObject* wxHtmlWinParser::GetProduct()
 236 {
 237     wxHtmlContainerCell *top;
 238
 239     CloseContainer();
 240     OpenContainer();
 241
 242     top = m_Container;
 243     while (top->GetParent()) top = top->GetParent();
 244     top->RemoveExtraSpacing(true, true);
 245
 246     return top;
 247 }
 248
 249 wxFSFile *wxHtmlWinParser::OpenURL(wxHtmlURLType type,
 250                                    const wxString& url) const
 251 {
 252     if ( m_Window )
 253     {
 254         wxString myurl(url);
 255         wxHtmlOpeningStatus status;
 256         for (;;)
 257         {
 258             wxString myfullurl(myurl);
 259
 260 #if wxUSE_URL
 261             // consider url as absolute path first
 262             wxURL current(wxURL::Unescape(myurl));
 263             myfullurl = current.GetURL();
 264
 265             // if not absolute then ...
 266             if( current.IsReference() )
 267             {
 268                 wxString basepath = GetFS()->GetPath();
 269                 wxURI base(wxURL::Unescape(basepath));
 270
 271                 // try to apply base path if valid ...
 272                 if( !base.IsReference() )
 273                 {
 274                     wxURI path(myfullurl);
 275                     path.Resolve( base );
 276                     myfullurl = path.BuildURI();
 277                 }
 278                 else
 279                 {
 280                     // ... or force such addition if not included already
 281                     if( !current.GetURL().Contains(basepath) )
 282                     {
 283                         basepath += myurl;
 284                         wxURL connected( wxURL::Unescape(basepath) );
 285                         myfullurl = connected.GetURL();
 286                     }
 287                 }
 288             }
 289 #endif
 290
 291             wxString redirect;
 292             status = m_Window->OnOpeningURL(type, myfullurl, &redirect);
 293             if ( status != wxHTML_REDIRECT )
 294                 break;
 295
 296             myurl = redirect;
 297         }
 298
 299         if ( status == wxHTML_BLOCK )
 300             return NULL;
 301
 302         return GetFS()->OpenFile(myurl);
 303     }
 304
 305     return wxHtmlParser::OpenURL(type, url);
 306 }
 307
 308 void wxHtmlWinParser::AddText(const wxChar* txt)
 309 {
 310     wxHtmlCell *c;
 311     size_t i = 0,
 312            x,
 313            lng = wxStrlen(txt);
 314     register wxChar d;
 315     int templen = 0;
 316     wxChar nbsp = GetEntitiesParser()->GetCharForCode(160 /* nbsp */);
 317
 318     if (lng+1 > m_tmpStrBufSize)
 319     {
 320         delete[] m_tmpStrBuf;
 321         m_tmpStrBuf = new wxChar[lng+1];
 322         m_tmpStrBufSize = lng+1;
 323     }
 324     wxChar *temp = m_tmpStrBuf;
 325
 326     if (m_tmpLastWasSpace)
 327     {
 328         while ((i < lng) &&
 329                ((txt[i] == wxT('\n')) || (txt[i] == wxT('\r')) || (txt[i] == wxT(' ')) ||
 330                 (txt[i] == wxT('\t')))) i++;
 331     }
 332
 333     while (i < lng)
 334     {
 335         x = 0;
 336         d = temp[templen++] = txt[i];
 337         if ((d == wxT('\n')) || (d == wxT('\r')) || (d == wxT(' ')) || (d == wxT('\t')))
 338         {
 339             i++, x++;
 340             while ((i < lng) && ((txt[i] == wxT('\n')) || (txt[i] == wxT('\r')) ||
 341                                  (txt[i] == wxT(' ')) || (txt[i] == wxT('\t')))) i++, x++;
 342         }
 343         else i++;
 344
 345         if (x)
 346         {
 347             temp[templen-1] = wxT(' ');
 348             temp[templen] = 0;
 349             templen = 0;
 350 #if !wxUSE_UNICODE
 351             if (m_EncConv)
 352                 m_EncConv->Convert(temp);
 353 #endif
 354             size_t len = wxStrlen(temp);
 355             for (size_t j = 0; j < len; j++)
 356                 if (temp[j] == nbsp)
 357                     temp[j] = wxT(' ');
 358             c = new wxHtmlWordCell(temp, *(GetDC()));
 359             if (m_UseLink)
 360                 c->SetLink(m_Link);
 361             m_Container->InsertCell(c);
 362             ((wxHtmlWordCell*)c)->SetPreviousWord(m_lastWordCell);
 363             m_lastWordCell = (wxHtmlWordCell*)c;
 364             m_tmpLastWasSpace = true;
 365         }
 366     }
 367
 368     if (templen && (templen > 1 || temp[0] != wxT(' ')))
 369     {
 370         temp[templen] = 0;
 371 #if !wxUSE_UNICODE
 372         if (m_EncConv)
 373             m_EncConv->Convert(temp);
 374 #endif
 375         size_t len = wxStrlen(temp);
 376         for (size_t j = 0; j < len; j++)
 377             if (temp[j] == nbsp)
 378                 temp[j] = wxT(' ');
 379         c = new wxHtmlWordCell(temp, *(GetDC()));
 380         if (m_UseLink)
 381             c->SetLink(m_Link);
 382         m_Container->InsertCell(c);
 383         ((wxHtmlWordCell*)c)->SetPreviousWord(m_lastWordCell);
 384         m_lastWordCell = (wxHtmlWordCell*)c;
 385         m_tmpLastWasSpace = false;
 386     }
 387 }
 388
 389
 390
 391 wxHtmlContainerCell* wxHtmlWinParser::OpenContainer()
 392 {
 393     m_Container = new wxHtmlContainerCell(m_Container);
 394     m_Container->SetAlignHor(m_Align);
 395     m_tmpLastWasSpace = true;
 396         /* to avoid space being first character in paragraph */
 397     return m_Container;
 398 }
 399
 400
 401
 402 wxHtmlContainerCell* wxHtmlWinParser::SetContainer(wxHtmlContainerCell *c)
 403 {
 404     m_tmpLastWasSpace = true;
 405         /* to avoid space being first character in paragraph */
 406     return m_Container = c;
 407 }
 408
 409
 410
 411 wxHtmlContainerCell* wxHtmlWinParser::CloseContainer()
 412 {
 413     m_Container = m_Container->GetParent();
 414     return m_Container;
 415 }
 416
 417
 418 void wxHtmlWinParser::SetFontSize(int s)
 419 {
 420     if (s < 1) s = 1;
 421     else if (s > 7) s = 7;
 422     m_FontSize = s;
 423 }
 424
 425
 426
 427 wxFont* wxHtmlWinParser::CreateCurrentFont()
 428 {
 429     int fb = GetFontBold(),
 430         fi = GetFontItalic(),
 431         fu = GetFontUnderlined(),
 432         ff = GetFontFixed(),
 433         fs = GetFontSize() - 1 /*remap from <1;7> to <0;6>*/ ;
 434
 435     wxString face = ff ? m_FontFaceFixed : m_FontFaceNormal;
 436     wxString *faceptr = &(m_FontsFacesTable[fb][fi][fu][ff][fs]);
 437     wxFont **fontptr = &(m_FontsTable[fb][fi][fu][ff][fs]);
 438 #if !wxUSE_UNICODE
 439     wxFontEncoding *encptr = &(m_FontsEncTable[fb][fi][fu][ff][fs]);
 440 #endif
 441
 442     if (*fontptr != NULL && (*faceptr != face
 443 #if !wxUSE_UNICODE
 444                              || *encptr != m_OutputEnc
 445 #endif
 446                             ))
 447     {
 448         delete *fontptr;
 449         *fontptr = NULL;
 450     }
 451
 452     if (*fontptr == NULL)
 453     {
 454         *faceptr = face;
 455         *fontptr = new wxFont(
 456                        (int) (m_FontsSizes[fs] * m_PixelScale),
 457                        ff ? wxMODERN : wxSWISS,
 458                        fi ? wxITALIC : wxNORMAL,
 459                        fb ? wxBOLD : wxNORMAL,
 460                        fu ? true : false, face
 461 #if wxUSE_UNICODE
 462                        );
 463 #else
 464                        , m_OutputEnc);
 465         *encptr = m_OutputEnc;
 466 #endif
 467     }
 468     m_DC->SetFont(**fontptr);
 469     return (*fontptr);
 470 }
 471
 472
 473
 474 void wxHtmlWinParser::SetLink(const wxHtmlLinkInfo& link)
 475 {
 476     m_Link = link;
 477     m_UseLink = (link.GetHref() != wxEmptyString);
 478 }
 479
 480
 481 void wxHtmlWinParser::SetFontFace(const wxString& face)
 482 {
 483     if (GetFontFixed()) m_FontFaceFixed = face;
 484     else m_FontFaceNormal = face;
 485
 486 #if !wxUSE_UNICODE
 487     if (m_InputEnc != wxFONTENCODING_DEFAULT)
 488         SetInputEncoding(m_InputEnc);
 489 #endif
 490 }
 491
 492
 493
 494 #if !wxUSE_UNICODE
 495 void wxHtmlWinParser::SetInputEncoding(wxFontEncoding enc)
 496 {
 497     m_InputEnc = m_OutputEnc = wxFONTENCODING_DEFAULT;
 498     if (m_EncConv)
 499     {
 500         delete m_EncConv;
 501         m_EncConv = NULL;
 502     }
 503
 504     if (enc == wxFONTENCODING_DEFAULT) return;
 505
 506     wxFontEncoding altfix, altnorm;
 507     bool availfix, availnorm;
 508
 509     // exact match?
 510     availnorm = wxFontMapper::Get()->IsEncodingAvailable(enc, m_FontFaceNormal);
 511     availfix = wxFontMapper::Get()->IsEncodingAvailable(enc, m_FontFaceFixed);
 512     if (availnorm && availfix)
 513         m_OutputEnc = enc;
 514
 515     // alternatives?
 516     else if (wxFontMapper::Get()->GetAltForEncoding(enc, &altnorm, m_FontFaceNormal, false) &&
 517              wxFontMapper::Get()->GetAltForEncoding(enc, &altfix, m_FontFaceFixed, false) &&
 518              altnorm == altfix)
 519         m_OutputEnc = altnorm;
 520
 521     // at least normal face?
 522     else if (availnorm)
 523         m_OutputEnc = enc;
 524     else if (wxFontMapper::Get()->GetAltForEncoding(enc, &altnorm, m_FontFaceNormal, false))
 525         m_OutputEnc = altnorm;
 526
 527     else
 528     {
 529 #ifndef __WXMAC__
 530         // okay, let convert to ISO_8859-1, available always
 531         m_OutputEnc = wxFONTENCODING_DEFAULT;
 532 #else
 533         m_OutputEnc = wxLocale::GetSystemEncoding() ;
 534 #endif
 535     }
 536
 537     m_InputEnc = enc;
 538     if (m_OutputEnc == wxFONTENCODING_DEFAULT)
 539         GetEntitiesParser()->SetEncoding(wxFONTENCODING_SYSTEM);
 540     else
 541         GetEntitiesParser()->SetEncoding(m_OutputEnc);
 542
 543     if (m_InputEnc == m_OutputEnc) return;
 544
 545     m_EncConv = new wxEncodingConverter();
 546     if (!m_EncConv->Init(m_InputEnc,
 547                            (m_OutputEnc == wxFONTENCODING_DEFAULT) ?
 548                                       wxFONTENCODING_ISO8859_1 : m_OutputEnc,
 549                            wxCONVERT_SUBSTITUTE))
 550     { // total failture :-(
 551         wxLogError(_("Failed to display HTML document in %s encoding"),
 552                    wxFontMapper::GetEncodingName(enc).c_str());
 553         m_InputEnc = m_OutputEnc = wxFONTENCODING_DEFAULT;
 554         delete m_EncConv;
 555         m_EncConv = NULL;
 556     }
 557 }
 558 #endif
 559
 560
 561
 562
 563 //-----------------------------------------------------------------------------
 564 // wxHtmlWinTagHandler
 565 //-----------------------------------------------------------------------------
 566
 567 IMPLEMENT_ABSTRACT_CLASS(wxHtmlWinTagHandler, wxHtmlTagHandler)
 568
 569 //-----------------------------------------------------------------------------
 570 // wxHtmlTagsModule
 571 //-----------------------------------------------------------------------------
 572
 573 // NB: This is *NOT* winpars.cpp's initialization and shutdown code!!
 574 //     This module is an ancestor for tag handlers modules defined
 575 //     in m_*.cpp files with TAGS_MODULE_BEGIN...TAGS_MODULE_END construct.
 576 //
 577 //     Do not add any winpars.cpp shutdown or initialization code to it,
 578 //     create a new module instead!
 579
 580 IMPLEMENT_DYNAMIC_CLASS(wxHtmlTagsModule, wxModule)
 581
 582 bool wxHtmlTagsModule::OnInit()
 583 {
 584     wxHtmlWinParser::AddModule(this);
 585     return true;
 586 }
 587
 588 void wxHtmlTagsModule::OnExit()
 589 {
 590     wxHtmlWinParser::RemoveModule(this);
 591 }
 592
 593 #endif
 594