src/richtext/richtextstyles.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/richtext/richtextstyles.cpp
   3 // Purpose:     Style management for wxRichTextCtrl
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     2005-09-30
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // For compilers that support precompilation, includes "wx.h".
  13 #include "wx/wxprec.h"
  14
  15 #ifdef __BORLANDC__
  16   #pragma hdrstop
  17 #endif
  18
  19 #if wxUSE_RICHTEXT
  20
  21 #include "wx/richtext/richtextstyles.h"
  22
  23 #ifndef WX_PRECOMP
  24   #include "wx/wx.h"
  25 #endif
  26
  27 #include "wx/filename.h"
  28 #include "wx/clipbrd.h"
  29 #include "wx/wfstream.h"
  30 #include "wx/settings.h"
  31
  32 #include "wx/richtext/richtextctrl.h"
  33
  34 IMPLEMENT_CLASS(wxRichTextStyleDefinition, wxObject)
  35 IMPLEMENT_CLASS(wxRichTextCharacterStyleDefinition, wxRichTextStyleDefinition)
  36 IMPLEMENT_CLASS(wxRichTextParagraphStyleDefinition, wxRichTextStyleDefinition)
  37 IMPLEMENT_CLASS(wxRichTextListStyleDefinition, wxRichTextParagraphStyleDefinition)
  38 IMPLEMENT_CLASS(wxRichTextBoxStyleDefinition, wxRichTextStyleDefinition)
  39
  40 /*!
  41  * A definition
  42  */
  43
  44 void wxRichTextStyleDefinition::Copy(const wxRichTextStyleDefinition& def)
  45 {
  46     m_name = def.m_name;
  47     m_baseStyle = def.m_baseStyle;
  48     m_style = def.m_style;
  49     m_description = def.m_description;
  50     m_properties = def.m_properties;
  51 }
  52
  53 bool wxRichTextStyleDefinition::Eq(const wxRichTextStyleDefinition& def) const
  54 {
  55     return (m_name == def.m_name && m_baseStyle == def.m_baseStyle && m_style == def.m_style && m_properties == def.m_properties);
  56 }
  57
  58 /// Gets the style combined with the base style
  59 wxRichTextAttr wxRichTextStyleDefinition::GetStyleMergedWithBase(const wxRichTextStyleSheet* sheet) const
  60 {
  61     if (m_baseStyle.IsEmpty())
  62         return m_style;
  63
  64     bool isParaStyle = IsKindOf(wxCLASSINFO(wxRichTextParagraphStyleDefinition));
  65     bool isCharStyle = IsKindOf(wxCLASSINFO(wxRichTextCharacterStyleDefinition));
  66     bool isListStyle = IsKindOf(wxCLASSINFO(wxRichTextListStyleDefinition));
  67     bool isBoxStyle  = IsKindOf(wxCLASSINFO(wxRichTextBoxStyleDefinition));
  68
  69     // Collect the styles, detecting loops
  70     wxArrayString styleNames;
  71     wxList styles;
  72     const wxRichTextStyleDefinition* def = this;
  73     while (def)
  74     {
  75         styles.Insert((wxObject*) def);
  76         styleNames.Add(def->GetName());
  77
  78         wxString baseStyleName = def->GetBaseStyle();
  79         if (!baseStyleName.IsEmpty() && styleNames.Index(baseStyleName) == wxNOT_FOUND)
  80         {
  81             if (isParaStyle)
  82                 def = sheet->FindParagraphStyle(baseStyleName);
  83             else if (isCharStyle)
  84                 def = sheet->FindCharacterStyle(baseStyleName);
  85             else if (isListStyle)
  86                 def = sheet->FindListStyle(baseStyleName);
  87             else if (isBoxStyle)
  88                 def = sheet->FindBoxStyle(baseStyleName);
  89             else
  90                 def = sheet->FindStyle(baseStyleName);
  91         }
  92         else
  93             def = NULL;
  94     }
  95
  96     wxRichTextAttr attr;
  97     wxList::compatibility_iterator node = styles.GetFirst();
  98     while (node)
  99     {
 100         wxRichTextStyleDefinition* def = (wxRichTextStyleDefinition*) node->GetData();
 101         attr.Apply(def->GetStyle(), NULL);
 102         node = node->GetNext();
 103     }
 104
 105     return attr;
 106 }
 107
 108 /*!
 109  * Paragraph style definition
 110  */
 111
 112 void wxRichTextParagraphStyleDefinition::Copy(const wxRichTextParagraphStyleDefinition& def)
 113 {
 114     wxRichTextStyleDefinition::Copy(def);
 115
 116     m_nextStyle = def.m_nextStyle;
 117 }
 118
 119 bool wxRichTextParagraphStyleDefinition::operator ==(const wxRichTextParagraphStyleDefinition& def) const
 120 {
 121     return (Eq(def) && m_nextStyle == def.m_nextStyle);
 122 }
 123
 124 /*!
 125  * Box style definition
 126  */
 127
 128 void wxRichTextBoxStyleDefinition::Copy(const wxRichTextBoxStyleDefinition& def)
 129 {
 130     wxRichTextStyleDefinition::Copy(def);
 131 }
 132
 133 bool wxRichTextBoxStyleDefinition::operator ==(const wxRichTextBoxStyleDefinition& def) const
 134 {
 135     return (Eq(def));
 136 }
 137
 138 /*!
 139  * List style definition
 140  */
 141
 142 void wxRichTextListStyleDefinition::Copy(const wxRichTextListStyleDefinition& def)
 143 {
 144     wxRichTextParagraphStyleDefinition::Copy(def);
 145
 146     int i;
 147     for (i = 0; i < 10; i++)
 148         m_levelStyles[i] = def.m_levelStyles[i];
 149 }
 150
 151 bool wxRichTextListStyleDefinition::operator ==(const wxRichTextListStyleDefinition& def) const
 152 {
 153     if (!Eq(def))
 154         return false;
 155     int i;
 156     for (i = 0; i < 10; i++)
 157         if (!(m_levelStyles[i] == def.m_levelStyles[i]))
 158             return false;
 159
 160     return true;
 161 }
 162
 163 /// Sets/gets the attributes for the given level
 164 void wxRichTextListStyleDefinition::SetLevelAttributes(int i, const wxRichTextAttr& attr)
 165 {
 166     wxASSERT( (i >= 0 && i < 10) );
 167     if (i >= 0 && i < 10)
 168         m_levelStyles[i] = attr;
 169 }
 170
 171 const wxRichTextAttr* wxRichTextListStyleDefinition::GetLevelAttributes(int i) const
 172 {
 173     wxASSERT( (i >= 0 && i < 10) );
 174     if (i >= 0 && i < 10)
 175         return & m_levelStyles[i];
 176     else
 177         return NULL;
 178 }
 179
 180 wxRichTextAttr* wxRichTextListStyleDefinition::GetLevelAttributes(int i)
 181 {
 182     wxASSERT( (i >= 0 && i < 10) );
 183     if (i >= 0 && i < 10)
 184         return & m_levelStyles[i];
 185     else
 186         return NULL;
 187 }
 188
 189 /// Convenience function for setting the major attributes for a list level specification
 190 void wxRichTextListStyleDefinition::SetAttributes(int i, int leftIndent, int leftSubIndent, int bulletStyle, const wxString& bulletSymbol)
 191 {
 192     wxASSERT( (i >= 0 && i < 10) );
 193     if (i >= 0 && i < 10)
 194     {
 195         wxRichTextAttr attr;
 196
 197         attr.SetBulletStyle(bulletStyle);
 198         attr.SetLeftIndent(leftIndent, leftSubIndent);
 199
 200         if (!bulletSymbol.IsEmpty())
 201         {
 202             if (bulletStyle & wxTEXT_ATTR_BULLET_STYLE_SYMBOL)
 203                 attr.SetBulletText(bulletSymbol);
 204             else
 205                 attr.SetBulletName(bulletSymbol);
 206         }
 207
 208         m_levelStyles[i] = attr;
 209     }
 210 }
 211
 212 /// Finds the level corresponding to the given indentation
 213 int wxRichTextListStyleDefinition::FindLevelForIndent(int indent) const
 214 {
 215     int i;
 216     for (i = 0; i < 10; i++)
 217     {
 218         if (indent < m_levelStyles[i].GetLeftIndent())
 219         {
 220             if (i > 0)
 221                 return i - 1;
 222             else
 223                 return 0;
 224         }
 225     }
 226     return 9;
 227 }
 228
 229 /// Combine the list style with a paragraph style, using the given indent (from which
 230 /// an appropriate level is found)
 231 wxRichTextAttr wxRichTextListStyleDefinition::CombineWithParagraphStyle(int indent, const wxRichTextAttr& paraStyle, wxRichTextStyleSheet* styleSheet)
 232 {
 233     int listLevel = FindLevelForIndent(indent);
 234
 235     wxRichTextAttr attr(*GetLevelAttributes(listLevel));
 236     int oldLeftIndent = attr.GetLeftIndent();
 237     int oldLeftSubIndent = attr.GetLeftSubIndent();
 238
 239     // First apply the overall paragraph style, if any
 240     if (styleSheet)
 241         attr.Apply(GetStyleMergedWithBase(styleSheet));
 242     else
 243         attr.Apply(GetStyle());
 244
 245     // Then apply paragraph style, e.g. from paragraph style definition
 246     attr.Apply(paraStyle);
 247
 248     // We override the indents according to the list definition
 249     attr.SetLeftIndent(oldLeftIndent, oldLeftSubIndent);
 250
 251     return attr;
 252 }
 253
 254 /// Combine the base and list style, using the given indent (from which
 255 /// an appropriate level is found)
 256 wxRichTextAttr wxRichTextListStyleDefinition::GetCombinedStyle(int indent, wxRichTextStyleSheet* styleSheet)
 257 {
 258     int listLevel = FindLevelForIndent(indent);
 259     return GetCombinedStyleForLevel(listLevel, styleSheet);
 260 }
 261
 262 /// Combine the base and list style, using the given indent (from which
 263 /// an appropriate level is found)
 264 wxRichTextAttr wxRichTextListStyleDefinition::GetCombinedStyleForLevel(int listLevel, wxRichTextStyleSheet* styleSheet)
 265 {
 266     wxRichTextAttr attr(*GetLevelAttributes(listLevel));
 267     int oldLeftIndent = attr.GetLeftIndent();
 268     int oldLeftSubIndent = attr.GetLeftSubIndent();
 269
 270     // Apply the overall paragraph style, if any
 271     if (styleSheet)
 272         attr.Apply(GetStyleMergedWithBase(styleSheet));
 273     else
 274         attr.Apply(GetStyle());
 275
 276     // We override the indents according to the list definition
 277     attr.SetLeftIndent(oldLeftIndent, oldLeftSubIndent);
 278
 279     return attr;
 280 }
 281
 282 /// Is this a numbered list?
 283 bool wxRichTextListStyleDefinition::IsNumbered(int i) const
 284 {
 285     return (0 != (GetLevelAttributes(i)->GetFlags() &
 286                    (wxTEXT_ATTR_BULLET_STYLE_ARABIC|wxTEXT_ATTR_BULLET_STYLE_LETTERS_UPPER|wxTEXT_ATTR_BULLET_STYLE_LETTERS_LOWER|
 287                     wxTEXT_ATTR_BULLET_STYLE_ROMAN_UPPER|wxTEXT_ATTR_BULLET_STYLE_ROMAN_LOWER)));
 288 }
 289
 290 /*!
 291  * The style manager
 292  */
 293
 294 IMPLEMENT_CLASS(wxRichTextStyleSheet, wxObject)
 295
 296 wxRichTextStyleSheet::~wxRichTextStyleSheet()
 297 {
 298     DeleteStyles();
 299
 300     if (m_nextSheet)
 301         m_nextSheet->m_previousSheet = m_previousSheet;
 302
 303     if (m_previousSheet)
 304         m_previousSheet->m_nextSheet = m_nextSheet;
 305
 306     m_previousSheet = NULL;
 307     m_nextSheet = NULL;
 308 }
 309
 310 /// Initialisation
 311 void wxRichTextStyleSheet::Init()
 312 {
 313     m_previousSheet = NULL;
 314     m_nextSheet = NULL;
 315 }
 316
 317 /// Add a definition to one of the style lists
 318 bool wxRichTextStyleSheet::AddStyle(wxList& list, wxRichTextStyleDefinition* def)
 319 {
 320     if (!list.Find(def))
 321         list.Append(def);
 322     return true;
 323 }
 324
 325 /// Remove a style
 326 bool wxRichTextStyleSheet::RemoveStyle(wxList& list, wxRichTextStyleDefinition* def, bool deleteStyle)
 327 {
 328     wxList::compatibility_iterator node = list.Find(def);
 329     if (node)
 330     {
 331         wxRichTextStyleDefinition* def = (wxRichTextStyleDefinition*) node->GetData();
 332         list.Erase(node);
 333         if (deleteStyle)
 334             delete def;
 335         return true;
 336     }
 337     else
 338         return false;
 339 }
 340
 341 /// Remove a style
 342 bool wxRichTextStyleSheet::RemoveStyle(wxRichTextStyleDefinition* def, bool deleteStyle)
 343 {
 344     if (RemoveParagraphStyle(def, deleteStyle))
 345         return true;
 346     if (RemoveCharacterStyle(def, deleteStyle))
 347         return true;
 348     if (RemoveListStyle(def, deleteStyle))
 349         return true;
 350     if (RemoveBoxStyle(def, deleteStyle))
 351         return true;
 352     return false;
 353 }
 354
 355 /// Find a definition by name
 356 wxRichTextStyleDefinition* wxRichTextStyleSheet::FindStyle(const wxList& list, const wxString& name, bool recurse) const
 357 {
 358     for (wxList::compatibility_iterator node = list.GetFirst(); node; node = node->GetNext())
 359     {
 360         wxRichTextStyleDefinition* def = (wxRichTextStyleDefinition*) node->GetData();
 361         if (def->GetName() == name)
 362             return def;
 363     }
 364
 365     if (m_nextSheet && recurse)
 366         return m_nextSheet->FindStyle(list, name, recurse);
 367
 368     return NULL;
 369 }
 370
 371 /// Delete all styles
 372 void wxRichTextStyleSheet::DeleteStyles()
 373 {
 374     WX_CLEAR_LIST(wxList, m_characterStyleDefinitions);
 375     WX_CLEAR_LIST(wxList, m_paragraphStyleDefinitions);
 376     WX_CLEAR_LIST(wxList, m_listStyleDefinitions);
 377     WX_CLEAR_LIST(wxList, m_boxStyleDefinitions);
 378 }
 379
 380 /// Insert into list of style sheets
 381 bool wxRichTextStyleSheet::InsertSheet(wxRichTextStyleSheet* before)
 382 {
 383     m_previousSheet = before->m_previousSheet;
 384     m_nextSheet = before;
 385
 386     before->m_previousSheet = this;
 387     return true;
 388 }
 389
 390 /// Append to list of style sheets
 391 bool wxRichTextStyleSheet::AppendSheet(wxRichTextStyleSheet* after)
 392 {
 393     wxRichTextStyleSheet* last = after;
 394     while (last && last->m_nextSheet)
 395     {
 396         last = last->m_nextSheet;
 397     }
 398
 399     if (last)
 400     {
 401         m_previousSheet = last;
 402         last->m_nextSheet = this;
 403
 404         return true;
 405     }
 406     else
 407         return false;
 408 }
 409
 410 /// Unlink from the list of style sheets
 411 void wxRichTextStyleSheet::Unlink()
 412 {
 413     if (m_previousSheet)
 414         m_previousSheet->m_nextSheet = m_nextSheet;
 415     if (m_nextSheet)
 416         m_nextSheet->m_previousSheet = m_previousSheet;
 417
 418     m_previousSheet = NULL;
 419     m_nextSheet = NULL;
 420 }
 421
 422 /// Add a definition to the character style list
 423 bool wxRichTextStyleSheet::AddCharacterStyle(wxRichTextCharacterStyleDefinition* def)
 424 {
 425     def->GetStyle().SetCharacterStyleName(def->GetName());
 426     return AddStyle(m_characterStyleDefinitions, def);
 427 }
 428
 429 /// Add a definition to the paragraph style list
 430 bool wxRichTextStyleSheet::AddParagraphStyle(wxRichTextParagraphStyleDefinition* def)
 431 {
 432     def->GetStyle().SetParagraphStyleName(def->GetName());
 433     return AddStyle(m_paragraphStyleDefinitions, def);
 434 }
 435
 436 /// Add a definition to the list style list
 437 bool wxRichTextStyleSheet::AddListStyle(wxRichTextListStyleDefinition* def)
 438 {
 439     def->GetStyle().SetListStyleName(def->GetName());
 440     return AddStyle(m_listStyleDefinitions, def);
 441 }
 442
 443 /// Add a definition to the box style list
 444 bool wxRichTextStyleSheet::AddBoxStyle(wxRichTextBoxStyleDefinition* def)
 445 {
 446     def->GetStyle().GetTextBoxAttr().SetBoxStyleName(def->GetName());
 447     return AddStyle(m_boxStyleDefinitions, def);
 448 }
 449
 450 /// Add a definition to the appropriate style list
 451 bool wxRichTextStyleSheet::AddStyle(wxRichTextStyleDefinition* def)
 452 {
 453     wxRichTextListStyleDefinition* listDef = wxDynamicCast(def, wxRichTextListStyleDefinition);
 454     if (listDef)
 455         return AddListStyle(listDef);
 456
 457     wxRichTextParagraphStyleDefinition* paraDef = wxDynamicCast(def, wxRichTextParagraphStyleDefinition);
 458     if (paraDef)
 459         return AddParagraphStyle(paraDef);
 460
 461     wxRichTextCharacterStyleDefinition* charDef = wxDynamicCast(def, wxRichTextCharacterStyleDefinition);
 462     if (charDef)
 463         return AddCharacterStyle(charDef);
 464
 465     wxRichTextBoxStyleDefinition* boxDef = wxDynamicCast(def, wxRichTextBoxStyleDefinition);
 466     if (boxDef)
 467         return AddBoxStyle(boxDef);
 468
 469     return false;
 470 }
 471
 472 /// Find any definition by name
 473 wxRichTextStyleDefinition* wxRichTextStyleSheet::FindStyle(const wxString& name, bool recurse) const
 474 {
 475     wxRichTextListStyleDefinition* listDef = FindListStyle(name, recurse);
 476     if (listDef)
 477         return listDef;
 478
 479     wxRichTextParagraphStyleDefinition* paraDef = FindParagraphStyle(name, recurse);
 480     if (paraDef)
 481         return paraDef;
 482
 483     wxRichTextCharacterStyleDefinition* charDef = FindCharacterStyle(name, recurse);
 484     if (charDef)
 485         return charDef;
 486
 487     wxRichTextBoxStyleDefinition* boxDef = FindBoxStyle(name, recurse);
 488     if (boxDef)
 489         return boxDef;
 490
 491     return NULL;
 492 }
 493
 494 /// Copy
 495 void wxRichTextStyleSheet::Copy(const wxRichTextStyleSheet& sheet)
 496 {
 497     DeleteStyles();
 498
 499     wxList::compatibility_iterator node;
 500
 501     for (node = sheet.m_characterStyleDefinitions.GetFirst(); node; node = node->GetNext())
 502     {
 503         wxRichTextCharacterStyleDefinition* def = (wxRichTextCharacterStyleDefinition*) node->GetData();
 504         AddCharacterStyle(new wxRichTextCharacterStyleDefinition(*def));
 505     }
 506
 507     for (node = sheet.m_paragraphStyleDefinitions.GetFirst(); node; node = node->GetNext())
 508     {
 509         wxRichTextParagraphStyleDefinition* def = (wxRichTextParagraphStyleDefinition*) node->GetData();
 510         AddParagraphStyle(new wxRichTextParagraphStyleDefinition(*def));
 511     }
 512
 513     for (node = sheet.m_listStyleDefinitions.GetFirst(); node; node = node->GetNext())
 514     {
 515         wxRichTextListStyleDefinition* def = (wxRichTextListStyleDefinition*) node->GetData();
 516         AddListStyle(new wxRichTextListStyleDefinition(*def));
 517     }
 518
 519     for (node = sheet.m_boxStyleDefinitions.GetFirst(); node; node = node->GetNext())
 520     {
 521         wxRichTextBoxStyleDefinition* def = (wxRichTextBoxStyleDefinition*) node->GetData();
 522         AddBoxStyle(new wxRichTextBoxStyleDefinition(*def));
 523     }
 524
 525     SetName(sheet.GetName());
 526     SetDescription(sheet.GetDescription());
 527     m_properties = sheet.m_properties;
 528 }
 529
 530 /// Equality
 531 bool wxRichTextStyleSheet::operator==(const wxRichTextStyleSheet& WXUNUSED(sheet)) const
 532 {
 533     // TODO
 534     return false;
 535 }
 536
 537
 538 #if wxUSE_HTML
 539
 540 // Functions for dealing with clashing names for different kinds of style.
 541 // Returns "P", "C", "L" or "B" (paragraph, character, list or box) for
 542 // style name | type.
 543 static wxString wxGetRichTextStyleType(const wxString& style)
 544 {
 545     return style.AfterLast(wxT('|'));
 546 }
 547
 548 static wxString wxGetRichTextStyle(const wxString& style)
 549 {
 550     return style.BeforeLast(wxT('|'));
 551 }
 552
 553
 554 /*!
 555  * wxRichTextStyleListBox: a listbox to display styles.
 556  */
 557
 558 IMPLEMENT_CLASS(wxRichTextStyleListBox, wxHtmlListBox)
 559
 560 BEGIN_EVENT_TABLE(wxRichTextStyleListBox, wxHtmlListBox)
 561     EVT_LEFT_DOWN(wxRichTextStyleListBox::OnLeftDown)
 562     EVT_LEFT_DCLICK(wxRichTextStyleListBox::OnLeftDoubleClick)
 563     EVT_IDLE(wxRichTextStyleListBox::OnIdle)
 564 END_EVENT_TABLE()
 565
 566 wxRichTextStyleListBox::wxRichTextStyleListBox(wxWindow* parent, wxWindowID id, const wxPoint& pos,
 567     const wxSize& size, long style)
 568 {
 569     Init();
 570     Create(parent, id, pos, size, style);
 571 }
 572
 573 bool wxRichTextStyleListBox::Create(wxWindow* parent, wxWindowID id, const wxPoint& pos,
 574         const wxSize& size, long style)
 575 {
 576     return wxHtmlListBox::Create(parent, id, pos, size, style);
 577 }
 578
 579 wxRichTextStyleListBox::~wxRichTextStyleListBox()
 580 {
 581 }
 582
 583 /// Returns the HTML for this item
 584 wxString wxRichTextStyleListBox::OnGetItem(size_t n) const
 585 {
 586     if (!GetStyleSheet())
 587         return wxEmptyString;
 588
 589     wxRichTextStyleDefinition* def = GetStyle(n);
 590     if (def)
 591         return CreateHTML(def);
 592
 593     return wxEmptyString;
 594 }
 595
 596 // Get style for index
 597 wxRichTextStyleDefinition* wxRichTextStyleListBox::GetStyle(size_t i) const
 598 {
 599     if (!GetStyleSheet())
 600         return NULL;
 601
 602     if (i >= m_styleNames.GetCount() /* || i < 0 */ )
 603         return NULL;
 604
 605     wxString styleType = wxGetRichTextStyleType(m_styleNames[i]);
 606     wxString style = wxGetRichTextStyle(m_styleNames[i]);
 607     if (styleType == wxT("P"))
 608         return GetStyleSheet()->FindParagraphStyle(style);
 609     else if (styleType == wxT("C"))
 610         return GetStyleSheet()->FindCharacterStyle(style);
 611     else if (styleType == wxT("L"))
 612         return GetStyleSheet()->FindListStyle(style);
 613     else if (styleType == wxT("B"))
 614         return GetStyleSheet()->FindBoxStyle(style);
 615     else
 616         return GetStyleSheet()->FindStyle(style);
 617 }
 618
 619 /// Updates the list
 620 void wxRichTextStyleListBox::UpdateStyles()
 621 {
 622     if (GetStyleSheet())
 623     {
 624         int oldSel = GetSelection();
 625
 626         SetSelection(wxNOT_FOUND);
 627
 628         m_styleNames.Clear();
 629
 630         size_t i;
 631         if (GetStyleType() == wxRICHTEXT_STYLE_ALL || GetStyleType() == wxRICHTEXT_STYLE_PARAGRAPH)
 632         {
 633             for (i = 0; i < GetStyleSheet()->GetParagraphStyleCount(); i++)
 634                 m_styleNames.Add(GetStyleSheet()->GetParagraphStyle(i)->GetName() + wxT("|P"));
 635         }
 636         if (GetStyleType() == wxRICHTEXT_STYLE_ALL || GetStyleType() == wxRICHTEXT_STYLE_CHARACTER)
 637         {
 638             for (i = 0; i < GetStyleSheet()->GetCharacterStyleCount(); i++)
 639                 m_styleNames.Add(GetStyleSheet()->GetCharacterStyle(i)->GetName() + wxT("|C"));
 640         }
 641         if (GetStyleType() == wxRICHTEXT_STYLE_ALL || GetStyleType() == wxRICHTEXT_STYLE_LIST)
 642         {
 643             for (i = 0; i < GetStyleSheet()->GetListStyleCount(); i++)
 644                 m_styleNames.Add(GetStyleSheet()->GetListStyle(i)->GetName() + wxT("|L"));
 645         }
 646         if (GetStyleType() == wxRICHTEXT_STYLE_ALL || GetStyleType() == wxRICHTEXT_STYLE_BOX)
 647         {
 648             for (i = 0; i < GetStyleSheet()->GetBoxStyleCount(); i++)
 649                 m_styleNames.Add(GetStyleSheet()->GetBoxStyle(i)->GetName() + wxT("|B"));
 650         }
 651
 652         m_styleNames.Sort();
 653         SetItemCount(m_styleNames.GetCount());
 654
 655         Refresh();
 656
 657         int newSel = -1;
 658         if (oldSel >= 0 && oldSel < (int) GetItemCount())
 659             newSel = oldSel;
 660         else if (GetItemCount() > 0)
 661             newSel = 0;
 662
 663         if (newSel >= 0)
 664         {
 665             SetSelection(newSel);
 666             SendSelectedEvent();
 667         }
 668     }
 669     else
 670     {
 671         m_styleNames.Clear();
 672         SetSelection(wxNOT_FOUND);
 673         SetItemCount(0);
 674         Refresh();
 675     }
 676 }
 677
 678 // Get index for style name
 679 int wxRichTextStyleListBox::GetIndexForStyle(const wxString& name) const
 680 {
 681     wxString s(name);
 682     if (GetStyleType() == wxRICHTEXT_STYLE_PARAGRAPH)
 683         s += wxT("|P");
 684     else if (GetStyleType() == wxRICHTEXT_STYLE_CHARACTER)
 685         s += wxT("|C");
 686     else if (GetStyleType() == wxRICHTEXT_STYLE_LIST)
 687         s += wxT("|L");
 688     else if (GetStyleType() == wxRICHTEXT_STYLE_BOX)
 689         s += wxT("|B");
 690     else
 691     {
 692         if (m_styleNames.Index(s + wxT("|P")) != wxNOT_FOUND)
 693             s += wxT("|P");
 694         else if (m_styleNames.Index(s + wxT("|C")) != wxNOT_FOUND)
 695             s += wxT("|C");
 696         else if (m_styleNames.Index(s + wxT("|L")) != wxNOT_FOUND)
 697             s += wxT("|L");
 698         else if (m_styleNames.Index(s + wxT("|B")) != wxNOT_FOUND)
 699             s += wxT("|B");
 700     }
 701     return m_styleNames.Index(s);
 702 }
 703
 704 /// Set selection for string
 705 int wxRichTextStyleListBox::SetStyleSelection(const wxString& name)
 706 {
 707     int i = GetIndexForStyle(name);
 708     if (i > -1)
 709     {
 710         SetSelection(i);
 711         if (!IsVisible(i))
 712             ScrollToRow(i);
 713     }
 714     return i;
 715 }
 716
 717 // Convert a colour to a 6-digit hex string
 718 static wxString ColourToHexString(const wxColour& col)
 719 {
 720     wxString hex;
 721
 722     hex += wxDecToHex(col.Red());
 723     hex += wxDecToHex(col.Green());
 724     hex += wxDecToHex(col.Blue());
 725
 726     return hex;
 727 }
 728
 729 /// Creates a suitable HTML fragment for a definition
 730 wxString wxRichTextStyleListBox::CreateHTML(wxRichTextStyleDefinition* def) const
 731 {
 732     // TODO: indicate list format for list style types
 733
 734     wxString str;
 735
 736     bool isCentred = false;
 737
 738     wxRichTextAttr attr(def->GetStyleMergedWithBase(GetStyleSheet()));
 739
 740     if (attr.HasAlignment() && attr.GetAlignment() == wxTEXT_ALIGNMENT_CENTRE)
 741         isCentred = true;
 742
 743     str << wxT("<html><head></head>");
 744     str << wxT("<body");
 745     if (attr.GetBackgroundColour().Ok())
 746         str << wxT(" bgcolor=\"#") << ColourToHexString(attr.GetBackgroundColour()) << wxT("\"");
 747     str << wxT(">");
 748
 749     if (isCentred)
 750         str << wxT("<center>");
 751
 752     str << wxT("<table");
 753     if (attr.GetBackgroundColour().Ok())
 754         str << wxT(" bgcolor=\"#") << ColourToHexString(attr.GetBackgroundColour()) << wxT("\"");
 755
 756     str << wxT("><tr>");
 757
 758     if (attr.GetLeftIndent() > 0)
 759     {
 760         wxClientDC dc((wxWindow*) this);
 761
 762         str << wxT("<td width=") << wxMin(50, (ConvertTenthsMMToPixels(dc, attr.GetLeftIndent())/2)) << wxT("></td>");
 763     }
 764
 765     if (isCentred)
 766         str << wxT("<td nowrap align=\"center\">");
 767     else
 768         str << wxT("<td nowrap>");
 769
 770 #ifdef __WXMSW__
 771     int size = 2;
 772 #else
 773     int size = 3;
 774 #endif
 775
 776     // Guess a standard font size
 777     int stdFontSize = 0;
 778
 779     // First see if we have a default/normal style to base the size on
 780     wxString normalTranslated(_("normal"));
 781     wxString defaultTranslated(_("default"));
 782     size_t i;
 783     for (i = 0; i < GetStyleSheet()->GetParagraphStyleCount(); i++)
 784     {
 785         wxRichTextStyleDefinition* d = GetStyleSheet()->GetParagraphStyle(i);
 786         wxString name = d->GetName().Lower();
 787         if (name.Find(wxT("normal")) != wxNOT_FOUND || name.Find(normalTranslated) != wxNOT_FOUND ||
 788             name.Find(wxT("default")) != wxNOT_FOUND || name.Find(defaultTranslated) != wxNOT_FOUND)
 789         {
 790             wxRichTextAttr attr2(d->GetStyleMergedWithBase(GetStyleSheet()));
 791             if (attr2.HasFontPointSize())
 792             {
 793                 stdFontSize = attr2.GetFontSize();
 794                 break;
 795             }
 796         }
 797     }
 798
 799     if (stdFontSize == 0)
 800     {
 801         // Look at sizes up to 20 points, and see which is the most common
 802         wxArrayInt sizes;
 803         size_t maxSize = 20;
 804         for (i = 0; i <= maxSize; i++)
 805             sizes.Add(0);
 806         for (i = 0; i < m_styleNames.GetCount(); i++)
 807         {
 808             wxRichTextStyleDefinition* d = GetStyle(i);
 809             if (d)
 810             {
 811                 wxRichTextAttr attr2(d->GetStyleMergedWithBase(GetStyleSheet()));
 812                 if (attr2.HasFontPointSize())
 813                 {
 814                     if (attr2.GetFontSize() <= (int) maxSize)
 815                         sizes[attr2.GetFontSize()] ++;
 816                 }
 817             }
 818         }
 819         int mostCommonSize = 0;
 820         for (i = 0; i <= maxSize; i++)
 821         {
 822             if (sizes[i] > mostCommonSize)
 823                 mostCommonSize = i;
 824         }
 825         if (mostCommonSize > 0)
 826             stdFontSize = mostCommonSize;
 827     }
 828
 829     if (stdFontSize == 0)
 830         stdFontSize = 12;
 831
 832     int thisFontSize = attr.HasFontPointSize() ? attr.GetFontSize() : stdFontSize;
 833
 834     if (thisFontSize < stdFontSize)
 835         size --;
 836     else if (thisFontSize > stdFontSize)
 837         size ++;
 838
 839     str += wxT("<font");
 840
 841     str << wxT(" size=") << size;
 842
 843     if (!attr.GetFontFaceName().IsEmpty())
 844         str << wxT(" face=\"") << attr.GetFontFaceName() << wxT("\"");
 845
 846     if (attr.GetTextColour().IsOk())
 847         str << wxT(" color=\"#") << ColourToHexString(attr.GetTextColour()) << wxT("\"");
 848
 849     if (attr.GetBackgroundColour().Ok())
 850         str << wxT(" bgcolor=\"#") << ColourToHexString(attr.GetBackgroundColour()) << wxT("\"");
 851
 852     str << wxT(">");
 853
 854     bool hasBold = false;
 855     bool hasItalic = false;
 856     bool hasUnderline = false;
 857
 858     if (attr.GetFontWeight() == wxFONTWEIGHT_BOLD)
 859         hasBold = true;
 860     if (attr.GetFontStyle() == wxFONTSTYLE_ITALIC)
 861         hasItalic = true;
 862     if (attr.GetFontUnderlined())
 863         hasUnderline = true;
 864
 865     if (hasBold)
 866         str << wxT("<b>");
 867     if (hasItalic)
 868         str << wxT("<i>");
 869     if (hasUnderline)
 870         str << wxT("<u>");
 871
 872     str += def->GetName();
 873
 874     if (hasUnderline)
 875         str << wxT("</u>");
 876     if (hasItalic)
 877         str << wxT("</i>");
 878     if (hasBold)
 879         str << wxT("</b>");
 880
 881     if (isCentred)
 882         str << wxT("</centre>");
 883
 884     str << wxT("</font>");
 885
 886     str << wxT("</td></tr></table>");
 887
 888     if (isCentred)
 889         str << wxT("</center>");
 890
 891     str << wxT("</body></html>");
 892     return str;
 893 }
 894
 895 // Convert units in tends of a millimetre to device units
 896 int wxRichTextStyleListBox::ConvertTenthsMMToPixels(wxDC& dc, int units) const
 897 {
 898     int ppi = dc.GetPPI().x;
 899
 900     // There are ppi pixels in 254.1 "1/10 mm"
 901
 902     double pixels = ((double) units * (double)ppi) / 254.1;
 903
 904     return (int) pixels;
 905 }
 906
 907 void wxRichTextStyleListBox::OnLeftDown(wxMouseEvent& event)
 908 {
 909     wxVListBox::OnLeftDown(event);
 910
 911     int item = VirtualHitTest(event.GetPosition().y);
 912     if (item != wxNOT_FOUND && GetApplyOnSelection())
 913         ApplyStyle(item);
 914 }
 915
 916 void wxRichTextStyleListBox::OnLeftDoubleClick(wxMouseEvent& event)
 917 {
 918     wxVListBox::OnLeftDown(event);
 919
 920     int item = VirtualHitTest(event.GetPosition().y);
 921     if (item != wxNOT_FOUND && !GetApplyOnSelection())
 922         ApplyStyle(item);
 923 }
 924
 925 /// Helper for listbox and combo control
 926 wxString wxRichTextStyleListBox::GetStyleToShowInIdleTime(wxRichTextCtrl* ctrl, wxRichTextStyleType styleType)
 927 {
 928     int adjustedCaretPos = ctrl->GetAdjustedCaretPosition(ctrl->GetCaretPosition());
 929
 930     wxString styleName;
 931
 932     wxRichTextAttr attr;
 933     ctrl->GetStyle(adjustedCaretPos, attr);
 934
 935     // Take into account current default style just chosen by user
 936     if (ctrl->IsDefaultStyleShowing())
 937     {
 938         wxRichTextApplyStyle(attr, ctrl->GetDefaultStyleEx());
 939
 940         if ((styleType == wxRICHTEXT_STYLE_ALL || styleType == wxRICHTEXT_STYLE_CHARACTER) &&
 941                           !attr.GetCharacterStyleName().IsEmpty())
 942             styleName = attr.GetCharacterStyleName();
 943         else if ((styleType == wxRICHTEXT_STYLE_ALL || styleType == wxRICHTEXT_STYLE_PARAGRAPH) &&
 944                           !attr.GetParagraphStyleName().IsEmpty())
 945             styleName = attr.GetParagraphStyleName();
 946         else if ((styleType == wxRICHTEXT_STYLE_ALL || styleType == wxRICHTEXT_STYLE_LIST) &&
 947                           !attr.GetListStyleName().IsEmpty())
 948             styleName = attr.GetListStyleName();
 949         // TODO: when we have a concept of focused object (text box), we'll
 950         // use the paragraph style name of the focused object as the frame style name.
 951 #if 0
 952         else if ((styleType == wxRICHTEXT_STYLE_ALL || styleType == wxRICHTEXT_STYLE_BOX) &&
 953                           !attr.GetBoxStyleName().IsEmpty())
 954             styleName = attr.GetBoxStyleName();
 955 #endif
 956     }
 957     else if ((styleType == wxRICHTEXT_STYLE_ALL || styleType == wxRICHTEXT_STYLE_CHARACTER) &&
 958              !attr.GetCharacterStyleName().IsEmpty())
 959     {
 960         styleName = attr.GetCharacterStyleName();
 961     }
 962     else if ((styleType == wxRICHTEXT_STYLE_ALL || styleType == wxRICHTEXT_STYLE_PARAGRAPH) &&
 963              !attr.GetParagraphStyleName().IsEmpty())
 964     {
 965         styleName = attr.GetParagraphStyleName();
 966     }
 967     else if ((styleType == wxRICHTEXT_STYLE_ALL || styleType == wxRICHTEXT_STYLE_LIST) &&
 968              !attr.GetListStyleName().IsEmpty())
 969     {
 970         styleName = attr.GetListStyleName();
 971     }
 972
 973     return styleName;
 974 }
 975
 976 /// Auto-select from style under caret in idle time
 977 void wxRichTextStyleListBox::OnIdle(wxIdleEvent& event)
 978 {
 979     if (CanAutoSetSelection() && GetRichTextCtrl() && IsShownOnScreen() && wxWindow::FindFocus() != this)
 980     {
 981         wxString styleName = GetStyleToShowInIdleTime(GetRichTextCtrl(), GetStyleType());
 982
 983         int sel = GetSelection();
 984         if (!styleName.IsEmpty())
 985         {
 986             // Don't do the selection if it's already set
 987             if (sel == GetIndexForStyle(styleName))
 988                 return;
 989
 990             SetStyleSelection(styleName);
 991         }
 992         else if (sel != -1)
 993             SetSelection(-1);
 994     }
 995     event.Skip();
 996 }
 997
 998 /// Do selection
 999 void wxRichTextStyleListBox::ApplyStyle(int item)
