src/apps/webpositive/support/FontSelectionView.cpp

   1 /*
   2  * Copyright 2001-2010, Haiku.
   3  * Distributed under the terms of the MIT License.
   4  *
   5  * Authors:
   6  *              Mark Hogben
   7  *              DarkWyrm <bpmagic@columbus.rr.com>
   8  *              Axel Dörfler, axeld@pinc-software.de
   9  *              Philippe Saint-Pierre, stpere@gmail.com
  10  *              Stephan Aßmus <superstippi@gmx.de>
  11  */
  12
  13 #include "FontSelectionView.h"
  14
  15 #include <Box.h>
  16 #include <Catalog.h>
  17 #include <Locale.h>
  18 #include <Looper.h>
  19 #include <MenuField.h>
  20 #include <MenuItem.h>
  21 #include <PopUpMenu.h>
  22 #include <String.h>
  23 #include <StringView.h>
  24 #include <LayoutItem.h>
  25 #include <GroupLayoutBuilder.h>
  26
  27 #include <stdio.h>
  28
  29 #undef B_TRANSLATION_CONTEXT
  30 #define B_TRANSLATION_CONTEXT "Font Selection view"
  31
  32
  33 static const float kMinSize = 8.0;
  34 static const float kMaxSize = 18.0;
  35
  36 static const int32 kMsgSetFamily = 'fmly';
  37 static const int32 kMsgSetStyle = 'styl';
  38 static const int32 kMsgSetSize = 'size';
  39
  40
  41 //      #pragma mark -
  42
  43
  44 FontSelectionView::FontSelectionView(const char* name, const char* label,
  45                 bool separateStyles, const BFont* currentFont)
  46         :
  47         BHandler(name),
  48         fMessage(NULL),
  49         fTarget(NULL)
  50 {
  51         if (currentFont == NULL)
  52                 fCurrentFont = _DefaultFont();
  53         else
  54                 fCurrentFont = *currentFont;
  55
  56         fSavedFont = fCurrentFont;
  57
  58         fSizesMenu = new BPopUpMenu("size menu");
  59         fFontsMenu = new BPopUpMenu("font menu");
  60
  61         // font menu
  62         fFontsMenuField = new BMenuField("fonts", label, fFontsMenu, B_WILL_DRAW);
  63         fFontsMenuField->SetFont(be_bold_font);
  64
  65         // styles menu, if desired
  66         if (separateStyles) {
  67                 fStylesMenu = new BPopUpMenu("styles menu");
  68                 fStylesMenuField = new BMenuField("styles", B_TRANSLATE("Style:"),
  69                         fStylesMenu, B_WILL_DRAW);
  70         } else {
  71                 fStylesMenu = NULL;
  72                 fStylesMenuField = NULL;
  73         }
  74
  75         // size menu
  76         fSizesMenuField = new BMenuField("size", B_TRANSLATE("Size:"), fSizesMenu,
  77                 B_WILL_DRAW);
  78         fSizesMenuField->SetAlignment(B_ALIGN_RIGHT);
  79
  80         // preview
  81         fPreviewText = new BStringView("preview text",
  82                 B_TRANSLATE_COMMENT("The quick brown fox jumps over the lazy dog.",
  83                 "Don't translate this literally ! Use a phrase showing all "
  84                 "chars from A to Z."));
  85
  86         fPreviewText->SetExplicitMaxSize(BSize(B_SIZE_UNLIMITED,
  87                 B_SIZE_UNLIMITED));
  88         fPreviewText->SetHighUIColor(B_PANEL_BACKGROUND_COLOR, 1.65);
  89         fPreviewText->SetAlignment(B_ALIGN_RIGHT);
  90         _UpdateFontPreview();
  91 }
  92
  93
  94 FontSelectionView::~FontSelectionView()
  95 {
  96         // Some controls may not have been attached...
  97         if (!fPreviewText->Window())
  98                 delete fPreviewText;
  99         if (!fSizesMenuField->Window())
 100                 delete fSizesMenuField;
 101         if (fStylesMenuField && !fStylesMenuField->Window())
 102                 delete fStylesMenuField;
 103         if (!fFontsMenuField->Window())
 104                 delete fFontsMenuField;
 105
 106         delete fMessage;
 107 }
 108
 109
 110 void
 111 FontSelectionView::AttachedToLooper()
 112 {
 113         _BuildSizesMenu();
 114         UpdateFontsMenu();
 115 }
 116
 117
 118 void
 119 FontSelectionView::MessageReceived(BMessage* message)
 120 {
 121         switch (message->what) {
 122                 case kMsgSetSize:
 123                 {
 124                         int32 size;
 125                         if (message->FindInt32("size", &size) != B_OK
 126                                 || size == fCurrentFont.Size())
 127                                 break;
 128
 129                         fCurrentFont.SetSize(size);
 130                         _UpdateFontPreview();
 131                         _Invoke();
 132                         break;
 133                 }
 134
 135                 case kMsgSetFamily:
 136                 {
 137                         const char* family;
 138                         if (message->FindString("family", &family) != B_OK)
 139                                 break;
 140
 141                         font_style style;
 142                         fCurrentFont.GetFamilyAndStyle(NULL, &style);
 143
 144                         BMenuItem* familyItem = fFontsMenu->FindItem(family);
 145                         if (familyItem != NULL) {
 146                                 _SelectCurrentFont(false);
 147
 148                                 BMenuItem* styleItem;
 149                                 if (fStylesMenuField != NULL)
 150                                         styleItem = fStylesMenuField->Menu()->FindMarked();
 151                                 else {
 152                                         styleItem = familyItem->Submenu()->FindItem(style);
 153                                         if (styleItem == NULL)
 154                                                 styleItem = familyItem->Submenu()->ItemAt(0);
 155                                 }
 156
 157                                 if (styleItem != NULL) {
 158                                         styleItem->SetMarked(true);
 159                                         fCurrentFont.SetFamilyAndStyle(family, styleItem->Label());
 160                                         _UpdateFontPreview();
 161                                 }
 162                                 if (fStylesMenuField != NULL)
 163                                         _AddStylesToMenu(fCurrentFont, fStylesMenuField->Menu());
 164                         }
 165
 166                         _Invoke();
 167                         break;
 168                 }
 169
 170                 case kMsgSetStyle:
 171                 {
 172                         const char* family;
 173                         const char* style;
 174                         if (message->FindString("family", &family) != B_OK
 175                                 || message->FindString("style", &style) != B_OK)
 176                                 break;
 177
 178                         BMenuItem *familyItem = fFontsMenu->FindItem(family);
 179                         if (!familyItem)
 180                                 break;
 181
 182                         _SelectCurrentFont(false);
 183                         familyItem->SetMarked(true);
 184
 185                         fCurrentFont.SetFamilyAndStyle(family, style);
 186                         _UpdateFontPreview();
 187                         _Invoke();
 188                         break;
 189                 }
 190
 191                 default:
 192                         BHandler::MessageReceived(message);
 193         }
 194 }
 195
 196
 197 void
 198 FontSelectionView::SetMessage(BMessage* message)
 199 {
 200         delete fMessage;
 201         fMessage = message;
 202 }
 203
 204
 205 void
 206 FontSelectionView::SetTarget(BHandler* target)
 207 {
 208         fTarget = target;
 209 }
 210
 211
 212 // #pragma mark -
 213
 214
 215 void
 216 FontSelectionView::SetFont(const BFont& font, float size)
 217 {
 218         BFont resizedFont(font);
 219         resizedFont.SetSize(size);
 220         SetFont(resizedFont);
 221 }
 222
 223
 224 void
 225 FontSelectionView::SetFont(const BFont& font)
 226 {
 227         if (font == fCurrentFont && font == fSavedFont)
 228                 return;
 229
 230         _SelectCurrentFont(false);
 231         fSavedFont = fCurrentFont = font;
 232         _UpdateFontPreview();
 233
 234         _SelectCurrentFont(true);
 235         _SelectCurrentSize(true);
 236 }
 237
 238
 239 void
 240 FontSelectionView::SetSize(float size)
 241 {
 242         SetFont(fCurrentFont, size);
 243 }
 244
 245
 246 const BFont&
 247 FontSelectionView::Font() const
 248 {
 249         return fCurrentFont;
 250 }
 251
 252
 253 void
 254 FontSelectionView::SetDefaults()
 255 {
 256         BFont defaultFont = _DefaultFont();
 257         if (defaultFont == fCurrentFont)
 258                 return;
 259
 260         _SelectCurrentFont(false);
 261
 262         fCurrentFont = defaultFont;
 263         _UpdateFontPreview();
 264
 265         _SelectCurrentFont(true);
 266         _SelectCurrentSize(true);
 267 }
 268
 269
 270 void
 271 FontSelectionView::Revert()
 272 {
 273         if (!IsRevertable())
 274                 return;
 275
 276         _SelectCurrentFont(false);
 277
 278         fCurrentFont = fSavedFont;
 279         _UpdateFontPreview();
 280
 281         _SelectCurrentFont(true);
 282         _SelectCurrentSize(true);
 283 }
 284
 285
 286 bool
 287 FontSelectionView::IsDefaultable()
 288 {
 289         return fCurrentFont != _DefaultFont();
 290 }
 291
 292
 293 bool
 294 FontSelectionView::IsRevertable()
 295 {
 296         return fCurrentFont != fSavedFont;
 297 }
 298
 299
 300 void
 301 FontSelectionView::UpdateFontsMenu()
 302 {
 303         int32 numFamilies = count_font_families();
 304
 305         fFontsMenu->RemoveItems(0, fFontsMenu->CountItems(), true);
 306
 307         BFont font = fCurrentFont;
 308
 309         font_family currentFamily;
 310         font_style currentStyle;
 311         font.GetFamilyAndStyle(&currentFamily, &currentStyle);
 312
 313         for (int32 i = 0; i < numFamilies; i++) {
 314                 font_family family;
 315                 uint32 flags;
 316                 if (get_font_family(i, &family, &flags) != B_OK)
 317                         continue;
 318
 319                 // if we're setting the fixed font, we only want to show fixed fonts
 320                 if (!strcmp(Name(), "fixed") && (flags & B_IS_FIXED) == 0)
 321                         continue;
 322
 323                 font.SetFamilyAndFace(family, B_REGULAR_FACE);
 324
 325                 BMessage* message = new BMessage(kMsgSetFamily);
 326                 message->AddString("family", family);
 327                 message->AddString("name", Name());
 328
 329                 BMenuItem* familyItem;
 330                 if (fStylesMenuField != NULL) {
 331                         familyItem = new BMenuItem(family, message);
 332                 } else {
 333                         // Each family item has a submenu with all styles for that font.
 334                         BMenu* stylesMenu = new BMenu(family);
 335                         _AddStylesToMenu(font, stylesMenu);
 336                         familyItem = new BMenuItem(stylesMenu, message);
 337                 }
 338
 339                 familyItem->SetMarked(strcmp(family, currentFamily) == 0);
 340                 fFontsMenu->AddItem(familyItem);
 341                 familyItem->SetTarget(this);
 342         }
 343
 344         // Separate styles menu for only the current font.
 345         if (fStylesMenuField != NULL)
 346                 _AddStylesToMenu(fCurrentFont, fStylesMenuField->Menu());
 347 }
 348
 349
 350 // #pragma mark - private
 351
 352
 353 BLayoutItem*
 354 FontSelectionView::CreateSizesLabelLayoutItem()
 355 {
 356         return fSizesMenuField->CreateLabelLayoutItem();
 357 }
 358
 359
 360 BLayoutItem*
 361 FontSelectionView::CreateSizesMenuBarLayoutItem()
 362 {
 363         return fSizesMenuField->CreateMenuBarLayoutItem();
 364 }
 365
 366
 367 BLayoutItem*
 368 FontSelectionView::CreateFontsLabelLayoutItem()
 369 {
 370         return fFontsMenuField->CreateLabelLayoutItem();
 371 }
 372
 373
 374 BLayoutItem*
 375 FontSelectionView::CreateFontsMenuBarLayoutItem()
 376 {
 377         return fFontsMenuField->CreateMenuBarLayoutItem();
 378 }
 379
 380
 381 BLayoutItem*
 382 FontSelectionView::CreateStylesLabelLayoutItem()
 383 {
 384         if (fStylesMenuField)
 385                 return fStylesMenuField->CreateLabelLayoutItem();
 386         return NULL;
 387 }
 388
 389
 390 BLayoutItem*
 391 FontSelectionView::CreateStylesMenuBarLayoutItem()
 392 {
 393         if (fStylesMenuField)
 394                 return fStylesMenuField->CreateMenuBarLayoutItem();
 395         return NULL;
 396 }
 397
 398
 399 BView*
 400 FontSelectionView::PreviewBox() const
 401 {
 402         return fPreviewText;
 403 }
 404
 405
 406 // #pragma mark - private
 407
 408
 409 void
 410 FontSelectionView::_Invoke()
 411 {
 412         if (fTarget != NULL && fTarget->Looper() != NULL && fMessage != NULL) {
 413                 BMessage message(*fMessage);
 414                 fTarget->Looper()->PostMessage(&message, fTarget);
 415         }
 416 }
 417
 418
 419 BFont
 420 FontSelectionView::_DefaultFont() const
 421 {
 422         if (strcmp(Name(), "bold") == 0)
 423                 return *be_bold_font;
 424         if (strcmp(Name(), "fixed") == 0)
 425                 return *be_fixed_font;
 426         else
 427                 return *be_plain_font;
 428 }
 429
 430
 431 void
 432 FontSelectionView::_SelectCurrentFont(bool select)
 433 {
 434         font_family family;
 435         font_style style;
 436         fCurrentFont.GetFamilyAndStyle(&family, &style);
 437
 438         BMenuItem *item = fFontsMenu->FindItem(family);
 439         if (item != NULL) {
 440                 item->SetMarked(select);
 441
 442                 if (item->Submenu() != NULL) {
 443                         item = item->Submenu()->FindItem(style);
 444                         if (item != NULL)
 445                                 item->SetMarked(select);
 446                 }
 447         }
 448 }
 449
 450
 451 void
 452 FontSelectionView::_SelectCurrentSize(bool select)
 453 {
 454         char label[16];
 455         snprintf(label, sizeof(label), "%" B_PRId32, (int32)fCurrentFont.Size());
 456
 457         BMenuItem* item = fSizesMenu->FindItem(label);
 458         if (item != NULL)
 459                 item->SetMarked(select);
 460 }
 461
 462
 463 void
 464 FontSelectionView::_UpdateFontPreview()
 465 {
 466         fPreviewText->SetFont(&fCurrentFont);
 467 }
 468
 469
 470 void
 471 FontSelectionView::_BuildSizesMenu()
 472 {
 473         const int32 sizes[] = {7, 8, 9, 10, 11, 12, 13, 14, 18, 21, 24, 0};
 474
 475         // build size menu
 476         for (int32 i = 0; sizes[i]; i++) {
 477                 int32 size = sizes[i];
 478                 if (size < kMinSize || size > kMaxSize)
 479                         continue;
 480
 481                 char label[32];
 482                 snprintf(label, sizeof(label), "%" B_PRId32, size);
 483
 484                 BMessage* message = new BMessage(kMsgSetSize);
 485                 message->AddInt32("size", size);
 486                 message->AddString("name", Name());
 487
 488                 BMenuItem* item = new BMenuItem(label, message);
 489                 if (size == fCurrentFont.Size())
 490                         item->SetMarked(true);
 491
 492                 fSizesMenu->AddItem(item);
 493                 item->SetTarget(this);
 494         }
 495 }
 496
 497
 498 void
 499 FontSelectionView::_AddStylesToMenu(const BFont& font, BMenu* stylesMenu) const
 500 {
 501         stylesMenu->RemoveItems(0, stylesMenu->CountItems(), true);
 502         stylesMenu->SetRadioMode(true);
 503
 504         font_family family;
 505         font_style style;
 506         font.GetFamilyAndStyle(&family, &style);
 507         BString currentStyle(style);
 508
 509         int32 numStyles = count_font_styles(family);
 510
 511         for (int32 j = 0; j < numStyles; j++) {
 512                 if (get_font_style(family, j, &style) != B_OK)
 513                         continue;
 514
 515                 BMessage* message = new BMessage(kMsgSetStyle);
 516                 message->AddString("family", (char*)family);
 517                 message->AddString("style", (char*)style);
 518
 519                 BMenuItem* item = new BMenuItem(style, message);
 520                 item->SetMarked(currentStyle == style);
 521
 522                 stylesMenu->AddItem(item);
 523                 item->SetTarget(this);
 524         }
 525 }
 526