src/html/winpars.cpp

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