// ----------------------------------------------------------------------- RHTML_Preferences_Win - FTSetFont -
void RHTMLPreferencesWin::FTSetFont(const char *font,const char *style ="")
{
fFTFontsBox->RemoveChild(fFTDFStyle);
font_family fFamily;
font_style fStyle;
BMenu *fSMenu;
strcpy(fFamily,font);
int32 styleNum = count_font_styles(fFamily);
if (style!="")
{
fSMenu = new BMenu(fOptions->GetLocaleString("Preferences_Window_FileTypes",style));
} else
if (styleNum>0)
{
get_font_style(fFamily, 0, &fStyle);
fSMenu = new BMenu(fOptions->GetLocaleString("Preferences_Window_FileTypes",fStyle));
} else fSMenu = new BMenu("");
fSMenu->SetRadioMode(false);
fSMenu->SetLabelFromMarked(true);
for (int32 ii = 0; ii < styleNum; ii++)
{
get_font_style(fFamily, ii, &fStyle);
BMessage* msg = new BMessage('FTFS');
msg->AddString("font_style", fStyle);
fSMenu->AddItem(new BMenuItem(fOptions->GetLocaleString("Preferences_Window_FileTypes",fStyle),msg));
}
fFTDFStyle= new BMenuField(BRect(10,45,180,75),"Font Style",fOptions->GetLocaleString("Preferences_Window_FileTypes","Style"),fSMenu);
fFTDFStyle->SetDivider(60);
fFTFontsBox->AddChild(fFTDFStyle);
}
void
FontSelectionView::_AddStylesToMenu(const BFont& font, BMenu* stylesMenu) const
{
stylesMenu->RemoveItems(0, stylesMenu->CountItems(), true);
stylesMenu->SetRadioMode(true);
font_family family;
font_style style;
font.GetFamilyAndStyle(&family, &style);
BString currentStyle(style);
int32 numStyles = count_font_styles(family);
for (int32 j = 0; j < numStyles; j++) {
if (get_font_style(family, j, &style) != B_OK)
continue;
BMessage* message = new BMessage(kMsgSetStyle);
message->AddString("family", (char*)family);
message->AddString("style", (char*)style);
BMenuItem* item = new BMenuItem(style, message);
item->SetMarked(currentStyle == style);
stylesMenu->AddItem(item);
item->SetTarget(this);
}
}
virtual status_t Do(const BString16* familyName)
{
ArpASSERT(familyName);
BMenuItem* item = new BMenuItem(familyName, new BMessage(FONT_IMSG));
if (item) mMenu->AddItem(item);
#if 0
int32 numFamilies = count_font_families();
for (int32 i = 0; i < numFamilies; i++) {
font_family family;
uint32 flags;
if (get_font_family(i, &family, &flags) == B_OK) {
BMenuItem* item = new BMenuItem(family, new BMessage(FONT_IMSG));
if (item) m->AddItem(item);
#if 0
int32 numStyles = count_font_styles(family);
for (int32 j = 0; j < numStyles; j++) {
font_style style;
if (get_font_style(family, j, &style, &flags) == B_OK) {
printf("FONT: %s %s\n", family, style);
}
}
#endif
}
}
#endif
return B_OK;
}
BPopUpMenu *TPrefsWindow::BuildFontMenu(BFont *font)
{
char label[512];
int32 family_count;
int32 family_loop;
int32 style_count;
int32 style_loop;
BMenuItem *item;
BMessage *msg;
BPopUpMenu *menu;
font_family def_family;
font_family f_family;
font_style def_style;
font_style f_style;
menu = new BPopUpMenu("");
font->GetFamilyAndStyle(&def_family, &def_style);
family_count = count_font_families();
for (family_loop = 0; family_loop < family_count; family_loop++) {
get_font_family(family_loop, &f_family);
style_count = count_font_styles(f_family);
for (style_loop = 0; style_loop < style_count; style_loop++) {
get_font_style(f_family, style_loop, &f_style);
msg = new BMessage(P_FONT);
msg->AddString("font", f_family);
msg->AddString("style", f_style);
sprintf(label, "%s %s", f_family, f_style);
menu->AddItem(item = new BMenuItem(label, msg));
if ((!strcmp(def_family, f_family)) && (!strcmp(def_style, f_style)))
item->SetMarked(true);
item->SetTarget(this);
}
}
return menu;
}
void
PrefHandler::_ConfirmFont(const BFont *fallbackFont)
{
font_family family;
font_style style;
const char *prefFamily = getString(PREF_HALF_FONT_FAMILY);
int32 familiesCount = (prefFamily != NULL) ? count_font_families() : 0;
for (int32 i = 0; i < familiesCount; i++) {
if (get_font_family(i, &family) != B_OK
|| strcmp(family, prefFamily) != 0)
continue;
const char *prefStyle = getString(PREF_HALF_FONT_STYLE);
int32 stylesCount = (prefStyle != NULL) ? count_font_styles(family) : 0;
for (int32 j = 0; j < stylesCount; j++) {
// check style if we can safely use this font
if (get_font_style(family, j, &style) == B_OK
&& strcmp(style, prefStyle) == 0)
return;
}
}
// use fall-back font
fallbackFont->GetFamilyAndStyle(&family, &style);
setString(PREF_HALF_FONT_FAMILY, family);
setString(PREF_HALF_FONT_STYLE, style);
}
void init_font() {
if(gfontstruct)
return;
int i, last, max_family=count_font_families();
int cap = max_family * 4;
gfontlist = (char**) malloc(cap * sizeof(char*));
gfontstruct = (XFontStruct*) calloc(cap, sizeof(XFontStruct));
for(i=0,last=0;i!=max_family;++i) {
font_family family;
get_font_family(i, &family);
int j, max_style = count_font_styles(family);
for(j=0;j!=max_style;++j) {
uint32 flag;
font_style style;
get_font_style(family, j, &style, &flag);
if(last == cap) {
cap += 100;
realloc(gfontlist, cap * sizeof(char*));
realloc(gfontstruct, cap * sizeof(XFontStruct));
}
gfontstruct[last].fid = i * 256 + j;
gfontlist[last] = create_xlfd(&family, &style, flag);
++last;
}
}
gfontlist[last] = 0;
}
/*******************************************************************************
* GdipGetFontHeightGivenDPI [GDIPLUS.@]
* PARAMS
* font [I] Font to retrieve DPI from
* dpi [I] DPI to assume
* height [O] Return value
*
* RETURNS
* SUCCESS: Ok
* FAILURE: InvalidParameter if font or height is NULL
*
* NOTES
* According to MSDN, the result is (lineSpacing)*(fontSize / emHeight)*dpi
* (for anything other than unit Pixel)
*/
GpStatus WINGDIPAPI GdipGetFontHeightGivenDPI(GDIPCONST GpFont *font, REAL dpi, REAL *height)
{
GpStatus stat;
INT style;
UINT16 line_spacing, em_height;
REAL font_size;
if (!font || !height) return InvalidParameter;
TRACE("%p (%s), %f, %p\n", font,
debugstr_w(font->family->FamilyName), dpi, height);
font_size = units_to_pixels(get_font_size(font), font->unit, dpi);
style = get_font_style(font);
stat = GdipGetLineSpacing(font->family, style, &line_spacing);
if (stat != Ok) return stat;
stat = GdipGetEmHeight(font->family, style, &em_height);
if (stat != Ok) return stat;
*height = (REAL)line_spacing * font_size / (REAL)em_height;
TRACE("%s,%d => %f\n",
debugstr_w(font->family->FamilyName), font->otm.otmTextMetrics.tmHeight, *height);
return Ok;
}
void
ControlView::_UpdateFontmenus(bool setInitialfont)
{
BFont font;
BMenu* stylemenu = NULL;
font_family fontFamilyName, currentFamily;
font_style fontStyleName, currentStyle;
GetFont(&font);
font.GetFamilyAndStyle(¤tFamily, ¤tStyle);
const int32 fontfamilies = count_font_families();
fFontFamilyMenu->RemoveItems(0, fFontFamilyMenu->CountItems(), true);
for (int32 i = 0; i < fontfamilies; i++) {
if (get_font_family(i, &fontFamilyName) == B_OK) {
stylemenu = new BMenu(fontFamilyName);
const int32 styles = count_font_styles(fontFamilyName);
BMessage* familyMsg = new BMessage(FONTFAMILY_CHANGED_MSG);
familyMsg->AddString("_family", fontFamilyName);
BMenuItem* familyItem = new BMenuItem(stylemenu, familyMsg);
fFontFamilyMenu->AddItem(familyItem);
for (int32 j = 0; j < styles; j++) {
if (get_font_style(fontFamilyName, j, &fontStyleName) == B_OK) {
BMessage* fontMsg = new BMessage(FONTSTYLE_CHANGED_MSG);
fontMsg->AddString("_family", fontFamilyName);
fontMsg->AddString("_style", fontStyleName);
BMenuItem* styleItem = new BMenuItem(fontStyleName, fontMsg);
styleItem->SetMarked(false);
// setInitialfont is used when we attach the FontField
if (!strcmp(fontStyleName, currentStyle)
&& !strcmp(fontFamilyName, currentFamily)
&& setInitialfont) {
styleItem->SetMarked(true);
familyItem->SetMarked(true);
BString string;
string << currentFamily << " " << currentStyle;
if (fFontMenuField)
fFontMenuField->MenuItem()->SetLabel(string.String());
}
stylemenu->AddItem(styleItem);
}
}
}
stylemenu->SetRadioMode(true);
stylemenu->SetTargetForItems(this);
}
fFontFamilyMenu->SetLabelFromMarked(true);
fFontFamilyMenu->SetTargetForItems(this);
}
/*******************************************************************************
* GdipGetFontStyle [GDIPLUS.@]
*
* Gets the font's style, returned in bitwise OR of FontStyle enumeration
*
* PARAMS
* font [I] font to request from
* style [O] resulting pointer to a FontStyle enumeration
*
* RETURNS
* SUCCESS: Ok
* FAILURE: InvalidParameter
*/
GpStatus WINGDIPAPI GdipGetFontStyle(GpFont *font, INT *style)
{
TRACE("%p %p\n", font, style);
if (!(font && style))
return InvalidParameter;
*style = get_font_style(font);
TRACE("%s,%d => %d\n", debugstr_w(font->family->FamilyName), font->otm.otmTextMetrics.tmHeight, *style);
return Ok;
}
// --------------------------------------------------------------------- RHTML_Preferences_Win - FTHSetFSize -
void RHTMLPreferencesWin::FTHSetFSize(uint FontColor)
{
fFTHFontBox->RemoveChild(fFTHStyle);
font_family fFamily;
font_style fStyle;
BMessage *msg;
// - Style
BMenu *fStyleMenu;
fOptions->DefaultFont->GetFamilyAndStyle(&fFamily,&fStyle);
int32 styleNum = count_font_styles(fFamily);
if (fOptions->FileTypes[fFTHFileTypes]->Font[FontColor]->Style.ICompare("Default style")==0)
{
fStyleMenu = new BMenu(fOptions->GetLocaleString("Preferences_Window_FileTypes","Default style"));
} else
fStyleMenu = new BMenu(fOptions->GetLocaleString("Preferences_Window_FileTypes",fOptions->FileTypes[fFTHFileTypes]->Font[FontColor]->Style.String()));
fStyleMenu->SetRadioMode(false);
fStyleMenu->SetLabelFromMarked(true);
msg = new BMessage(R_FTH_Style_MSG);
msg->AddString("font_style","Default style");
fStyleMenu->AddItem(new BMenuItem(fOptions->GetLocaleString("Preferences_Window_FileTypes","Default style"),msg));
for (int32 ii = 0; ii < styleNum; ii++)
{
get_font_style(fFamily, ii, &fStyle);
msg = new BMessage(R_FTH_Style_MSG);
msg->AddString("font_style", fStyle);
fStyleMenu->AddItem(new BMenuItem(fOptions->GetLocaleString("Preferences_Window_FileTypes",fStyle),msg));
}
fFTHStyle= new BMenuField(BRect(10,15,210,40),"Style",fOptions->GetLocaleString("Preferences_Window_FileTypes","Style"),fStyleMenu);
fFTHStyle->SetDivider(80);
fFTHFontBox->AddChild(fFTHStyle);
// - Color
rgb_color rgb;
rgb.alpha=fOptions->FileTypes[fFTHFileTypes]->Color[FontColor]->alpha;
rgb.red=fOptions->FileTypes[fFTHFileTypes]->Color[FontColor]->red;
rgb.green=fOptions->FileTypes[fFTHFileTypes]->Color[FontColor]->green;
rgb.blue=fOptions->FileTypes[fFTHFileTypes]->Color[FontColor]->blue;
fFTHCC->SetValue(rgb);
}
/*******************************************************************************
* GdipGetFontHeightGivenDPI [GDIPLUS.@]
* PARAMS
* font [I] Font to retrieve DPI from
* dpi [I] DPI to assume
* height [O] Return value
*
* RETURNS
* SUCCESS: Ok
* FAILURE: InvalidParameter if font or height is NULL
*
* NOTES
* According to MSDN, the result is (lineSpacing)*(fontSize / emHeight)*dpi
* (for anything other than unit Pixel)
*/
GpStatus WINGDIPAPI GdipGetFontHeightGivenDPI(GDIPCONST GpFont *font, REAL dpi, REAL *height)
{
GpStatus stat;
INT style;
UINT16 line_spacing, em_height;
REAL font_height, font_size;
if (!font || !height) return InvalidParameter;
TRACE("%p (%s), %f, %p\n", font,
debugstr_w(font->family->FamilyName), dpi, height);
font_size = get_font_size(font);
style = get_font_style(font);
stat = GdipGetLineSpacing(font->family, style, &line_spacing);
if (stat != Ok) return stat;
stat = GdipGetEmHeight(font->family, style, &em_height);
if (stat != Ok) return stat;
font_height = (REAL)line_spacing * font_size / (REAL)em_height;
switch (font->unit)
{
case UnitPixel:
case UnitWorld:
*height = font_height;
break;
case UnitPoint:
*height = font_height * dpi * inch_per_point;
break;
case UnitInch:
*height = font_height * dpi;
break;
case UnitDocument:
*height = font_height * (dpi / 300.0);
break;
case UnitMillimeter:
*height = font_height * (dpi / mm_per_inch);
break;
default:
FIXME("Unhandled unit type: %d\n", font->unit);
return NotImplemented;
}
TRACE("%s,%d(unit %d) => %f\n",
debugstr_w(font->family->FamilyName), font->otm.otmTextMetrics.tmHeight, font->unit, *height);
return Ok;
}
void
ControlView::_UpdateAndSendFamily(const BMessage* message)
{
_DeselectOldItems();
font_family family;
font_style style;
if (message->FindString("_family", (const char **)&family) == B_OK) {
char* name;
type_code typeFound = 0;
int32 countFound = 0;
if (message->GetInfo(B_ANY_TYPE, 0, &name, &typeFound,
&countFound) == B_OK) {
if (typeFound == B_STRING_TYPE) {
BString string;
if (message->FindString(name, 0, &string) == B_OK)
printf("Family: %s\n", string.String());
}
}
BMenuItem* markedItem = fFontFamilyMenu->FindItem(family);
if (!markedItem)
return;
markedItem->SetMarked(true);
get_font_style(family, 0, &style);
BString string;
string << family << " " << style;
if (fFontMenuField)
fFontMenuField->MenuItem()->SetLabel(string.String());
BMenu* submenu = markedItem->Submenu();
if (submenu) {
BMenuItem* styleItem = submenu->FindItem(style);
if (styleItem && !styleItem->IsMarked())
styleItem->SetMarked(true);
}
BMessage fontMsg(FONTFAMILY_CHANGED_MSG);
if (fontMsg.AddMessage("_fontMessage", message) == B_OK)
fMessenger->SendMessage(&fontMsg);
}
}
void
CharacterWindow::_UpdateFontMenu(BMenu* menu)
{
BMenuItem* item;
while (menu->CountItems() > 0) {
item = menu->RemoveItem(static_cast<int32>(0));
delete(item);
}
font_family currentFamily;
font_style currentStyle;
fCharacterView->CharacterFont().GetFamilyAndStyle(¤tFamily,
¤tStyle);
int32 numFamilies = count_font_families();
menu->SetRadioMode(true);
for (int32 i = 0; i < numFamilies; i++) {
font_family family;
if (get_font_family(i, &family) == B_OK) {
BMenu* subMenu = new BMenu(family);
menu->AddItem(new BMenuItem(subMenu,
new BMessage(kMsgFontSelected)));
int numStyles = count_font_styles(family);
for (int32 j = 0; j < numStyles; j++) {
font_style style;
uint32 flags;
if (get_font_style(family, j, &style, &flags) == B_OK) {
item = new BMenuItem(style, new BMessage(kMsgFontSelected));
subMenu->AddItem(item);
if (!strcmp(family, currentFamily)
&& !strcmp(style, currentStyle)) {
fSelectedFontItem = item;
item->SetMarked(true);
}
}
}
}
}
item = menu->FindItem(currentFamily);
item->SetMarked(true);
}
/*static*/ BMenu*
AppearancePrefView::_MakeFontMenu(uint32 command,
const char* defaultFamily, const char* defaultStyle)
{
BPopUpMenu* menu = new BPopUpMenu("");
int32 numFamilies = count_font_families();
uint32 flags;
for (int32 i = 0; i < numFamilies; i++) {
font_family family;
if (get_font_family(i, &family, &flags) == B_OK) {
BFont font;
font_style style;
int32 numStyles = count_font_styles(family);
for (int32 j = 0; j < numStyles; j++) {
if (get_font_style(family, j, &style) == B_OK) {
font.SetFamilyAndStyle(family, style);
if (IsFontUsable(font)) {
BMessage* message = new BMessage(command);
const char* size
= PrefHandler::Default()->getString(PREF_HALF_FONT_SIZE);
message->AddString("font_family", family);
message->AddString("font_style", style);
message->AddString("font_size", size);
char fontMenuLabel[134];
snprintf(fontMenuLabel, sizeof(fontMenuLabel),
"%s - %s", family, style);
BMenu* fontSizeMenu = _MakeFontSizeMenu(fontMenuLabel,
MSG_HALF_FONT_CHANGED, family, style, size);
BMenuItem* item = new BMenuItem(fontSizeMenu, message);
menu->AddItem(item);
if (strcmp(defaultFamily, family) == 0
&& strcmp(defaultStyle, style) == 0)
item->SetMarked(true);
}
}
}
}
}
if (menu->FindMarked() == NULL)
menu->ItemAt(0)->SetMarked(true);
return menu;
}
BMenu*
CharacterWindow::_CreateFontMenu()
{
BMenu* menu = new BMenu(B_TRANSLATE("Font"));
BMenuItem* item;
font_family currentFamily;
font_style currentStyle;
fCharacterView->CharacterFont().GetFamilyAndStyle(¤tFamily,
¤tStyle);
int32 numFamilies = count_font_families();
menu->SetRadioMode(true);
for (int32 i = 0; i < numFamilies; i++) {
font_family family;
if (get_font_family(i, &family) == B_OK) {
BMenu* subMenu = new BMenu(family);
menu->AddItem(new BMenuItem(subMenu,
new BMessage(kMsgFontSelected)));
int numStyles = count_font_styles(family);
for (int32 j = 0; j < numStyles; j++) {
font_style style;
uint32 flags;
if (get_font_style(family, j, &style, &flags) == B_OK) {
item = new BMenuItem(style, new BMessage(kMsgFontSelected));
subMenu->AddItem(item);
if (!strcmp(family, currentFamily)
&& !strcmp(style, currentStyle)) {
fSelectedFontItem = item;
item->SetMarked(true);
}
}
}
}
}
item = menu->FindItem(currentFamily);
item->SetMarked(true);
return menu;
}
static void testSetFontFamilyAndStyle(BView *view, BRect frame)
{
view->DrawString("This is a test", BPoint(2, 6));
BFont font;
view->GetFont(&font);
int32 families = count_font_families();
font_family familyName;
get_font_family(families - 1, &familyName);
int32 styles = count_font_styles(familyName);
font_style styleName;
get_font_style(familyName, styles - 1, &styleName);
font.SetFamilyAndStyle(familyName, styleName);
view->SetFont(&font);
view->DrawString( "This is a test", BPoint(2, 19));
}
int
AddFontMenu(char *str,BMenu* menu, uint32 what,const BHandler* handler)//, const BLooper* looper)
{
const int32 fontNum = count_font_families();
font_family fFamily;
font_style fStyle;
BMenu* styleMenu;
BMenuItem* styleItem;
int tot = 0,nb = -1;
char tmp[512];
for(int32 i = 0; i < fontNum; i++)
{
get_font_family(i,&fFamily);
int32 styleNum = count_font_styles(fFamily);
for(int32 ii = 0; ii < styleNum; ii++)
{
get_font_style(fFamily, ii, &fStyle);
BMessage* msg = new BMessage(what);
msg->AddString("f0", fFamily);
msg->AddString("f1", fStyle);
sprintf(&tmp[0],"%s, %s",fFamily,fStyle);
if (strcmp(str,&tmp[0]) == 0)
{
nb = tot;
}
tot++;
styleItem = new BMenuItem(&tmp[0],msg);
menu->AddItem(styleItem);
}
}
return nb;
}
bool Bookmark::Exists(const char* f, const char* s) const {
font_family family;
font_style style;
uint32 flags;
int32 nFamilies;
int32 nStyles;
nFamilies = count_font_families();
for (int32 i = 0; i < nFamilies; i ++) {
if (get_font_family(i, &family, &flags) == B_OK && strcmp(f, family) == 0) {
nStyles = count_font_styles(family);
for (int32 j = 0; j < nStyles; j++) {
if (get_font_style(family, j, &style, &flags) == B_OK && strcmp(s, style) == 0) {
return true;
}
}
}
}
return false;
}
BFont
CharacterStyle::_FindFontForFace(uint16 face) const
{
BFont font(Font());
font_family family;
font_style style;
font.GetFamilyAndStyle(&family, &style);
int32 styleCount = count_font_styles(family);
for (int32 i = 0; i < styleCount; i++) {
uint16 styleFace;
if (get_font_style(family, i, &style, &styleFace) == B_OK) {
if (styleFace == face) {
font.SetFamilyAndStyle(family, style);
return font;
}
}
}
return font;
}
CInfoDialog::CInfoDialog(BRect frame, const char *name, window_type type, int flags,
BWindow *owner, BPositionIO* data)
: HDialog(frame, name, type, flags, owner, data)
{
fDoc = dynamic_cast<PDoc*>(owner);
FailNil(fDoc);
SetText("name", owner->Title());
char s[32];
sprintf(s, "%d", fDoc->TextView()->Size());
SetText("docsize", s);
sprintf(s, "%d", fDoc->TextView()->LineCount());
SetText("lines", s);
BMenuField *mf = dynamic_cast<BMenuField*>(FindView("mime"));
FailNil(mf);
fTypes = mf->Menu();
const char *p;
int i = 0;
while ((p = gPrefs->GetIxPrefString(prf_X_Mimetype, i++)) != NULL)
fTypes->AddItem(new BMenuItem(p, new BMessage(msg_FieldChanged)));
if (i == 1)
fTypes->AddItem(new BMenuItem("text/plain", new BMessage(msg_FieldChanged)));
const char *mime = fDoc->MimeType();
if (mime && mime[0])
{
for (i = 0; i < fTypes->CountItems(); i++)
{
BMenuItem *item = fTypes->ItemAt(i);
if (strcmp(item->Label(), mime) == 0)
{
item->SetMarked(true);
break;
}
}
if (i == fTypes->CountItems())
{
fTypes->AddSeparatorItem();
fTypes->AddItem(new BMenuItem(mime, new BMessage(msg_FieldChanged)));
fTypes->ItemAt(fTypes->CountItems() - 1)->SetMarked(true);
}
}
else
{
BMenuItem *item;
fTypes->AddSeparatorItem();
fTypes->AddItem(item = new BMenuItem("<undefined>", new BMessage(msg_FieldChanged)));
item->SetMarked(true);
}
if (fDoc->EntryRef())
{
BNode node;
FailOSErr(node.SetTo(fDoc->EntryRef()));
time_t t;
node.GetModificationTime(&t);
char time[256];
strcpy(time, ctime(&t));
time[strlen(time) - 1] = 0;
SetText("time", time);
}
else
{
//SetEnabled("mime", false);
SetText("time", "Not Saved");
}
mf = dynamic_cast<BMenuField*>(FindView("font"));
FailNil(mf);
fMenu = mf->Menu();
FailNil(fMenu);
font_family ff;
font_style fs;
for (int i = 0; i < count_font_families(); i++)
{
get_font_family(i, &ff);
BMenu *fontItem = new BMenu(ff);
FailNil(fontItem);
fMenu->AddItem(new BMenuItem(fontItem, new BMessage(msg_FieldChanged)));
fontItem->SetFont(be_plain_font);
for (int j = 0; j < count_font_styles(ff); j++)
{
get_font_style(ff, j, &fs);
BMessage *msg = new BMessage(msg_FieldChanged);
msg->AddString("family", ff);
msg->AddString("style", fs);
fontItem->AddItem(new BMenuItem(fs, msg));
}
}
fMenu->SetRadioMode(true);
mf = dynamic_cast<BMenuField*>(FindView("encoding"));
FailNil(mf);
fEncoding = mf->Menu();
FailNil(fEncoding);
fEncoding->SetRadioMode(true);
mf = dynamic_cast<BMenuField*>(FindView("source encoding"));
FailNil(mf);
fSourceEncoding = mf->Menu();
FailNil(fSourceEncoding);
fSourceEncoding->SetRadioMode(true);
mf = dynamic_cast<BMenuField*>(FindView("linebreaks"));
FailNil(mf);
fLineBreaks = mf->Menu();
FailNil(fLineBreaks);
fLineBreaks->SetRadioMode(true);
BTextControl *tc = dynamic_cast<BTextControl*>(FindView("tabs"));
if (tc) tc->SetDivider(be_plain_font->StringWidth(tc->Label()) + 4);
BMenu *lang;
mf = dynamic_cast<BMenuField*>(FindView("language"));
FailNil(mf);
lang = mf->Menu();
CLanguageInterface *intf;
int cookie = 0;
while ((intf = CLanguageInterface::NextIntf(cookie)) != NULL)
lang->AddItem(new BMenuItem(intf->Name(), new BMessage(msg_FieldChanged)));
lang->SetRadioMode(true);
int curLang = fDoc->TextView()->Language();
SetValue("language", curLang >= 0 ? curLang + 3 : 1);
CancelClicked();
} /* CInfoDialog::CInfoDialog */
void
FontSelectionView::UpdateFontsMenu()
{
int32 numFamilies = count_font_families();
fFontsMenu->RemoveItems(0, fFontsMenu->CountItems(), true);
BFont font;
fFontsMenu->GetFont(&font);
font_family currentFamily;
font_style currentStyle;
fCurrentFont.GetFamilyAndStyle(¤tFamily, ¤tStyle);
for (int32 i = 0; i < numFamilies; i++) {
font_family family;
uint32 flags;
if (get_font_family(i, &family, &flags) != B_OK)
continue;
// if we're setting the fixed font, we only want to show fixed and
// full-and-half-fixed fonts
if (strcmp(Name(), "fixed") == 0
&& (flags
& (B_IS_FIXED | B_PRIVATE_FONT_IS_FULL_AND_HALF_FIXED)) == 0) {
continue;
}
float width = font.StringWidth(family);
if (width > fMaxFontNameWidth)
fMaxFontNameWidth = width;
BMenu* stylesMenu = new BMenu(family);
stylesMenu->SetRadioMode(true);
stylesMenu->SetFont(&font);
BMessage* message = new BMessage(kMsgSetFamily);
message->AddString("family", family);
message->AddString("name", Name());
BMenuItem* familyItem = new BMenuItem(stylesMenu, message);
fFontsMenu->AddItem(familyItem);
int32 numStyles = count_font_styles(family);
for (int32 j = 0; j < numStyles; j++) {
font_style style;
if (get_font_style(family, j, &style, &flags) != B_OK)
continue;
message = new BMessage(kMsgSetStyle);
message->AddString("family", (char*)family);
message->AddString("style", (char*)style);
message->AddString("name", Name());
BMenuItem* item = new BMenuItem(style, message);
if (!strcmp(style, currentStyle)
&& !strcmp(family, currentFamily)) {
item->SetMarked(true);
familyItem->SetMarked(true);
}
stylesMenu->AddItem(item);
}
stylesMenu->SetTargetForItems(fMessageTarget);
}
fFontsMenu->SetTargetForItems(fMessageTarget);
}
void TextToolView::MessageReceived(BMessage *message)
{ char string1[255];
font_family family;
font_style style;
int32 num_styles,i;
uint32 flags;
BStringItem *selected;
switch(message->what)
{ case SHEAR_CHANGED:
fontview->currentfont.SetShear((float)shearslider->Value());
sprintf(string1,"Shear: %ld",shearslider->Value());
shearslider->SetLabel(string1);
fontview->SetFont(&(fontview->currentfont), B_FONT_SHEAR);
if(!(shearslider->IsFocus()))
shearslider->MakeFocus();
fontview->Invalidate();
break;
case ROTATION_CHANGED:
fontview->currentfont.SetRotation((float)rotationslider->Value());
sprintf(string1,"Rotation: %ld",rotationslider->Value());
rotationslider->SetLabel(string1);
fontview->SetFont(&(fontview->currentfont), B_FONT_ROTATION);
if(!(rotationslider->IsFocus()))
rotationslider->MakeFocus();
fontview->Invalidate();
break;
case SIZE_CHANGED:
fontview->currentfont.SetSize((float)sizeslider->Value());
sprintf(string1,"Size: %ld",sizeslider->Value());
sizeslider->SetLabel(string1);
fontview->SetFont(&(fontview->currentfont), B_FONT_SIZE);
if(!(sizeslider->IsFocus()))
sizeslider->MakeFocus();
fontview->Invalidate();
break;
case TEXT_CHANGED:
sprintf(fontview->text,textedit->Text());
fontview->Invalidate();
break;
case FONT_FAMILY_CHANGED:
//Delete all styles for the old family
stylelist->RemoveItems(0,stylelist->CountItems());
// Determine current family
selected=(BStringItem *)fontlist->ItemAt(fontlist->CurrentSelection());
// We can afford to do this only because user can't edit
// the font names
sprintf((char *)&family,selected->Text());
//Repopulate with all styles for new family
num_styles = count_font_styles(family);
for (i=0; i < num_styles; i++ )
{
if ( get_font_style(family, i, &style, &flags) == B_OK )
stylelist->AddItem(new BStringItem((char *)&style));
}
stylelist->Select(0);
// break;
case FONT_STYLE_CHANGED:
// Determine current family
selected=(BStringItem *)fontlist->ItemAt(fontlist->CurrentSelection());
sprintf((char *)&family,selected->Text());
// Determine current style
selected=(BStringItem *)stylelist->ItemAt(stylelist->CurrentSelection());
sprintf((char *)&style,selected->Text());
// Set text to new font
fontview->currentfont.SetFamilyAndStyle(family,style);
fontview->SetFont(&(fontview->currentfont));
fontview->Invalidate();
break;
case ANTIALIAS_TEXT:
if(aacheckbox->Value()==B_CONTROL_ON)
fontview->currentfont.SetFlags(B_FORCE_ANTIALIASING);
else
fontview->currentfont.SetFlags(B_DISABLE_ANTIALIASING);
fontview->SetFont(&(fontview->currentfont));
fontview->Invalidate();
break;
default:
BView::MessageReceived(message);
}
}
void
FontDemoView::MessageReceived(BMessage* msg)
{
switch (msg->what) {
case TEXT_CHANGED_MSG:
{
const char* text = NULL;
if (msg->FindString("_text", &text) == B_OK) {
SetString(text);
Invalidate(/*&fBoxRegion*/);
}
break;
}
case FONTSTYLE_CHANGED_MSG:
{
BMessage fontMessage;
if (msg->FindMessage("_fontMessage", &fontMessage) != B_OK)
return;
const char* family;
const char* style;
if (fontMessage.FindString("_family", &family) != B_OK
|| fontMessage.FindString("_style", &style) != B_OK)
return;
fFont.SetFamilyAndStyle(family, style);
Invalidate();
break;
}
case FONTFAMILY_CHANGED_MSG:
{
BMessage fontMessage;
if (msg->FindMessage("_fontMessage", &fontMessage) != B_OK)
return;
const char* family;
if (fontMessage.FindString("_family", &family) != B_OK)
return;
font_style style;
if (get_font_style(const_cast<char*>(family), 0, &style) == B_OK) {
fFont.SetFamilyAndStyle(family, style);
Invalidate(/*&fBoxRegion*/);
}
break;
}
case FONTSIZE_MSG:
{
float size = 0.0;
if (msg->FindFloat("_size", &size) == B_OK) {
SetFontSize(size);
Invalidate(/*&fBoxRegion*/);
}
break;
}
case FONTSHEAR_MSG:
{
float shear = 90.0;
if (msg->FindFloat("_shear", &shear) == B_OK) {
SetFontShear(shear);
Invalidate(/*&fBoxRegion*/);
}
break;
}
case ROTATION_MSG:
{
float rotation = 0.0;
if (msg->FindFloat("_rotation", &rotation) == B_OK) {
SetFontRotation(rotation);
Invalidate(/*&fBoxRegion*/);
}
break;
}
case SPACING_MSG:
{
float space = 0.0;
if (msg->FindFloat("_spacing", &space) == B_OK) {
SetSpacing(space);
Invalidate(/*&fBoxRegion*/);
}
break;
}
case OUTLINE_MSG:
{
int8 outline = 0;
if (msg->FindInt8("_outline", &outline) == B_OK) {
SetOutlineLevel(outline);
Invalidate(/*&fBoxRegion*/);
}
break;
}
case ALIASING_MSG:
{
bool aliased = false;
if (msg->FindBool("_aliased", &aliased) == B_OK) {
SetAntialiasing(aliased);
Invalidate(/*&fBoxRegion*/);
}
break;
}
case DRAWINGMODE_CHANGED_MSG:
{
if (msg->FindInt32("_mode", (int32 *)&fDrawingMode) == B_OK) {
Invalidate(/*&fBoxRegion*/);
switch (fDrawingMode) {
case B_OP_COPY:
printf("Drawing mode: B_OP_COPY\n");
break;
case B_OP_OVER:
printf("Drawing mode: B_OP_OVER\n");
break;
case B_OP_ERASE:
printf("Drawing mode: B_OP_ERASE\n");
break;
case B_OP_INVERT:
printf("Drawing mode: B_OP_INVERT\n");
break;
case B_OP_ADD:
printf("Drawing mode: B_OP_ADD\n");
break;
case B_OP_SUBTRACT:
printf("Drawing mode: B_OP_SUBTRACT\n");
break;
case B_OP_BLEND:
printf("Drawing mode: B_OP_BLEND\n");
break;
case B_OP_MIN:
printf("Drawing mode: B_OP_MIN\n");
break;
case B_OP_MAX:
printf("Drawing mode: B_OP_MAX\n");
break;
case B_OP_SELECT:
printf("Drawing mode: B_OP_SELECT\n");
break;
case B_OP_ALPHA:
printf("Drawing mode: B_OP_ALPHA\n");
break;
default:
printf("Drawing mode: %d\n", fDrawingMode);
}
}
break;
}
case BOUNDING_BOX_MSG:
{
bool boundingbox = false;
if (msg->FindBool("_boundingbox", &boundingbox) == B_OK) {
SetDrawBoundingBoxes(boundingbox);
Invalidate(/*&fBoxRegion*/);
}
break;
}
default:
BView::MessageReceived(msg);
break;
}
}
bool
BF_GUI_SetupDialog_FontItem::Invoke(BF_GUI_DlgView_Menu *po_Parent)
{
BF_GUI_Func_EnableDialog( po_Parent->Parent()->Name(),false );
/* prepare message */
BMessage oMessage(BF_MSG_DIALOG_FOCUS/*BF_MSG_MAINVIEW_MAINSETUP_FONT_UPDATED*/);
oMessage.AddPointer("bf_focus",po_Parent->Parent());
/* make dialog */
printf("BF_GUI_SetupDialog_FontItem::Invoke this=%i\n",this);
BF_GUI_SetupDialog_FontDialog *poDialog = new BF_GUI_SetupDialog_FontDialog(this,BRect(0,0,440,0),
sTitle.String(),"color_dialog",oMessage,BG_GUI_DIALOG_WINRESIZE_MOVE_CENTER,true);
/* resize dialog */
BRect oRect;
// make fonts_menu //
BL_List *poList = new BL_List();
int32 iCountFam = count_font_families();
for(int32 iFam=0;iFam<iCountFam;iFam++){
font_family uFam;
uint32 iFlags;
if( B_OK != get_font_family(iFam,&uFam,&iFlags)) continue;
// load styles
BL_List *plsStyle = new BL_List();
int32 iCountStyles = count_font_styles(uFam);
for(int iStyle=0;iStyle<iCountStyles;iStyle++){
font_style uStyle;
if(B_OK != get_font_style(uFam,iStyle,&uStyle,&iFlags)) continue;
plsStyle->AddItem( new BF_GUI_ViewMenu_Item(uStyle,uStyle));
}
// make store item
BF_GUI_SetupDialog_FontFamilyItem *poItem = new BF_GUI_SetupDialog_FontFamilyItem(uFam,plsStyle);
poList->AddItem(poItem);
}
poDialog->LocalBounds(oRect);
oRect.bottom = oRect.top + 300;
oRect.right = oRect.left + 200;
poDialog->AddChild( new BF_GUI_DlgView_VMenu(oRect,"families",B_FOLLOW_ALL,poList,BF_GUI_DLGVIEW_VMENU_NAV_PARENTINFORM) );
// make styles //
poDialog->LocalBounds(oRect);
oRect.bottom = oRect.top + 300;
oRect.left += 210;
poDialog->AddChild( new BF_GUI_DlgView_VMenu(oRect,"styles",B_FOLLOW_ALL,new BL_List(),BF_GUI_DLGVIEW_VMENU_NAV_PARENTINFORM) );
// make anti_aliasing
{
poDialog->LocalBounds(oRect);
oRect.top += 310;
oRect.bottom = oRect.top + poSysSetup->oFontToolView.fHeight*2;
oRect.right = oRect.left + 140;
BF_GUI_ViewCheck *poCheck = new BF_GUI_ViewCheck(oRect,"anti_aliasing",BF_DictAt(BF_DICT_FONTSETUP_ANTI)
,poFont->iFlags & B_FORCE_ANTIALIASING
,B_FOLLOW_LEFT|B_FOLLOW_TOP,B_WILL_DRAW|B_NAVIGABLE);
poDialog->AddChild(poCheck);
}
// make test
poDialog->LocalBounds(oRect);
oRect.top += 310;
oRect.bottom = oRect.top + poSysSetup->oFontToolView.fHeight*3;
oRect.left += 160;
poDialog->AddChild( new BF_GUI_FontView(oRect,B_FOLLOW_RIGHT|B_FOLLOW_BOTTOM) );
// make size
poDialog->LocalBounds(oRect);
oRect.top += 310+poSysSetup->oFontToolView.fHeight*2;
oRect.bottom = oRect.top + poSysSetup->oFontToolView.fHeight;
oRect.right = oRect.left + 150;
BL_String s;
s<<poFont->fSize;
BF_GUI_ViewEdit_Create(oRect,BF_DictAt(BF_DICT_SIZE),poDialog,"size",s.String()
,B_FOLLOW_LEFT|B_FOLLOW_BOTTOM,B_NAVIGABLE);
///////////////////////////////
/* make bottom menu */
BRect oRect1;
poDialog->LocalBounds(oRect1);
oRect.left = oRect1.left;
oRect.right = oRect1.right;
oRect.top = oRect.bottom+10;
oRect.bottom = oRect.top + poSysSetup->oFontToolView.fHeight;
BL_List *ploMenu = new BL_List();
ploMenu->AddItem(new BF_GUI_ViewMenu_Item(BF_DictAt(BF_DICT_OK),"ok"));
poDialog->AddMenu(oRect,ploMenu,true);
/* finish */
poDialog->SetHeightFromLastChild();
poDialog->MoveToCenter( poWinView );
BF_GUI_Func_AddChildToMainView( poDialog );
return true;
}
void
PreferenceFont::AttachedToWindow (void)
{
BView::AttachedToWindow();
SetViewColor (Parent()->ViewColor());
// Moved this here because Gord has 3000 fonts,
// and he was complaining that the preferences
// window was coming up slow. This will postpone it
// until he wants to change the fonts. Can you believe it,
// 3000!?!?
if (clientFont[0] == 0)
{
int32 i, family_count (count_font_families());
float label_width (0.0);
for (i = 0; ControlLabels[i]; ++i)
if (be_plain_font->StringWidth (ControlLabels[i]) > label_width)
label_width = be_plain_font->StringWidth (ControlLabels[i]);
FontStat *font_stat = new FontStat [family_count];
for (i = 0; i < family_count; ++i)
{
uint32 flags;
*font_stat[i].family = '\0';
font_stat[i].style_count = 0;
font_stat[i].styles = 0;
if (get_font_family (i, &font_stat[i].family, &flags) == B_OK
&& (font_stat[i].style_count = count_font_styles (font_stat[i].family)) > 0)
{
font_stat[i].styles = new font_style [font_stat[i].style_count];
for (int32 j = 0; j < font_stat[i].style_count; ++j)
{
*font_stat[i].styles[j] = '\0';
get_font_style (font_stat[i].family, j, font_stat[i].styles + j, &flags);
}
}
}
BMenu *parentMenu[2][5];
BRect frame (Bounds());
font_height fh;
float height;
GetFontHeight (&fh);
height = fh.ascent + fh.descent + fh.leading + 20;
for (i = 0; i < 5; ++i)
{
font_family cur_family;
font_style cur_style;
float cur_size;
int32 j;
bowser_app->GetClientFont (i)->GetFamilyAndStyle (
&cur_family,
&cur_style);
cur_size = bowser_app->GetClientFont (i)->Size();
parentMenu[0][i] = new BMenu ("Font");
parentMenu[1][i] = new BMenu ("Size");
clientFont[i] = new BMenuField (
BRect (0, i * height, 185, 20 + i * height),
"clientFont",
ControlLabels[i],
parentMenu[0][i]);
AddChild (clientFont[i]);
fontSize[i] = new BMenuField (
BRect (210, i * height, frame.right, 20 + i * height),
"fontSize",
"",
parentMenu[1][i]);
fontSize[i]->Menu()->SetRadioMode (true);
fontSize[i]->SetDivider (0.0);
AddChild (fontSize[i]);
clientFont[i]->SetDivider (label_width + 5.0);
for (j = 0; j < family_count; ++j)
if (*font_stat[j].family && font_stat[j].style_count)
{
BMenu *menu (new BMenu (font_stat[j].family));
parentMenu[0][i]->AddItem (menu);
for (int32 k = 0; k < font_stat[j].style_count; ++k)
{
BMessage *msg (new BMessage (M_FONT_CHANGE));
BMenuItem *item;
msg->AddString ("family", font_stat[j].family);
msg->AddString ("style", font_stat[j].styles[k]);
msg->AddInt32 ("which", i);
menu->AddItem (item = new BMenuItem (font_stat[j].styles[k], msg));
if (strcmp (font_stat[j].family, cur_family) == 0
&& strcmp (font_stat[j].styles[k], cur_style) == 0)
{
item->SetMarked (true);
clientFont[i]->MenuItem()->SetLabel (font_stat[j].family);
}
}
}
for (j = 0; FontSizes[j]; ++j)
{
BMessage *msg (new BMessage (M_FONT_SIZE_CHANGE));
BMenuItem *item;
char buffer[32];
sprintf (buffer, "%ld", FontSizes[j]);
msg->AddInt32 ("size", FontSizes[j]);
msg->AddInt32 ("which", i);
parentMenu[1][i]->AddItem (item = new BMenuItem (buffer, msg));
if (FontSizes[j] == cur_size)
item->SetMarked (true);
}
}
for (i = 0; i < family_count; ++i)
delete [] font_stat[i].styles;
delete [] font_stat;
}
for (int32 i = 0; i < 5; ++i)
{
fontSize[i]->Menu()->SetLabelFromMarked (true);
fontSize[i]->MenuItem()->SetLabel (fontSize[i]->Menu()->FindMarked()->Label());
fontSize[i]->Menu()->SetTargetForItems (this);
for (int32 j = 0; j < clientFont[i]->Menu()->CountItems(); ++j)
{
BMenuItem *item (clientFont[i]->Menu()->ItemAt (j));
item->Submenu()->SetTargetForItems (this);
}
}
ResizeTo (Frame().Width(), clientFont[4]->Frame().bottom);
}
BYdpMainWindow::BYdpMainWindow(const char *windowTitle) : BWindow(
BRect(64, 64, 585, 480), windowTitle, B_DOCUMENT_WINDOW, B_OUTLINE_RESIZE ) {
this->Hide();
config = new bydpConfig();
BView *MainView(
new BView(BWindow::Bounds(), NULL, B_FOLLOW_ALL, 0) );
if (MainView == NULL) {
AppReturnValue = B_NO_MEMORY;
be_app->PostMessage(B_QUIT_REQUESTED);
return;
}
MainView->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
BWindow::AddChild(MainView);
wordInput = new BTextControl(
BRect(5,24,210,45), "wordInput", NULL, "text", new BMessage(MSG_MODIFIED_INPUT));
wordInput->SetModificationMessage(new BMessage(MSG_MODIFIED_INPUT));
MainView->AddChild(wordInput);
outputView = new BTextView(
BRect(220,24,506,402), "outputView", BRect(10,10,300,200), B_FOLLOW_LEFT_RIGHT|B_FOLLOW_TOP_BOTTOM, B_WILL_DRAW|B_PULSE_NEEDED);
outputView->SetText("output");
outputView->MakeEditable(false);
outputView->SetStylable(true);
MainView->AddChild(new BScrollView("scrolloutput",outputView,B_FOLLOW_LEFT_RIGHT|B_FOLLOW_TOP_BOTTOM, 0, true, true));
dictList = new bydpListView("listView", this);
MainView->AddChild(new BScrollView("scrollview", dictList, B_FOLLOW_LEFT|B_FOLLOW_TOP_BOTTOM, 0, false, false, B_FANCY_BORDER));
dictList->SetInvocationMessage(new BMessage(MSG_LIST_INVOKED));
dictList->SetSelectionMessage(new BMessage(MSG_LIST_SELECTED));
BRect barr = dictList->Bounds();
barr.left = barr.right-B_V_SCROLL_BAR_WIDTH;
scrollBar = new bydpScrollBar(barr, "scrollbar", dictList);
dictList->AddChild(scrollBar);
dictList->SetScrollBar(scrollBar);
ydpConv = new ConvertYDP();
sapConv = new ConvertSAP();
// sq2Conv = new ConvertSQ2();
ydpDict = new EngineYDP(outputView, dictList, config, ydpConv);
sapDict = new EngineSAP(outputView, dictList, config, sapConv);
// sq2Dict = new EngineSQ2(outputView, dictList, config, sq2Conv);
switch(config->dictionarymode) {
/* case DICTIONARY_SQ2:
myDict = sq2Dict;
myConverter = sq2Conv;
break; */
case DICTIONARY_YDP:
myDict = ydpDict;
myConverter = ydpConv;
break;
case DICTIONARY_SAP:
default:
myDict = sapDict;
myConverter = sapConv;
break;
}
dictList->SetConverter(myConverter);
BRect r;
r = MainView->Bounds();
r.bottom = 19;
BMenuBar *menubar = new BMenuBar(r, "menubar");
MainView->AddChild(menubar);
BMenu *menu = new BMenu("File");
menu->AddItem(new BMenuItem("About...", new BMessage(MENU_ABOUT), 'O'));
menu->AddItem(new BMenuItem("Quit", new BMessage(B_QUIT_REQUESTED), 'Q'));
menubar->AddItem(menu);
BMenu *engineMenu;
menu = new BMenu("Dictionary");
menu->AddItem(new BMenuItem("Switch", new BMessage(MENU_SWITCH), 'J'));
menu->AddItem(menuEng = new BMenuItem("Eng -> Pol", new BMessage(MENU_ENG2POL), 'E'));
menu->AddItem(menuPol = new BMenuItem("Pol -> Eng", new BMessage(MENU_POL2ENG), 'P'));
menu->AddSeparatorItem();
menu->AddItem(engineMenu = new BMenu("Dictionary engine"));
engineMenu->AddItem(menuSAP = new BMenuItem("SAP", new BMessage(MENU_ENGINESAP)));
engineMenu->AddItem(menuYDP = new BMenuItem("YDP", new BMessage(MENU_ENGINEYDP)));
// engineMenu->AddItem(menuSQ2 = new BMenuItem("SQ2", new BMessage(MENU_ENGINESQ2)));
menubar->AddItem(menu);
menu = new BMenu("Search type");
menu->AddItem(menuPlain = new BMenuItem("Plain", new BMessage(MENU_PLAIN), 'Z'));
menu->AddItem(menuFuzzy = new BMenuItem("Fuzzy", new BMessage(MENU_FUZZY), 'R'));
menubar->AddItem(menu);
menu = new BMenu("Settings");
menu->AddItem(new BMenuItem("Path to dictionary", new BMessage(MENU_PATH), 'S'));
menu->AddSeparatorItem();
menu->AddItem(menuCol0 = new BMenuItem(myDict->ColourFunctionName(0), new BMessage(MENU_COLOR0)));
menu->AddItem(menuCol1 = new BMenuItem(myDict->ColourFunctionName(1), new BMessage(MENU_COLOR1)));
menu->AddItem(menuCol2 = new BMenuItem(myDict->ColourFunctionName(2), new BMessage(MENU_COLOR2)));
menu->AddItem(menuCol3 = new BMenuItem(myDict->ColourFunctionName(3), new BMessage(MENU_COLOR3)));
menu->AddSeparatorItem();
menu->AddItem(menuClip = new BMenuItem("Clipboard tracking", new BMessage(MENU_CLIP), 'L'));
menu->AddItem(menuFocus = new BMenuItem("Popup window", new BMessage(MENU_FOCUS), 'F'));
menu->AddSeparatorItem();
menu->AddItem(new BMenuItem("Fuzzy factor", new BMessage(MENU_DISTANCE)));
// menu->AddItem(new BMenuItem("SQL data source", new BMessage(MENU_SQL)));
menu->AddSeparatorItem();
menubar->AddItem(menu);
BMessage *fontMessage;
fontMenu = new BMenu("Font");
menu->AddItem(fontMenu);
BMenu* fontSizeMenu = new BMenu("Size");
fontSizeMenu->SetRadioMode(true);
fontMenu->AddItem(fontSizeMenu);
fontMenu->AddSeparatorItem();
fontSizeMenu->AddItem(new BMenuItem("9", fontMessage = new BMessage(FONT_SIZE)));
fontMessage->AddFloat("size", 9.0);
fontSizeMenu->AddItem(new BMenuItem("10", fontMessage = new BMessage(FONT_SIZE)));
fontMessage->AddFloat("size",10.0);
fontSizeMenu->AddItem(new BMenuItem("11", fontMessage = new BMessage(FONT_SIZE)));
fontMessage->AddFloat("size",11.0);
fontSizeMenu->AddItem(new BMenuItem("12", fontMessage = new BMessage(FONT_SIZE)));
fontMessage->AddFloat("size",12.0);
fontSizeMenu->AddItem(new BMenuItem("14", fontMessage = new BMessage(FONT_SIZE)));
fontMessage->AddFloat("size",14.0);
fontSizeMenu->AddItem(new BMenuItem("18", fontMessage = new BMessage(FONT_SIZE)));
fontMessage->AddFloat("size",18.0);
fontSizeMenu->AddItem(new BMenuItem("24", fontMessage = new BMessage(FONT_SIZE)));
fontMessage->AddFloat("size",24.0);
fontSizeMenu->AddItem(new BMenuItem("36", fontMessage = new BMessage(FONT_SIZE)));
fontMessage->AddFloat("size",36.0);
fontSizeMenu->AddItem(new BMenuItem("48", fontMessage = new BMessage(FONT_SIZE)));
fontMessage->AddFloat("size",48.0);
fontSizeMenu->AddItem(new BMenuItem("72", fontMessage = new BMessage(FONT_SIZE)));
fontMessage->AddFloat("size",72.0);
font_family plain_family;
font_style plain_style;
config->currentFont.GetFamilyAndStyle(&plain_family,&plain_style);
BMenu *subMenu;
BMenuItem *menuItem;
currentFontItem = 0;
int32 numFamilies = count_font_families();
for ( int32 i = 0; i < numFamilies; i++ ) {
font_family localfamily;
if ( get_font_family ( i, &localfamily ) == B_OK ) {
subMenu = new BMenu(localfamily);
subMenu->SetRadioMode(true);
fontMenu->AddItem(menuItem = new BMenuItem(subMenu, new BMessage(FONT_FAMILY)));
if (!strcmp(plain_family,localfamily)) {
menuItem->SetMarked(true);
currentFontItem = menuItem;
}
int32 numStyles=count_font_styles(localfamily);
for(int32 j = 0;j<numStyles;j++){
font_style style;
uint32 flags;
if( get_font_style(localfamily,j,&style,&flags)==B_OK){
subMenu->AddItem(menuItem = new BMenuItem(style, new BMessage(FONT_STYLE)));
if (!strcmp(plain_style,style)) {
menuItem->SetMarked(true);
}
}
}
}
}
this->FrameResized(0.0, 0.0);
UpdateMenus();
wordInput->MakeFocus(true);
firstStart = true;
TryToOpenDict();
BMessenger mesg(this);
be_clipboard->StartWatching(mesg);
}
// ----------------------------------------------------------------- RHTML_Preferences_Win - MessageReceived -
void RHTMLPreferencesWin::MessageReceived(BMessage *msg)
{
switch (msg->what)
{
case 'LANG':
{
int32 lang;
msg->FindInt32("Lang",&lang);
fOptions->CurrentLocale=lang;
BAlert *fAlert= new BAlert("Alert",fOptions->GetLocaleString("Preferences_Window_Alert","To take effect your changes you must restart Globe!"),"OK");
LSetAuthor();
fAlert->Go();
fOptions->Save();
}
break;
case 'FTFT':
{
int32 filetype;
msg->FindInt32("FileType",&filetype);
FTCreateKitList(filetype);
}
break;
case 'FTHF':
{
int32 filetype;
msg->FindInt32("FileType",&filetype);
fFTHFileTypes= (uint) filetype;
FTHSetFT(filetype);
}
break;
case 'FTHT':
{
int32 fontcolor;
msg->FindInt32("FontColor",&fontcolor);
fFTHFontColor= (uint) fontcolor;
FTHSetFSize(fontcolor);
}
break;
case R_FTH_Family_MSG:
{
const char *family;
msg->FindString("font_family",&family);
fOptions->FileTypes[fFTHFileTypes]->Font[fFTHFontColor]->Family.SetTo(family);
if (fOptions->FileTypes[fFTHFileTypes]->Font[fFTHFontColor]->Style.ICompare("Default style")!=0)
{
font_family fFamily;
font_style fStyle;
if (strcmp(family,"Default font")==0)
{
fOptions->DefaultFont->GetFamilyAndStyle(&fFamily,&fStyle);
} else strcpy(fFamily,family);
get_font_style(fFamily, 0, &fStyle);
fOptions->FileTypes[fFTHFileTypes]->Font[fFTHFontColor]->Style.SetTo(fStyle);
FTHSetFSize(fFTHFontColor);
}
fOptions->Save();
}
break;
case R_FTH_Style_MSG:
{
const char *style;
msg->FindString("font_style",&style);
fOptions->FileTypes[fFTHFileTypes]->Font[fFTHFontColor]->Style.SetTo(style);
fOptions->Save();
}
break;
case R_FTH_Size_MSG:
{
int32 size;
msg->FindInt32("font_size",&size);
fOptions->FileTypes[fFTHFileTypes]->Font[fFTHFontColor]->Size=size;
fOptions->Save();
}
break;
case R_FTH_Color_MSG:
{
fOptions->FileTypes[fFTHFileTypes]->Color[fFTHFontColor]->alpha=fFTHCC->ValueAsColor().alpha;
fOptions->FileTypes[fFTHFileTypes]->Color[fFTHFontColor]->red=fFTHCC->ValueAsColor().red;
fOptions->FileTypes[fFTHFileTypes]->Color[fFTHFontColor]->green=fFTHCC->ValueAsColor().green;
fOptions->FileTypes[fFTHFileTypes]->Color[fFTHFontColor]->blue=fFTHCC->ValueAsColor().blue;
fOptions->Save();
}
break;
case 'FTSL':
{
if (fFTKit->CurrentSelection()>=0)
fFTStrView->SetText(fOptions->FileTypes[fFT]->Kit[fFTKit->CurrentSelection()]->String());
}
break;
case 'FTAD':
{
uint num=fOptions->AddFTKit(fFT,fFTStrView->Text());
FTCreateKitList(fFT);
fFTKit->Select(num);
fOptions->Save();
}
break;
case 'FTRM':
{
if (fFTKit->CurrentSelection()>=0)
{
fOptions->RemoveFTKit(fFT,fFTKit->CurrentSelection());
FTCreateKitList(fFT);
fOptions->Save();
}
}
break;
case 'FTED':
{
if (fFTKit->CurrentSelection()>=0)
{
fOptions->EditFTKit(fFT,fFTKit->CurrentSelection(),fFTStrView->Text());
FTCreateKitList(fFT);
fOptions->Save();
}
}
break;
case 'FTDF':
{
const char *family;
msg->FindString("font_family",&family);
FTSetFont(family);
font_style fStyle;
get_font_style((font_family) family, 0, &fStyle);
fOptions->DefaultFont->SetFamilyAndStyle(family,fStyle);
fOptions->Save();
}
break;
case 'FTFS':
{
const char *style;
msg->FindString("font_style",&style);
font_family family;
font_style fstyle;
fOptions->DefaultFont->GetFamilyAndStyle(&family,&fstyle);
fOptions->DefaultFont->SetFamilyAndStyle(family, style);
fOptions->Save();
}
break;
case 'FTSZ':
{
int32 size;
msg->FindInt32("font_size",&size);
fOptions->DefaultFont->SetSize((float) size);
fOptions->Save();
}
break;
case 'LIST':
{
for (uint i=0;i<JViewDb;i++)fJView[i]->ResizeTo(0,0);
if (fList->CurrentSelection()>=0)
{
fJView[fList->CurrentSelection()]->ResizeTo(fView->Bounds().right,fView->Bounds().bottom);
FTHSetFSize(0);
}
}
break;
case 'DFBB':
{
if (!IsHidden())
Hide();
fDFFilePanel->Show();
}
break;
case 'DFFP':
{
entry_ref ref;
status_t err;
int32 ref_num;
BPath path;
BEntry entry;
ref_num = 0;
do
{
if ((err = msg->FindRef("refs", ref_num, &ref)) != B_OK) { return; }
if ((err=entry.SetTo(&ref)) == B_OK)
{
entry.GetPath(&path);
fDFDefaultFolder->SetText(path.Path());
fOptions->DefaultFolder.SetTo(path.Path());
fOptions->Save();
}
ref_num++;
} while (1);
}
break;
case 'DFFN':
{
fOptions->DefaultFolder.SetTo(fDFDefaultFolder->Text());
fOptions->Save();
}
break;
case 'DFCK':
{
fOptions->DFOnlyStart=fDFCheckBox->Value();
fOptions->Save();
}
break;
case 'APRT':
{
fOptions->ReakcioIdo = (uint32) (fAPSlider->Position() * 1000);
fOptions->Save();
}
break;
case 'APTM':
{
fOptions->ReakcioIdoTM = (uint32) (fAPTMSlider->Position() * 1000);
fOptions->Save();
}
break;
case B_CANCEL:
{
if (IsHidden())
Show();
}
break;
default:
{
BWindow::MessageReceived(msg);
}
break;
}
}