1000 {
1001     if ( item != wxNOT_FOUND )
1002     {
1003         wxRichTextStyleDefinition* def = GetStyle(item);
1004         if (def && GetRichTextCtrl())
1005         {
1006             GetRichTextCtrl()->ApplyStyle(def);
1007             GetRichTextCtrl()->SetFocus();
1008         }
1009     }
1010 }
1011
1012 /*!
1013  * wxRichTextStyleListCtrl class: manages a listbox and a choice control to
1014  * switch shown style types
1015  */
1016
1017 IMPLEMENT_CLASS(wxRichTextStyleListCtrl, wxControl)
1018
1019 BEGIN_EVENT_TABLE(wxRichTextStyleListCtrl, wxControl)
1020     EVT_CHOICE(wxID_ANY, wxRichTextStyleListCtrl::OnChooseType)
1021     EVT_SIZE(wxRichTextStyleListCtrl::OnSize)
1022 END_EVENT_TABLE()
1023
1024 wxRichTextStyleListCtrl::wxRichTextStyleListCtrl(wxWindow* parent, wxWindowID id, const wxPoint& pos,
1025     const wxSize& size, long style)
1026 {
1027     Init();
1028     Create(parent, id, pos, size, style);
1029 }
1030
1031 bool wxRichTextStyleListCtrl::Create(wxWindow* parent, wxWindowID id, const wxPoint& pos,
1032         const wxSize& size, long style)
1033 {
1034     if ((style & wxBORDER_MASK) == wxBORDER_DEFAULT)
1035         style |= wxBORDER_THEME;
1036
1037     wxControl::Create(parent, id, pos, size, style);
1038
1039     SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));
1040     if (size != wxDefaultSize)
1041         SetInitialSize(size);
1042
1043     bool showSelector = ((style & wxRICHTEXTSTYLELIST_HIDE_TYPE_SELECTOR) == 0);
1044
1045     wxBorder listBoxStyle;
1046     if (showSelector)
1047         listBoxStyle = wxBORDER_THEME;
1048     else
1049         listBoxStyle = wxBORDER_NONE;
1050
1051     m_styleListBox = new wxRichTextStyleListBox(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, listBoxStyle);
1052
1053     wxBoxSizer* boxSizer = new wxBoxSizer(wxVERTICAL);
1054
1055     if (showSelector)
1056     {
1057         wxArrayString choices;
1058         choices.Add(_("All styles"));
1059         choices.Add(_("Paragraph styles"));
1060         choices.Add(_("Character styles"));
1061         choices.Add(_("List styles"));
1062         choices.Add(_("Box styles"));
1063
1064         m_styleChoice = new wxChoice(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, choices);
1065
1066         boxSizer->Add(m_styleListBox, 1, wxALL|wxEXPAND, 5);
1067         boxSizer->Add(m_styleChoice, 0, wxLEFT|wxRIGHT|wxBOTTOM|wxEXPAND, 5);
1068     }
1069     else
1070     {
1071         boxSizer->Add(m_styleListBox, 1, wxALL|wxEXPAND, 0);
1072     }
1073
1074     SetSizer(boxSizer);
1075     Layout();
1076
1077     m_dontUpdate = true;
1078
1079     if (m_styleChoice)
1080     {
1081         int i = StyleTypeToIndex(m_styleListBox->GetStyleType());
1082         m_styleChoice->SetSelection(i);
1083     }
1084
1085     m_dontUpdate = false;
1086
1087     return true;
1088 }
1089
1090 wxRichTextStyleListCtrl::~wxRichTextStyleListCtrl()
1091 {
1092
1093 }
1094
1095 /// React to style type choice
1096 void wxRichTextStyleListCtrl::OnChooseType(wxCommandEvent& event)
1097 {
1098     if (event.GetEventObject() != m_styleChoice)
1099         event.Skip();
1100     else
1101     {
1102         if (m_dontUpdate)
1103             return;
1104
1105         wxRichTextStyleListBox::wxRichTextStyleType styleType = StyleIndexToType(event.GetSelection());
1106         m_styleListBox->SetSelection(-1);
1107         m_styleListBox->SetStyleType(styleType);
1108     }
1109 }
1110
1111 /// Lay out the controls
1112 void wxRichTextStyleListCtrl::OnSize(wxSizeEvent& WXUNUSED(event))
1113 {
1114     if (GetAutoLayout())
1115         Layout();
1116 }
1117
1118 /// Get the choice index for style type
1119 int wxRichTextStyleListCtrl::StyleTypeToIndex(wxRichTextStyleListBox::wxRichTextStyleType styleType)
1120 {
1121     if (styleType == wxRichTextStyleListBox::wxRICHTEXT_STYLE_ALL)
1122     {
1123         return 0;
1124     }
1125     else if (styleType == wxRichTextStyleListBox::wxRICHTEXT_STYLE_PARAGRAPH)
1126     {
1127         return 1;
1128     }
1129     else if (styleType == wxRichTextStyleListBox::wxRICHTEXT_STYLE_CHARACTER)
1130     {
1131         return 2;
1132     }
1133     else if (styleType == wxRichTextStyleListBox::wxRICHTEXT_STYLE_LIST)
1134     {
1135         return 3;
1136     }
1137     else if (styleType == wxRichTextStyleListBox::wxRICHTEXT_STYLE_BOX)
1138     {
1139         return 4;
1140     }
1141     return 0;
1142 }
1143
1144 /// Get the style type for choice index
1145 wxRichTextStyleListBox::wxRichTextStyleType wxRichTextStyleListCtrl::StyleIndexToType(int i)
1146 {
1147     if (i == 1)
1148         return wxRichTextStyleListBox::wxRICHTEXT_STYLE_PARAGRAPH;
1149     else if (i == 2)
1150         return wxRichTextStyleListBox::wxRICHTEXT_STYLE_CHARACTER;
1151     else if (i == 3)
1152         return wxRichTextStyleListBox::wxRICHTEXT_STYLE_LIST;
1153     else if (i == 4)
1154         return wxRichTextStyleListBox::wxRICHTEXT_STYLE_BOX;
1155
1156     return wxRichTextStyleListBox::wxRICHTEXT_STYLE_ALL;
1157 }
1158
1159 /// Associates the control with a style manager
1160 void wxRichTextStyleListCtrl::SetStyleSheet(wxRichTextStyleSheet* styleSheet)
1161 {
1162     if (m_styleListBox)
1163         m_styleListBox->SetStyleSheet(styleSheet);
1164 }
1165
1166 wxRichTextStyleSheet* wxRichTextStyleListCtrl::GetStyleSheet() const
1167 {
1168     if (m_styleListBox)
1169         return m_styleListBox->GetStyleSheet();
1170     else
1171         return NULL;
1172 }
1173
1174 /// Associates the control with a wxRichTextCtrl
1175 void wxRichTextStyleListCtrl::SetRichTextCtrl(wxRichTextCtrl* ctrl)
1176 {
1177     if (m_styleListBox)
1178         m_styleListBox->SetRichTextCtrl(ctrl);
1179 }
1180
1181 wxRichTextCtrl* wxRichTextStyleListCtrl::GetRichTextCtrl() const
1182 {
1183     if (m_styleListBox)
1184         return m_styleListBox->GetRichTextCtrl();
1185     else
1186         return NULL;
1187 }
1188
1189 /// Set/get the style type to display
1190 void wxRichTextStyleListCtrl::SetStyleType(wxRichTextStyleListBox::wxRichTextStyleType styleType)
1191 {
1192     if ( !m_styleListBox )
1193         return;
1194
1195     m_styleListBox->SetStyleType(styleType);
1196
1197     m_dontUpdate = true;
1198
1199     if (m_styleChoice)
1200     {
1201         int i = StyleTypeToIndex(m_styleListBox->GetStyleType());
1202         m_styleChoice->SetSelection(i);
1203     }
1204
1205     m_dontUpdate = false;
1206 }
1207
1208 wxRichTextStyleListBox::wxRichTextStyleType wxRichTextStyleListCtrl::GetStyleType() const
1209 {
1210     if (m_styleListBox)
1211         return m_styleListBox->GetStyleType();
1212     else
1213         return wxRichTextStyleListBox::wxRICHTEXT_STYLE_ALL;
1214 }
1215
1216 /// Updates the style list box
1217 void wxRichTextStyleListCtrl::UpdateStyles()
1218 {
1219     if (m_styleListBox)
1220         m_styleListBox->UpdateStyles();
1221 }
1222
1223 #if wxUSE_COMBOCTRL
1224
1225 /*!
1226  * Style drop-down for a wxComboCtrl
1227  */
1228
1229
1230 BEGIN_EVENT_TABLE(wxRichTextStyleComboPopup, wxRichTextStyleListBox)
1231     EVT_MOTION(wxRichTextStyleComboPopup::OnMouseMove)
1232     EVT_LEFT_DOWN(wxRichTextStyleComboPopup::OnMouseClick)
1233 END_EVENT_TABLE()
1234
1235 bool wxRichTextStyleComboPopup::Create( wxWindow* parent )
1236 {
1237     int borderStyle = GetDefaultBorder();
1238     if (borderStyle == wxBORDER_SUNKEN || borderStyle == wxBORDER_NONE)
1239         borderStyle = wxBORDER_THEME;
1240
1241     return wxRichTextStyleListBox::Create(parent, wxID_ANY,
1242                                   wxPoint(0,0), wxDefaultSize,
1243                                   borderStyle);
1244 }
1245
1246 void wxRichTextStyleComboPopup::SetStringValue( const wxString& s )
1247 {
1248     m_value = SetStyleSelection(s);
1249 }
1250
1251 wxString wxRichTextStyleComboPopup::GetStringValue() const
1252 {
1253     int sel = m_value;
1254     if (sel > -1)
1255     {
1256         wxRichTextStyleDefinition* def = GetStyle(sel);
1257         if (def)
1258             return def->GetName();
1259     }
1260     return wxEmptyString;
1261 }
1262
1263 //
1264 // Popup event handlers
1265 //
1266
1267 // Mouse hot-tracking
1268 void wxRichTextStyleComboPopup::OnMouseMove(wxMouseEvent& event)
1269 {
1270     // Move selection to cursor if it is inside the popup
1271
1272     int itemHere = wxRichTextStyleListBox::VirtualHitTest(event.GetPosition().y);
1273     if ( itemHere >= 0 )
1274     {
1275         wxRichTextStyleListBox::SetSelection(itemHere);
1276         m_itemHere = itemHere;
1277     }
1278     event.Skip();
1279 }
1280
1281 // On mouse left, set the value and close the popup
1282 void wxRichTextStyleComboPopup::OnMouseClick(wxMouseEvent& WXUNUSED(event))
1283 {
1284     if (m_itemHere >= 0)
1285         m_value = m_itemHere;
1286
1287     // Ordering is important, so we don't dismiss this popup accidentally
1288     // by setting the focus elsewhere e.g. in ApplyStyle
1289     Dismiss();
1290
1291     if (m_itemHere >= 0)
1292         wxRichTextStyleListBox::ApplyStyle(m_itemHere);
1293 }
1294
1295 /*!
1296  * wxRichTextStyleComboCtrl
1297  * A combo for applying styles.
1298  */
1299
1300 IMPLEMENT_CLASS(wxRichTextStyleComboCtrl, wxComboCtrl)
1301
1302 BEGIN_EVENT_TABLE(wxRichTextStyleComboCtrl, wxComboCtrl)
1303     EVT_IDLE(wxRichTextStyleComboCtrl::OnIdle)
1304 END_EVENT_TABLE()
1305
1306 bool wxRichTextStyleComboCtrl::Create(wxWindow* parent, wxWindowID id, const wxPoint& pos,
1307         const wxSize& size, long style)
1308 {
1309     if (!wxComboCtrl::Create(parent, id, wxEmptyString, pos, size, style))
1310         return false;
1311
1312     SetPopupMaxHeight(400);
1313
1314     m_stylePopup = new wxRichTextStyleComboPopup;
1315
1316     SetPopupControl(m_stylePopup);
1317
1318     return true;
1319 }
1320
1321 /// Auto-select from style under caret in idle time
1322
1323 // TODO: must be able to show italic, bold, combinations
1324 // in style box. Do we have a concept of automatic, temporary
1325 // styles that are added whenever we wish to show a style
1326 // that doesn't exist already? E.g. "Bold, Italic, Underline".
1327 // Word seems to generate these things on the fly.
1328 // If there's a named style already, it uses e.g. Heading1 + Bold, Italic
1329 // If you unembolden text in a style that has bold, it uses the
1330 // term "Not bold".
1331 // TODO: order styles alphabetically. This means indexes can change,
1332 // so need a different way to specify selections, i.e. by name.
1333
1334 void wxRichTextStyleComboCtrl::OnIdle(wxIdleEvent& event)
1335 {
1336     event.Skip();
1337
1338     if ( !m_stylePopup )
1339         return;
1340
1341     wxRichTextCtrl * const richtext = GetRichTextCtrl();
1342     if ( !richtext )
1343         return;
1344
1345     if ( !IsPopupShown() && IsShownOnScreen() && wxWindow::FindFocus() != this )
1346     {
1347         wxString styleName =
1348             wxRichTextStyleListBox::GetStyleToShowInIdleTime(richtext, m_stylePopup->GetStyleType());
1349
1350         wxString currentValue = GetValue();
1351         if (!styleName.IsEmpty())
1352         {
1353             // Don't do the selection if it's already set
1354             if (currentValue == styleName)
1355                 return;
1356
1357             SetValue(styleName);
1358         }
1359         else if (!currentValue.IsEmpty())
1360             SetValue(wxEmptyString);
1361     }
1362 }
1363
1364 #endif
1365     // wxUSE_COMBOCTRL
1366
1367 #endif
1368     // wxUSE_HTML
1369
1370 #endif
1371     // wxUSE_RICHTEXT