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 #ifdef __GNUG__
  12 #pragma implementation
  13 #endif
  14
  15 #include "wx/wxprec.h"
  16
  17 #include "wx/defs.h"
  18 #if wxUSE_HTML && wxUSE_STREAMS
  19
  20 #ifdef __BORDLANDC__
  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
  35
  36 //-----------------------------------------------------------------------------
  37 // wxHtmlWinParser
  38 //-----------------------------------------------------------------------------
  39
  40
  41 wxList wxHtmlWinParser::m_Modules;
  42
  43 wxHtmlWinParser::wxHtmlWinParser(wxWindow *wnd) : wxHtmlParser()
  44 {
  45     m_tmpStrBuf = NULL;
  46     m_tmpStrBufSize = 0;
  47     m_Window = wnd;
  48     m_Container = NULL;
  49     m_DC = NULL;
  50     m_CharHeight = m_CharWidth = 0;
  51     m_UseLink = FALSE;
  52     m_EncConv = NULL;
  53     m_InputEnc = m_OutputEnc = wxFONTENCODING_DEFAULT;
  54
  55     {
  56         int i, j, k, l, m;
  57         for (i = 0; i < 2; i++)
  58             for (j = 0; j < 2; j++)
  59                 for (k = 0; k < 2; k++)
  60                     for (l = 0; l < 2; l++)
  61                         for (m = 0; m < 7; m++)
  62                         {
  63                             m_FontsTable[i][j][k][l][m] = NULL;
  64                             m_FontsFacesTable[i][j][k][l][m] = wxEmptyString;
  65                             m_FontsEncTable[i][j][k][l][m] = wxFONTENCODING_DEFAULT;
  66                         }
  67 #ifdef __WXMSW__
  68         static int default_sizes[7] = {7, 8, 10, 12, 16, 22, 30};
  69 #elif defined(__WXMAC__)
  70         static int default_sizes[7] = {9, 12, 14, 18, 24, 30, 36};
  71 #else
  72         static int default_sizes[7] = {10, 12, 14, 16, 19, 24, 32};
  73 #endif
  74         SetFonts("", "", default_sizes);
  75     }
  76
  77     // fill in wxHtmlParser's tables:
  78     wxNode *node = m_Modules.GetFirst();
  79     while (node)
  80     {
  81         wxHtmlTagsModule *mod = (wxHtmlTagsModule*) node->GetData();
  82         mod->FillHandlersTable(this);
  83         node = node->GetNext();
  84     }
  85 }
  86
  87
  88 wxHtmlWinParser::~wxHtmlWinParser()
  89 {
  90     int i, j, k, l, m;
  91
  92     for (i = 0; i < 2; i++)
  93         for (j = 0; j < 2; j++)
  94             for (k = 0; k < 2; k++)
  95                 for (l = 0; l < 2; l++)
  96                     for (m = 0; m < 7; m++)
  97                     {
  98                         if (m_FontsTable[i][j][k][l][m] != NULL)
  99                             delete m_FontsTable[i][j][k][l][m];
 100                     }
 101     delete m_EncConv;
 102     delete[] m_tmpStrBuf;
 103 }
 104
 105
 106 void wxHtmlWinParser::AddModule(wxHtmlTagsModule *module)
 107 {
 108     m_Modules.Append(module);
 109 }
 110
 111
 112
 113 void wxHtmlWinParser::RemoveModule(wxHtmlTagsModule *module)
 114 {
 115     m_Modules.DeleteObject(module);
 116 }
 117
 118
 119
 120 void wxHtmlWinParser::SetFonts(wxString normal_face, wxString fixed_face, const int *sizes)
 121 {
 122     int i, j, k, l, m;
 123
 124     for (i = 0; i < 7; i++) m_FontsSizes[i] = sizes[i];
 125     m_FontFaceFixed = fixed_face;
 126     m_FontFaceNormal = normal_face;
 127
 128     SetInputEncoding(m_InputEnc);
 129
 130     for (i = 0; i < 2; i++)
 131         for (j = 0; j < 2; j++)
 132             for (k = 0; k < 2; k++)
 133                 for (l = 0; l < 2; l++)
 134                     for (m = 0; m < 7; m++) {
 135                         if (m_FontsTable[i][j][k][l][m] != NULL)
 136                         {
 137                             delete m_FontsTable[i][j][k][l][m];
 138                             m_FontsTable[i][j][k][l][m] = NULL;
 139                         }
 140                     }
 141 }
 142
 143
 144
 145 void wxHtmlWinParser::InitParser(const wxString& source)
 146 {
 147     wxHtmlParser::InitParser(source);
 148     wxASSERT_MSG(m_DC != NULL, _T("no DC assigned to wxHtmlWinParser!!"));
 149
 150     m_FontBold = m_FontItalic = m_FontUnderlined = m_FontFixed = FALSE;
 151     m_FontSize = 3; //default one
 152     CreateCurrentFont();           // we're selecting default font into
 153     m_DC->GetTextExtent("H", &m_CharWidth, &m_CharHeight);
 154                 /* NOTE : we're not using GetCharWidth/Height() because
 155                    of differences under X and win
 156                  */
 157
 158     m_UseLink = FALSE;
 159     m_Link = wxHtmlLinkInfo("", "");
 160     m_LinkColor.Set(0, 0, 0xFF);
 161     m_ActualColor.Set(0, 0, 0);
 162     m_Align = wxHTML_ALIGN_LEFT;
 163     m_tmpLastWasSpace = FALSE;
 164
 165     OpenContainer();
 166
 167     OpenContainer();
 168     m_Container->InsertCell(new wxHtmlColourCell(m_ActualColor));
 169     m_Container->InsertCell(new wxHtmlFontCell(CreateCurrentFont()));
 170 }
 171
 172
 173
 174 void wxHtmlWinParser::DoneParser()
 175 {
 176     m_Container = NULL;
 177     SetInputEncoding(wxFONTENCODING_DEFAULT); // for next call
 178     wxHtmlParser::DoneParser();
 179 }
 180
 181
 182
 183 wxObject* wxHtmlWinParser::GetProduct()
 184 {
 185     wxHtmlContainerCell *top;
 186
 187     CloseContainer();
 188     OpenContainer();
 189
 190     top = m_Container;
 191     while (top->GetParent()) top = top->GetParent();
 192     return top;
 193 }
 194
 195
 196 void wxHtmlWinParser::AddText(const wxChar* txt)
 197 {
 198     wxHtmlCell *c;
 199     size_t i = 0,
 200            x,
 201            lng = wxStrlen(txt);
 202     register wxChar d;
 203     int templen = 0;
 204     wxChar nbsp = GetEntitiesParser()->GetCharForCode(160 /* nbsp */);
 205
 206     if (lng+1 > m_tmpStrBufSize)
 207     {
 208         delete[] m_tmpStrBuf;
 209         m_tmpStrBuf = new wxChar[lng+1];
 210         m_tmpStrBufSize = lng+1;
 211     }
 212     wxChar *temp = m_tmpStrBuf;
 213
 214     if (m_tmpLastWasSpace)
 215     {
 216         while ((i < lng) &&
 217                ((txt[i] == wxT('\n')) || (txt[i] == wxT('\r')) || (txt[i] == wxT(' ')) ||
 218                 (txt[i] == wxT('\t')))) i++;
 219     }
 220
 221     while (i < lng)
 222     {
 223         x = 0;
 224         d = temp[templen++] = txt[i];
 225         if ((d == wxT('\n')) || (d == wxT('\r')) || (d == wxT(' ')) || (d == wxT('\t')))
 226         {
 227             i++, x++;
 228             while ((i < lng) && ((txt[i] == wxT('\n')) || (txt[i] == wxT('\r')) ||
 229                                  (txt[i] == wxT(' ')) || (txt[i] == wxT('\t')))) i++, x++;
 230         }
 231         else i++;
 232
 233         if (x)
 234         {
 235             temp[templen-1] = wxT(' ');
 236             temp[templen] = 0;
 237             if (templen == 1) continue;
 238             templen = 0;
 239             if (m_EncConv)
 240                 m_EncConv->Convert(temp);
 241             wxString str = GetEntitiesParser()->Parse(temp);
 242             size_t len = str.Len();
 243             for (size_t j = 0; j < len; j++)
 244                 if (str.GetChar(j) == nbsp)
 245                     str[j] = wxT(' ');
 246             c = new wxHtmlWordCell(str, *(GetDC()));
 247             if (m_UseLink)
 248                 c->SetLink(m_Link);
 249             m_Container->InsertCell(c);
 250             m_tmpLastWasSpace = TRUE;
 251         }
 252     }
 253
 254     if (templen && (templen > 1 || temp[0] != wxT(' ')))
 255     {
 256         temp[templen] = 0;
 257         if (m_EncConv)
 258             m_EncConv->Convert(temp);
 259         wxString str = GetEntitiesParser()->Parse(temp);
 260         size_t len = str.Len();
 261         for (size_t j = 0; j < len; j++)
 262             if (str.GetChar(j) == nbsp)
 263                 str[j] = wxT(' ');
 264         c = new wxHtmlWordCell(str, *(GetDC()));
 265         if (m_UseLink)
 266             c->SetLink(m_Link);
 267         m_Container->InsertCell(c);
 268         m_tmpLastWasSpace = FALSE;
 269     }
 270 }
 271
 272
 273
 274 wxHtmlContainerCell* wxHtmlWinParser::OpenContainer()
 275 {
 276     m_Container = new wxHtmlContainerCell(m_Container);
 277     m_Container->SetAlignHor(m_Align);
 278     m_tmpLastWasSpace = TRUE;
 279         /* to avoid space being first character in paragraph */
 280     return m_Container;
 281 }
 282
 283
 284
 285 wxHtmlContainerCell* wxHtmlWinParser::SetContainer(wxHtmlContainerCell *c)
 286 {
 287     m_tmpLastWasSpace = TRUE;
 288         /* to avoid space being first character in paragraph */
 289     return m_Container = c;
 290 }
 291
 292
 293
 294 wxHtmlContainerCell* wxHtmlWinParser::CloseContainer()
 295 {
 296     m_Container = m_Container->GetParent();
 297     return m_Container;
 298 }
 299
 300
 301 void wxHtmlWinParser::SetFontSize(int s)
 302 {
 303     if (s < 1) s = 1;
 304     else if (s > 7) s = 7;
 305     m_FontSize = s;
 306 }
 307
 308
 309
 310 wxFont* wxHtmlWinParser::CreateCurrentFont()
 311 {
 312     int fb = GetFontBold(),
 313         fi = GetFontItalic(),
 314         fu = GetFontUnderlined(),
 315         ff = GetFontFixed(),
 316         fs = GetFontSize() - 1 /*remap from <1;7> to <0;6>*/ ;
 317
 318     wxString face = ff ? m_FontFaceFixed : m_FontFaceNormal;
 319     wxString *faceptr = &(m_FontsFacesTable[fb][fi][fu][ff][fs]);
 320     wxFont **fontptr = &(m_FontsTable[fb][fi][fu][ff][fs]);
 321     wxFontEncoding *encptr = &(m_FontsEncTable[fb][fi][fu][ff][fs]);
 322
 323     if (*fontptr != NULL && (*faceptr != face || *encptr != m_OutputEnc))
 324     {
 325         delete *fontptr;
 326         *fontptr = NULL;
 327     }
 328
 329     if (*fontptr == NULL)
 330     {
 331         *faceptr = face;
 332         *encptr = m_OutputEnc;
 333         *fontptr = new wxFont(
 334                        (int) (m_FontsSizes[fs] * m_PixelScale),
 335                        ff ? wxMODERN : wxSWISS,
 336                        fi ? wxITALIC : wxNORMAL,
 337                        fb ? wxBOLD : wxNORMAL,
 338                        fu ? TRUE : FALSE, face,
 339                        m_OutputEnc);
 340     }
 341     m_DC->SetFont(**fontptr);
 342     return (*fontptr);
 343 }
 344
 345
 346
 347 void wxHtmlWinParser::SetLink(const wxHtmlLinkInfo& link)
 348 {
 349     m_Link = link;
 350     m_UseLink = (link.GetHref() != wxEmptyString);
 351 }
 352
 353
 354 void wxHtmlWinParser::SetFontFace(const wxString& face)
 355 {
 356     if (GetFontFixed()) m_FontFaceFixed = face;
 357     else m_FontFaceNormal = face;
 358
 359     if (m_InputEnc != wxFONTENCODING_DEFAULT)
 360         SetInputEncoding(m_InputEnc);
 361 }
 362
 363
 364
 365 void wxHtmlWinParser::SetInputEncoding(wxFontEncoding enc)
 366 {
 367     m_InputEnc = m_OutputEnc = wxFONTENCODING_DEFAULT;
 368     if (m_EncConv)
 369     {
 370         delete m_EncConv;
 371         m_EncConv = NULL;
 372     }
 373
 374     if (enc == wxFONTENCODING_DEFAULT) return;
 375
 376     wxFontEncoding altfix, altnorm;
 377     bool availfix, availnorm;
 378
 379     // exact match?
 380     availnorm = wxTheFontMapper->IsEncodingAvailable(enc, m_FontFaceNormal);
 381     availfix = wxTheFontMapper->IsEncodingAvailable(enc, m_FontFaceFixed);
 382     if (availnorm && availfix)
 383         m_OutputEnc = enc;
 384
 385     // alternatives?
 386     else if (wxTheFontMapper->GetAltForEncoding(enc, &altnorm, m_FontFaceNormal, FALSE) &&
 387              wxTheFontMapper->GetAltForEncoding(enc, &altfix, m_FontFaceFixed, FALSE) &&
 388              altnorm == altfix)
 389         m_OutputEnc = altnorm;
 390
 391     // at least normal face?
 392     else if (availnorm)
 393         m_OutputEnc = enc;
 394     else if (wxTheFontMapper->GetAltForEncoding(enc, &altnorm, m_FontFaceNormal, FALSE))
 395         m_OutputEnc = altnorm;
 396
 397     // okay, let convert to ISO_8859-1, available always
 398     else
 399         m_OutputEnc = wxFONTENCODING_DEFAULT;
 400
 401     m_InputEnc = enc;
 402     if (m_OutputEnc == wxFONTENCODING_DEFAULT)
 403         GetEntitiesParser()->SetEncoding(wxFONTENCODING_SYSTEM);
 404     else
 405         GetEntitiesParser()->SetEncoding(m_OutputEnc);
 406
 407     if (m_InputEnc == m_OutputEnc) return;
 408
 409     m_EncConv = new wxEncodingConverter();
 410     if (!m_EncConv->Init(m_InputEnc,
 411                            (m_OutputEnc == wxFONTENCODING_DEFAULT) ?
 412                                       wxFONTENCODING_ISO8859_1 : m_OutputEnc,
 413                            wxCONVERT_SUBSTITUTE))
 414     { // total failture :-(
 415         wxLogError(_("Failed to display HTML document in %s encoding"),
 416                    wxFontMapper::GetEncodingName(enc).c_str());
 417         m_InputEnc = m_OutputEnc = wxFONTENCODING_DEFAULT;
 418         delete m_EncConv;
 419         m_EncConv = NULL;
 420     }
 421 }
 422
 423
 424
 425
 426
 427 //-----------------------------------------------------------------------------
 428 // wxHtmlWinTagHandler
 429 //-----------------------------------------------------------------------------
 430
 431 IMPLEMENT_ABSTRACT_CLASS(wxHtmlWinTagHandler, wxHtmlTagHandler)
 432
 433
 434
 435 //-----------------------------------------------------------------------------
 436 // wxHtmlTagsModule
 437 //-----------------------------------------------------------------------------
 438
 439
 440 IMPLEMENT_DYNAMIC_CLASS(wxHtmlTagsModule, wxModule)
 441
 442
 443 bool wxHtmlTagsModule::OnInit()
 444 {
 445     wxHtmlWinParser::AddModule(this);
 446     return TRUE;
 447 }
 448
 449
 450
 451 void wxHtmlTagsModule::OnExit()
 452 {
 453     wxHtmlWinParser::RemoveModule(this);
 454 }
 455 #endif
 456