int CharismaWindow::saveprefs()
{
FILE *f;
BMenu *m;
char fname[B_PATH_NAME_LENGTH];
int r;
BRect rect;
r=find_directory(B_COMMON_SETTINGS_DIRECTORY,0,true,fname,sizeof fname);
if(r) return r;
strcat(fname,"/");
strcat(fname,"Charisma_settings");
f=fopen(fname,"w");
if(!f)return -1;
fprintf(f,"Charisma_settings\n");
fprintf(f,"version=1\n");
fprintf(f,"directory=%s\n",g_webdir);
m=modemenu->Menu();
fprintf(f,"mode=%d\n",m->IndexOf(m->FindMarked()));
m=smartrefresh->Menu();
fprintf(f,"smart_refresh=%d\n",m->IndexOf(m->FindMarked()));
fprintf(f,"external_control=%s\n",extcontrol_item->IsMarked()?"yes":"no");
fprintf(f,"netpositive_autoset=%s\n",netposautoset_item->IsMarked()?"yes":"no");
rect=Frame();
fprintf(f,"position=%f,%f\n",rect.left,rect.top);
fprintf(f,"minimized=%s\n",isminim?"yes":"no");
fclose(f);
return 0;
}
void
ControlView::_UpdateAndSendStyle(const BMessage* message)
{
_DeselectOldItems();
const char* style;
const char* family;
if (message->FindString("_style", &style) == B_OK
&& message->FindString("_family", &family) == B_OK) {
BMenuItem* familyItem = fFontFamilyMenu->FindItem(family);
if (familyItem && !familyItem->IsMarked()) {
familyItem->SetMarked(true);
BMenu* submenu = familyItem->Submenu();
if (submenu) {
BMenuItem* styleItem = submenu->FindItem(style);
if (styleItem && !styleItem->IsMarked())
styleItem->SetMarked(true);
}
printf("Family: %s, Style: %s\n", family, style);
}
BString string;
string << family << " " << style;
if (fFontMenuField)
fFontMenuField->MenuItem()->SetLabel(string.String());
}
BMessage fontMsg(FONTSTYLE_CHANGED_MSG);
if (fontMsg.AddMessage("_fontMessage", message) == B_OK)
fMessenger->SendMessage(&fontMsg);
}
void
PropEnumFlagEditor::HandleEdit(int32 value)
{
int32 newValue = 0;
for (int32 i = 0; i < fMenu->CountItems(); i++)
{
BMenuItem *item = fMenu->ItemAt(i);
int32 temp;
if (!item || item->Message()->FindInt32("value",&temp) != B_OK)
continue;
if (temp == value)
{
if (item->IsMarked())
{
item->SetMarked(false);
continue;
}
else
item->SetMarked(true);
}
if (item->IsMarked())
newValue |= temp;
}
PropEnumEditor::HandleEdit(newValue);
}
status_t
PMenuItem::GetProperty(const char *name, PValue *value, const int32 &index) const
{
if (!name || !value)
return B_ERROR;
BString str(name);
PProperty *prop = FindProperty(name,index);
if (!prop)
return B_NAME_NOT_FOUND;
BMenuItem *backend = (BMenuItem*)fBackend;
if (str.ICompare("Message") == 0)
((IntProperty*)prop)->SetValue(backend->Command());
else if (str.ICompare("Trigger") == 0)
((CharProperty*)prop)->SetValue(backend->Trigger());
else if (str.ICompare("Label") == 0)
((StringProperty*)prop)->SetValue(backend->Label());
else if (str.ICompare("Frame") == 0)
((RectProperty*)prop)->SetValue(backend->Frame());
else if (str.ICompare("Marked") == 0)
((BoolProperty*)prop)->SetValue(backend->IsMarked());
else if (str.ICompare("Enabled") == 0)
((BoolProperty*)prop)->SetValue(backend->IsEnabled());
else
{
return PObject::GetProperty(name, value, index);
}
return prop->GetValue(value);
}
void
ShowImageWindow::_MarkMenuItem(BMenu *menu, uint32 what, bool marked)
{
BMenuItem* item = menu->FindItem(what);
if (item && item->IsMarked() != marked)
item->SetMarked(marked);
}
void
AttributeWindow::_CheckDisplayAs()
{
// check display as suported types
type_code currentType = _CurrentType();
BMenu* menu = fDisplayAsMenuField->Menu();
for (int32 i = menu->CountItems(); i-- > 0;) {
BMenuItem* item = menu->ItemAt(i);
bool supported = item == _DefaultDisplayAs();
// the default type is always supported
type_code type;
for (int32 j = 0; item->Message()->FindInt32("supports",
j, (int32*)&type) == B_OK; j++) {
if (type == currentType) {
supported = true;
break;
}
}
item->SetEnabled(supported);
if (item->IsMarked() && !supported)
menu->ItemAt(0)->SetMarked(true);
}
fSpecialControl->SetEnabled(!_DefaultDisplayAs()->IsMarked());
}
/*! Gets the path of the currently marked keyboard layout item
by searching through each of the menus recursively until
a marked item is found.
*/
BPath
KeymapWindow::_GetMarkedKeyboardLayoutPath(BMenu* menu)
{
BPath path;
BMenuItem* item = NULL;
entry_ref ref;
for (int32 i = 0; i < menu->CountItems(); i++) {
item = menu->ItemAt(i);
if (item == NULL)
continue;
BMenu* submenu = item->Submenu();
if (submenu != NULL)
return _GetMarkedKeyboardLayoutPath(submenu);
else {
if (item->IsMarked()
&& item->Message()->FindRef("ref", &ref) == B_OK) {
path.SetTo(&ref);
return path;
}
}
}
return path;
}
void
ShowImageWindow::_MarkMenuItem(BMenu* menu, uint32 what, bool marked)
{
BMenuItem* item = menu->FindItem(what);
if (item && item->IsMarked() != marked)
item->SetMarked(marked);
fToolBarView->SetActionPressed(what, marked);
}
void
MainWindow::WindowActivated(bool active)
{
if (fFieldView->GetGameState() != GAME_STARTED)
return;
BMenuItem *item = fMenuBar->FindItem(M_PAUSE_GAME);
if (!item->IsMarked())
PostMessage(M_PAUSE_GAME);
}
void TeamListView::UpdatePopUpPriorityMenu()
{
BMenuField *Priority = (BMenuField *)slayer->mainWindow->FindView("MainPriorityField");
BMenu *menu = Priority->Menu();
BMenuItem *item;
int32 i;
for (i = 2; (item = menu->ItemAt(i)); i++) {
priorityMenu->ItemAt(i-2)->SetMarked(item->IsMarked());
priorityMenu->ItemAt(i-2)->SetEnabled(item->IsEnabled());
}
}
bool
ShowImageWindow::_ToggleMenuItem(uint32 what)
{
bool marked = false;
BMenuItem *item = fBar->FindItem(what);
if (item != NULL) {
marked = !item->IsMarked();
item->SetMarked(marked);
}
return marked;
}
bool
ShowImageWindow::_ToggleMenuItem(uint32 what)
{
bool marked = false;
BMenuItem* item = fBar->FindItem(what);
if (item != NULL) {
marked = !item->IsMarked();
item->SetMarked(marked);
}
fToolBarView->SetActionPressed(what, marked);
return marked;
}
void CharismaWindow::setnetpos()
{
int newnetpossetting;
if(!netposautoset_item->IsMarked())
return;
newnetpossetting=g_mode!=k_disabled;
if(newnetpossetting!=curnetpossetting){
setNPprefs(newnetpossetting);
curnetpossetting=newnetpossetting;
}
}
void SeqManageRosterWindow::MenusBeginning()
{
inherited::MenusBeginning();
BMenuBar* bar = KeyMenuBar();
if (!bar) return;
BColumnListView* table = dynamic_cast<BColumnListView*>( FindView(TABLE_STR) );
if (!table) return;
BMenu* menu;
BMenuItem* item;
// Entry menu
bool canEdit = false, canDuplicate = false;
BString key, filePath;
bool readOnly;
if (GetSelectionInfo(key, filePath, &readOnly) == B_OK) {
canEdit = !readOnly;
canDuplicate = true;
}
if ( (menu = bar->SubmenuAt(ENTRY_MENU_INDEX)) != NULL) {
if ( (item = menu->FindItem(EDIT_ENTRY_MSG)) != NULL) item->SetEnabled(canEdit);
if ( (item = menu->FindItem(DUPLICATE_ENTRY_MSG)) != NULL) item->SetEnabled(canDuplicate);
if ( (item = menu->FindItem(DELETE_ENTRY_MSG)) != NULL) item->SetEnabled(canEdit);
}
// Attributes menu
if ( (menu = bar->SubmenuAt(ATTRIBUTES_MENU_INDEX)) != NULL) {
for (int32 k = 0; (item = menu->ItemAt(k)) != NULL; k++) {
const char* n;
if (item->Message() && item->Message()->FindString(COLUMN_NAME_STR, &n) == B_OK) {
BColumn* col = column_named(n, table);
if (col && col->IsVisible() ) {
if (!item->IsMarked() ) item->SetMarked(true);
} else {
if (item->IsMarked() ) item->SetMarked(false);
}
}
}
}
}
void SeqStudioWindow::MenusBeginning()
{
inherited::MenusBeginning();
BMenuBar* bar = KeyMenuBar();
if (!bar) return;
BColumnListView* table = dynamic_cast<BColumnListView*>( FindView(ENDPOINT_LIST_STR) );
if (!table) return;
if (mDeviceCtrl && mDeviceCtrl->Menu() ) add_device_menu_items(mDeviceCtrl->Menu() );
// MIDI Port menu
if (mPortMenu) {
bool deleteEnabled = false;
_EndpointRow* r = dynamic_cast<_EndpointRow*>(table->CurrentSelection() );
if (r && !r->mIsValid && r->mEndpoint.channel < 0) deleteEnabled = true;
BMenuItem* deleteItem = mPortMenu->FindItem(DELETE_STR);
if (deleteItem && deleteItem->IsEnabled() != deleteEnabled) deleteItem->SetEnabled(deleteEnabled);
}
// Attributes menu
BMenu* menu;
BMenuItem* item;
if ( (menu = bar->SubmenuAt(ATTRIBUTES_MENU_INDEX)) != NULL) {
for (int32 k = 0; (item = menu->ItemAt(k)) != NULL; k++) {
const char* n;
if (item->Message() && item->Message()->FindString(COLUMN_NAME_STR, &n) == B_OK) {
BColumn* col = column_named(n, table);
if (col && col->IsVisible() ) {
if (!item->IsMarked() ) item->SetMarked(true);
} else {
if (item->IsMarked() ) item->SetMarked(false);
}
}
}
}
}
int32
GoGoEncoder::GetPsycho(bool* psycho) {
PRINT(("GoGoEncoder::GetPsycho(bool*)\n"));
BMenuItem* item;
item = menu->FindItem(PSYCHO_ACOUSTICS_STR);
if (!item) {
return B_ERROR;
}
*psycho = item->IsMarked();
return B_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
ShowImageWindow::_MarkSlideShowDelay(float value)
{
const int32 n = fSlideShowDelay->CountItems();
float v;
for (int32 i = 0; i < n; i ++) {
BMenuItem* item = fSlideShowDelay->ItemAt(i);
if (item) {
if (item->Message()->FindFloat("value", &v) == B_OK && v == value) {
if (!item->IsMarked())
item->SetMarked(true);
return;
}
}
}
}
status_t
NotifierConfigView::SaveInto(BMailAddOnSettings& settings) const
{
int32 method = 0;
BMenuField *field;
if ((field = dynamic_cast<BMenuField *>(FindView("notify"))) != NULL) {
for (int32 i = field->Menu()->CountItems(); i-- > 0;) {
BMenuItem *item = field->Menu()->ItemAt(i);
if (item->IsMarked())
method |= 1L << i;
}
}
return settings.SetInt32("notification_method", method);
}
void ConfigView::MessageReceived(BMessage *msg)
{
switch (msg->what)
{
case kMsgNotifyMethod:
{
BMenuItem *item;
if (msg->FindPointer("source",(void **)&item) < B_OK)
break;
item->SetMarked(!item->IsMarked());
UpdateNotifyText();
break;
}
default:
BView::MessageReceived(msg);
}
}
status_t ConfigView::Archive(BMessage *into, bool) const
{
int32 method = 0;
BMenuField *field;
if ((field = dynamic_cast<BMenuField *>(FindView("notify"))) != NULL)
{
for (int32 i = field->Menu()->CountItems();i-- > 0;)
{
BMenuItem *item = field->Menu()->ItemAt(i);
if (item->IsMarked())
method |= 1L << i;
}
}
if (into->ReplaceInt32("notification_method",method) != B_OK)
into->AddInt32("notification_method",method);
return B_OK;
}
/*****************************************************************************
* InterfaceWindow::_UpdateSpeedMenu
*****************************************************************************/
void
InterfaceWindow::_UpdateSpeedMenu( int rate )
{
BMenuItem * toMark = NULL;
switch( rate )
{
case ( INPUT_RATE_DEFAULT * 8 ):
toMark = fHeighthMI;
break;
case ( INPUT_RATE_DEFAULT * 4 ):
toMark = fQuarterMI;
break;
case ( INPUT_RATE_DEFAULT * 2 ):
toMark = fHalfMI;
break;
case ( INPUT_RATE_DEFAULT ):
toMark = fNormalMI;
break;
case ( INPUT_RATE_DEFAULT / 2 ):
toMark = fTwiceMI;
break;
case ( INPUT_RATE_DEFAULT / 4 ):
toMark = fFourMI;
break;
case ( INPUT_RATE_DEFAULT / 8 ):
toMark = fHeightMI;
break;
}
if ( toMark && !toMark->IsMarked() )
{
toMark->SetMarked( true );
}
}
void ConfigView::UpdateNotifyText()
{
BMenuField *field;
if ((field = dynamic_cast<BMenuField *>(FindView("notify"))) == NULL)
return;
BString label;
for (int32 i = field->Menu()->CountItems();i-- > 0;)
{
BMenuItem *item = field->Menu()->ItemAt(i);
if (!item->IsMarked())
continue;
if (label != "")
label.Prepend(" + ");
label.Prepend(item->Label());
}
if (label == "")
label = "none";
field->MenuItem()->SetLabel(label.String());
}
void
MainWindow::MessageReceived(BMessage *msg)
{
switch (msg->what)
{
case B_ABOUT_REQUESTED:
{
AboutRequested();
break;
}
case M_SHOW_HELP:
{
HelpWindow *helpwin = new HelpWindow();
helpwin->Show();
break;
}
case M_SHOW_CUSTOM:
{
CustomWindow *cswin = new CustomWindow();
cswin->Show();
break;
}
case M_NEW_GAME:
{
SetFace(FACE_NORMAL);
SetupGame();
break;
}
case M_SHOW_SCORES:
{
ScoreWindow *scorewin = new ScoreWindow();
scorewin->Show();
break;
}
case M_PAUSE_GAME:
{
BMenuItem *item = fMenuBar->FindItem(M_PAUSE_GAME);
if (fTimerView->GetState() == TIMER_START)
{
fTimerView->SetState(TIMER_STOP);
if (item)
item->SetMarked(true);
fFieldView->SetPauseMode(true);
}
else
{
if (item->IsMarked())
{
fTimerView->SetState(TIMER_START);
if (item)
item->SetMarked(false);
fFieldView->SetPauseMode(false);
}
}
break;
}
case M_SET_DIFFICULTY:
{
int32 level;
if (msg->FindInt32("level",&level) != B_OK)
break;
BMenuItem *item = fMenuBar->FindItem(M_SET_DIFFICULTY);
BMenu *menu = item ? item->Menu() : NULL;
item = menu->FindMarked();
if (item)
item->SetMarked(false);
menu->ItemAt(level)->SetMarked(true);
gDifficulty = level;
SetupGame();
fFieldView->SetPauseMode(false);
break;
}
case M_UPDATE_COUNT:
{
fCounterView->SetCount(fFieldView->MineCount() - fFieldView->FlagCount());
break;
}
case M_START_TIMER:
{
fTimerView->SetState(TIMER_RESET);
fTimerView->SetState(TIMER_START);
gGameState = GAME_STARTED;
break;
}
case M_SONAR_PENALTY:
{
fTimerView->SetState(TIMER_STOP);
if (fTimerView->GetTime() < 979)
fTimerView->SetTime(fTimerView->GetTime() + 20);
else
fTimerView->SetTime(999);
fTimerView->SetState(TIMER_START);
if (fFieldView->CheckWin())
fFieldView->DoWin();
break;
}
case M_SIZE_CHANGED:
{
ResizeTo(fFieldView->Frame().right + 10,fFieldView->Frame().bottom + 10);
break;
}
case M_SET_THEME:
{
BString name;
if (msg->FindString("name",&name) == B_OK)
SetTheme(name.String());
break;
}
case M_TOGGLE_SOUNDS:
{
gPlaySounds = gPlaySounds ? false : true;
BMenuItem *item = fMenuBar->FindItem(M_TOGGLE_SOUNDS);
if (item)
item->SetMarked(!item->IsMarked());
break;
}
default:
{
BWindow::MessageReceived(msg);
break;
}
}
}
void
SudokuWindow::MessageReceived(BMessage* message)
{
if (message->WasDropped()) {
_MessageDropped(message);
return;
}
switch (message->what) {
case kMsgOpenFilePanel:
fOpenPanel->Show();
break;
case B_REFS_RECEIVED:
case B_SIMPLE_DATA:
_MessageDropped(message);
break;
case kMsgGenerateSudoku:
{
int32 level;
if (message->FindInt32("level", &level) != B_OK)
level = _Level();
_SetLevel(level);
_Generate(level);
break;
}
case kMsgAbortSudokuGenerator:
if (fGenerator != NULL)
fGenerator->Abort();
break;
case kMsgSudokuGenerated:
{
BMessage archive;
if (message->FindMessage("field", &archive) == B_OK) {
SudokuField* field = new SudokuField(&archive);
fSudokuView->SetTo(field);
}
fSudokuView->SetEditable(true);
fProgressWindow->Stop();
delete fGenerator;
fGenerator = NULL;
break;
}
case kMsgExportAs:
{
if (message->FindInt32("as", (int32 *)&fExportFormat) < B_OK)
fExportFormat = kExportAsText;
fSavePanel->Show();
break;
}
case B_COPY:
fSudokuView->CopyToClipboard();
break;
case B_SAVE_REQUESTED:
{
entry_ref directoryRef;
const char* name;
if (message->FindRef("directory", &directoryRef) != B_OK
|| message->FindString("name", &name) != B_OK)
break;
BDirectory directory(&directoryRef);
BEntry entry(&directory, name);
entry_ref ref;
if (entry.GetRef(&ref) == B_OK)
fSudokuView->SaveTo(ref, fExportFormat);
break;
}
case kMsgNewBlank:
_ResetStoredState();
fSudokuView->ClearAll();
break;
case kMsgStartAgain:
fSudokuView->ClearChanged();
break;
case kMsgMarkInvalid:
case kMsgMarkValidHints:
{
BMenuItem* item;
if (message->FindPointer("source", (void**)&item) != B_OK)
return;
uint32 flag = message->what == kMsgMarkInvalid
? kMarkInvalid : kMarkValidHints;
item->SetMarked(!item->IsMarked());
if (item->IsMarked())
fSudokuView->SetHintFlags(fSudokuView->HintFlags() | flag);
else
fSudokuView->SetHintFlags(fSudokuView->HintFlags() & ~flag);
break;
}
case kMsgStoreState:
delete fStoredState;
fStoredState = new BMessage;
fSudokuView->Field()->Archive(fStoredState, true);
fRestoreStateItem->SetEnabled(true);
break;
case kMsgRestoreState:
{
if (fStoredState == NULL)
break;
SudokuField* field = new SudokuField(fStoredState);
fSudokuView->SetTo(field);
break;
}
case kMsgSudokuSolved:
{
BAlert* alert = new BAlert(B_TRANSLATE("Sudoku request"),
B_TRANSLATE("Sudoku solved - congratulations!\n"),
B_TRANSLATE("OK"), NULL, NULL,
B_WIDTH_AS_USUAL, B_IDEA_ALERT);
alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
alert->Go();
break;
}
case B_OBSERVER_NOTICE_CHANGE:
{
int32 what;
if (message->FindInt32(B_OBSERVE_WHAT_CHANGE, &what) != B_OK)
break;
if (what == kUndoRedoChanged) {
fUndoItem->SetEnabled(fSudokuView->CanUndo());
fRedoItem->SetEnabled(fSudokuView->CanRedo());
}
break;
}
default:
BWindow::MessageReceived(message);
break;
}
}
void
ObjectView::MessageReceived(BMessage* msg)
{
BMenuItem* item = NULL;
bool toggleItem = false;
switch (msg->what) {
case kMsgFPS:
fFps = (fFps) ? false : true;
msg->FindPointer("source", reinterpret_cast<void**>(&item));
item->SetMarked(fFps);
fForceRedraw = true;
setEvent(drawEvent);
break;
case kMsgAddModel:
{
TriangleObject *Tri = new TriangleObject(this);
if (Tri->InitCheck() == B_OK) {
fObjListLock.Lock();
fObjects.AddItem(Tri);
fObjListLock.Unlock();
} else {
BAlert *NoResourceAlert = new BAlert(B_TRANSLATE("Error"),
kNoResourceError, B_TRANSLATE("OK"), NULL, NULL,
B_WIDTH_AS_USUAL, B_OFFSET_SPACING, B_STOP_ALERT);
NoResourceAlert->SetFlags(NoResourceAlert->Flags() | B_CLOSE_ON_ESCAPE);
NoResourceAlert->Go();
delete Tri;
}
setEvent(drawEvent);
break;
}
case kMsgLights:
{
msg->FindPointer("source", reinterpret_cast<void**>(&item));
long lightNum = msg->FindInt32("num");
long color = msg->FindInt32("color");
BMenu *menu = item->Menu();
long index = menu->IndexOf(item);
menu->ItemAt(index)->SetMarked(true);
for (int i = 0; i < menu->CountItems(); i++) {
if (i != index)
menu->ItemAt(i)->SetMarked(false);
}
LockGL();
if (color != lightNone) {
glEnable(GL_LIGHT0 + lightNum - 1);
glLightfv(GL_LIGHT0 + lightNum - 1, GL_SPECULAR,
lights[color].specular);
glLightfv(GL_LIGHT0 + lightNum - 1, GL_DIFFUSE,
lights[color].diffuse);
glLightfv(GL_LIGHT0 + lightNum - 1, GL_AMBIENT,
lights[color].ambient);
} else {
glDisable(GL_LIGHT0 + lightNum - 1);
}
UnlockGL();
fForceRedraw = true;
setEvent(drawEvent);
break;
}
case kMsgGouraud:
fGouraud = !fGouraud;
toggleItem = true;
break;
case kMsgZBuffer:
fZbuf = !fZbuf;
toggleItem = true;
break;
case kMsgCulling:
fCulling = !fCulling;
toggleItem = true;
break;
case kMsgLighting:
fLighting = !fLighting;
toggleItem = true;
break;
case kMsgFilled:
fFilled = !fFilled;
toggleItem = true;
break;
case kMsgPerspective:
fPersp = !fPersp;
toggleItem = true;
break;
case kMsgFog:
fFog = !fFog;
toggleItem = true;
break;
}
if (toggleItem && msg->FindPointer("source", reinterpret_cast<void**>(&item)) == B_OK){
item->SetMarked(!item->IsMarked());
setEvent(drawEvent);
}
BGLView::MessageReceived(msg);
}
void
DevicesView::CreateLayout()
{
BMenuBar* menuBar = new BMenuBar("menu");
BMenu* menu = new BMenu(B_TRANSLATE("Devices"));
BMenuItem* item;
menu->AddItem(new BMenuItem(B_TRANSLATE("Refresh devices"),
new BMessage(kMsgRefresh), 'R'));
menu->AddItem(item = new BMenuItem(B_TRANSLATE("Report compatibility"),
new BMessage(kMsgReportCompatibility)));
item->SetEnabled(false);
menu->AddItem(item = new BMenuItem(B_TRANSLATE(
"Generate system information"), new BMessage(kMsgGenerateSysInfo)));
item->SetEnabled(false);
menu->AddSeparatorItem();
menu->AddItem(new BMenuItem(B_TRANSLATE("Quit"),
new BMessage(B_QUIT_REQUESTED), 'Q'));
menu->SetTargetForItems(this);
item->SetTarget(be_app);
menuBar->AddItem(menu);
fDevicesOutline = new BOutlineListView("devices_list");
fDevicesOutline->SetTarget(this);
fDevicesOutline->SetSelectionMessage(new BMessage(kMsgSelectionChanged));
BScrollView *scrollView = new BScrollView("devicesScrollView",
fDevicesOutline, B_WILL_DRAW | B_FRAME_EVENTS, true, true);
// Horizontal scrollbar doesn't behave properly like the vertical
// scrollbar... If you make the view bigger (exposing a larger percentage
// of the view), it does not adjust the width of the scroll 'dragger'
// why? Bug? In scrollview or in outlinelistview?
BPopUpMenu* orderByPopupMenu = new BPopUpMenu("orderByMenu");
BMenuItem* byCategory = new BMenuItem(B_TRANSLATE("Category"),
new BMessage(kMsgOrderCategory));
BMenuItem* byConnection = new BMenuItem(B_TRANSLATE("Connection"),
new BMessage(kMsgOrderConnection));
byCategory->SetMarked(true);
fOrderBy = byCategory->IsMarked() ? ORDER_BY_CATEGORY :
ORDER_BY_CONNECTION;
orderByPopupMenu->AddItem(byCategory);
orderByPopupMenu->AddItem(byConnection);
fOrderByMenu = new BMenuField(B_TRANSLATE("Order by:"), orderByPopupMenu);
fTabView = new BTabView("fTabView", B_WIDTH_FROM_LABEL);
fBasicTab = new BTab();
fBasicView = new PropertyListPlain("basicView");
fTabView->AddTab(fBasicView, fBasicTab);
fBasicTab->SetLabel(B_TRANSLATE("Basic information"));
fDeviceTypeTab = new BTab();
fBusView = new PropertyListPlain("busView");
fTabView->AddTab(fBusView, fDeviceTypeTab);
fDeviceTypeTab->SetLabel(B_TRANSLATE("Bus"));
fDetailedTab = new BTab();
fAttributesView = new PropertyList("attributesView");
fTabView->AddTab(fAttributesView, fDetailedTab);
fDetailedTab->SetLabel(B_TRANSLATE("Detailed"));
BLayoutBuilder::Group<>(this, B_VERTICAL, 0)
.Add(menuBar)
.AddSplit(B_HORIZONTAL)
.SetInsets(B_USE_ITEM_INSETS)
.AddGroup(B_VERTICAL)
.Add(fOrderByMenu, 1)
.Add(scrollView, 2)
.End()
.Add(fTabView, 2);
}
void
CharacterWindow::MessageReceived(BMessage* message)
{
switch (message->what) {
case B_COPY:
PostMessage(message, fCharacterView);
break;
case kMsgUnicodeBlockSelected:
{
int32 index;
if (message->FindInt32("index", &index) != B_OK
|| index < 0)
break;
BlockListItem* item
= static_cast<BlockListItem*>(fUnicodeBlockView->ItemAt(index));
fCharacterView->ScrollTo(item->BlockIndex());
fFilterControl->MakeFocus();
break;
}
case kMsgCharacterChanged:
{
uint32 character;
if (message->FindInt32("character", (int32*)&character) != B_OK)
break;
char utf8[16];
CharacterView::UnicodeToUTF8(character, utf8, sizeof(utf8));
char utf8Hex[32];
CharacterView::UnicodeToUTF8Hex(character, utf8Hex,
sizeof(utf8Hex));
char text[128];
snprintf(text, sizeof(text), "'%s' Code: %#lx (%ld), UTF-8: %s",
utf8, character, character, utf8Hex);
fCodeView->SetText(text);
break;
}
case kMsgFontSelected:
{
BMenuItem* item;
if (message->FindPointer("source", (void**)&item) != B_OK)
break;
fSelectedFontItem->SetMarked(false);
// If it's the family menu, just select the first style
if (item->Submenu() != NULL)
item = item->Submenu()->ItemAt(0);
if (item != NULL) {
item->SetMarked(true);
fSelectedFontItem = item;
_SetFont(item->Menu()->Name(), item->Label());
}
break;
}
case kMsgFontSizeChanged:
{
int32 size = fFontSizeSlider->Value();
if (size < kMinFontSize)
size = kMinFontSize;
else if (size > kMaxFontSize)
size = kMaxFontSize;
BFont font = fCharacterView->CharacterFont();
font.SetSize(size);
fCharacterView->SetCharacterFont(font);
break;
}
case kMsgPrivateBlocks:
{
BMenuItem* item;
if (message->FindPointer("source", (void**)&item) != B_OK
|| item == NULL)
break;
item->SetMarked(!item->IsMarked());
fCharacterView->ShowPrivateBlocks(item->IsMarked());
fUnicodeBlockView->ShowPrivateBlocks(item->IsMarked());
break;
}
case kMsgContainedBlocks:
{
BMenuItem* item;
if (message->FindPointer("source", (void**)&item) != B_OK
|| item == NULL)
break;
item->SetMarked(!item->IsMarked());
fCharacterView->ShowContainedBlocksOnly(item->IsMarked());
fUnicodeBlockView->ShowContainedBlocksOnly(item->IsMarked());
break;
}
case kMsgFilterChanged:
fUnicodeBlockView->SetFilter(fFilterControl->Text());
fUnicodeBlockView->Select(0);
break;
case kMsgClearFilter:
fFilterControl->SetText("");
fFilterControl->MakeFocus();
break;
default:
BWindow::MessageReceived(message);
break;
}
}
void
ShowImageWindow::MessageReceived(BMessage *message)
{
switch (message->what) {
case MSG_MODIFIED:
// If image has been modified due to a Cut or Paste
fModified = true;
break;
case MSG_OUTPUT_TYPE:
// User clicked Save As then choose an output format
if (!fSavePanel)
// If user doesn't already have a save panel open
_SaveAs(message);
break;
case MSG_SAVE_PANEL:
// User specified where to save the output image
_SaveToFile(message);
break;
case B_CANCEL:
delete fSavePanel;
fSavePanel = NULL;
break;
case MSG_UPDATE_STATUS: {
int32 pages = fImageView->PageCount();
int32 curPage = fImageView->CurrentPage();
bool benable = (pages > 1) ? true : false;
_EnableMenuItem(fBar, MSG_PAGE_FIRST, benable);
_EnableMenuItem(fBar, MSG_PAGE_LAST, benable);
_EnableMenuItem(fBar, MSG_PAGE_NEXT, benable);
_EnableMenuItem(fBar, MSG_PAGE_PREV, benable);
_EnableMenuItem(fBar, MSG_FILE_NEXT, fImageView->HasNextFile());
_EnableMenuItem(fBar, MSG_FILE_PREV, fImageView->HasPrevFile());
if (fGoToPageMenu->CountItems() != pages) {
// Only rebuild the submenu if the number of
// pages is different
while (fGoToPageMenu->CountItems() > 0)
// Remove all page numbers
delete fGoToPageMenu->RemoveItem(0L);
for (int32 i = 1; i <= pages; i++) {
// Fill Go To page submenu with an entry for each page
BMessage *pgomsg = new BMessage(MSG_GOTO_PAGE);
pgomsg->AddInt32("page", i);
char shortcut = 0;
if (i < 10) {
shortcut = '0' + i;
} else if (i == 10) {
shortcut = '0';
}
BString strCaption;
strCaption << i;
BMenuItem *item = new BMenuItem(strCaption.String(), pgomsg,
shortcut);
if (curPage == i)
item->SetMarked(true);
fGoToPageMenu->AddItem(item);
}
} else {
// Make sure the correct page is marked
BMenuItem *pcurItem;
pcurItem = fGoToPageMenu->ItemAt(curPage - 1);
if (!pcurItem->IsMarked()) {
pcurItem->SetMarked(true);
}
}
// Disable the Invert menu item if the bitmap color space
// is B_CMAP8. (B_CMAP8 is currently unsupported by the
// invert algorithm)
color_space colors = B_NO_COLOR_SPACE;
message->FindInt32("colors", reinterpret_cast<int32 *>(&colors));
_EnableMenuItem(fBar, MSG_INVERT, (colors != B_CMAP8));
BString status;
bool messageProvidesSize = false;
if (message->FindInt32("width", &fWidth) >= B_OK
&& message->FindInt32("height", &fHeight) >= B_OK) {
status << fWidth << "x" << fHeight;
messageProvidesSize = true;
}
BString str;
if (message->FindString("status", &str) == B_OK && str.Length() > 0) {
if (status.Length() > 0)
status << ", ";
status << str;
}
if (messageProvidesSize) {
_UpdateResizerWindow(fWidth, fHeight);
if (!fImageView->GetZoomToBounds()
&& !fImageView->GetShrinkToBounds()
&& !fFullScreen)
WindowRedimension(fImageView->GetBitmap());
}
fStatusView->SetText(status);
UpdateTitle();
} break;
case MSG_UPDATE_STATUS_TEXT: {
BString status;
status << fWidth << "x" << fHeight;
BString str;
if (message->FindString("status", &str) == B_OK && str.Length() > 0) {
status << ", " << str;
fStatusView->SetText(status);
}
} break;
case MSG_SELECTION: {
// The view sends this message when a selection is
// made or the selection is cleared so that the window
// can update the state of the appropriate menu items
bool benable;
if (message->FindBool("has_selection", &benable) == B_OK) {
_EnableMenuItem(fBar, B_CUT, benable);
_EnableMenuItem(fBar, B_COPY, benable);
_EnableMenuItem(fBar, MSG_CLEAR_SELECT, benable);
}
} break;
case MSG_UNDO_STATE: {
bool benable;
if (message->FindBool("can_undo", &benable) == B_OK)
_EnableMenuItem(fBar, B_UNDO, benable);
} break;
case MSG_CLIPBOARD_CHANGED: {
// The app sends this message after it examines the clipboard in
// response to a B_CLIPBOARD_CHANGED message
bool bdata;
if (message->FindBool("data_available", &bdata) == B_OK)
_EnableMenuItem(fBar, B_PASTE, bdata);
} break;
case B_UNDO:
fImageView->Undo();
break;
case B_CUT:
fImageView->Cut();
break;
case B_COPY:
fImageView->CopySelectionToClipboard();
break;
case B_PASTE:
fImageView->Paste();
break;
case MSG_CLEAR_SELECT:
fImageView->ClearSelection();
break;
case MSG_SELECT_ALL:
fImageView->SelectAll();
break;
case MSG_PAGE_FIRST:
if (_ClosePrompt())
fImageView->FirstPage();
break;
case MSG_PAGE_LAST:
if (_ClosePrompt())
fImageView->LastPage();
break;
case MSG_PAGE_NEXT:
if (_ClosePrompt())
fImageView->NextPage();
break;
case MSG_PAGE_PREV:
if (_ClosePrompt())
fImageView->PrevPage();
break;
case MSG_GOTO_PAGE: {
if (!_ClosePrompt())
break;
int32 newPage;
if (message->FindInt32("page", &newPage) != B_OK)
break;
int32 curPage = fImageView->CurrentPage();
int32 pages = fImageView->PageCount();
if (newPage > 0 && newPage <= pages) {
BMenuItem* pcurItem = fGoToPageMenu->ItemAt(curPage - 1);
BMenuItem* pnewItem = fGoToPageMenu->ItemAt(newPage - 1);
if (pcurItem && pnewItem) {
pcurItem->SetMarked(false);
pnewItem->SetMarked(true);
fImageView->GoToPage(newPage);
}
}
} break;
case MSG_DITHER_IMAGE:
fImageView->SetDither(_ToggleMenuItem(message->what));
break;
case MSG_SHRINK_TO_WINDOW:
_ResizeToWindow(true, message->what);
break;
case MSG_ZOOM_TO_WINDOW:
_ResizeToWindow(false, message->what);
break;
case MSG_FILE_PREV:
if (_ClosePrompt())
fImageView->PrevFile();
break;
case MSG_FILE_NEXT:
if (_ClosePrompt())
fImageView->NextFile();
break;
case MSG_ROTATE_90:
fImageView->Rotate(90);
break;
case MSG_ROTATE_270:
fImageView->Rotate(270);
break;
case MSG_FLIP_LEFT_TO_RIGHT:
fImageView->Flip(true);
break;
case MSG_FLIP_TOP_TO_BOTTOM:
fImageView->Flip(false);
break;
case MSG_INVERT:
fImageView->Invert();
break;
case MSG_SLIDE_SHOW: {
BMenuItem *item = fBar->FindItem(message->what);
if (!item)
break;
if (item->IsMarked()) {
item->SetMarked(false);
fResizeItem->SetEnabled(true);
fImageView->StopSlideShow();
} else if (_ClosePrompt()) {
item->SetMarked(true);
fResizeItem->SetEnabled(false);
fImageView->StartSlideShow();
}
} break;
case MSG_SLIDE_SHOW_DELAY: {
float value;
if (message->FindFloat("value", &value) == B_OK) {
fImageView->SetSlideShowDelay(value);
// in case message is sent from popup menu
_MarkSlideShowDelay(value);
}
} break;
case MSG_FULL_SCREEN:
_ToggleFullScreen();
break;
case MSG_EXIT_FULL_SCREEN:
if (fFullScreen)
_ToggleFullScreen();
break;
case MSG_SHOW_CAPTION: {
fShowCaption = _ToggleMenuItem(message->what);
ShowImageSettings* settings = my_app->Settings();
if (settings->Lock()) {
settings->SetBool("ShowCaption", fShowCaption);
settings->Unlock();
}
if (fFullScreen)
fImageView->SetShowCaption(fShowCaption);
} break;
case MSG_PAGE_SETUP:
_PageSetup();
break;
case MSG_PREPARE_PRINT:
_PrepareForPrint();
break;
case MSG_PRINT:
_Print(message);
break;
case MSG_ZOOM_IN:
fImageView->ZoomIn();
break;
case MSG_ZOOM_OUT:
fImageView->ZoomOut();
break;
case MSG_ORIGINAL_SIZE:
fImageView->SetZoom(1.0);
break;
case MSG_SCALE_BILINEAR:
fImageView->SetScaleBilinear(_ToggleMenuItem(message->what));
break;
case MSG_OPEN_RESIZER_WINDOW: {
if (fImageView->GetBitmap() != NULL) {
BRect rect = fImageView->GetBitmap()->Bounds();
_OpenResizerWindow(rect.IntegerWidth()+1, rect.IntegerHeight()+1);
}
} break;
case MSG_RESIZE: {
int w = message->FindInt32("w");
int h = message->FindInt32("h");
fImageView->ResizeImage(w, h);
} break;
case MSG_RESIZER_WINDOW_QUIT:
delete fResizerWindowMessenger;
fResizerWindowMessenger = NULL;
break;
case MSG_DESKTOP_BACKGROUND: {
BMessage message(B_REFS_RECEIVED);
message.AddRef("refs", fImageView->Image());
// This is used in the Backgrounds code for scaled placement
message.AddInt32("placement", 'scpl');
be_roster->Launch("application/x-vnd.antares-backgrounds", &message);
} break;
default:
BWindow::MessageReceived(message);
break;
}
}
void
MediaReplicant::MessageReceived(BMessage* message)
{
switch (message->what) {
case kMsgOpenMediaPlayer:
_Launch("MediaPlayer", "application/x-vnd.Haiku-MediaPlayer",
B_SYSTEM_APPS_DIRECTORY, "MediaPlayer");
break;
case kMsgOpenMediaSettings:
_Launch("Media Preferences", "application/x-vnd.Haiku-Media",
B_SYSTEM_PREFERENCES_DIRECTORY, "Media");
break;
case kMsgOpenSoundSettings:
_Launch("Sounds Preferences", "application/x-vnd.Haiku-Sounds",
B_SYSTEM_PREFERENCES_DIRECTORY, "Sounds");
break;
case kMsgToggleBeep:
{
BMenuItem* item;
if (message->FindPointer("source", (void**)&item) != B_OK)
return;
item->SetMarked(!item->IsMarked());
fDontBeep = !item->IsMarked();
break;
}
case kMsgVolumeWhich:
{
BMenuItem* item;
if (message->FindPointer("source", (void**)&item) != B_OK)
return;
item->SetMarked(!item->IsMarked());
fVolumeWhich = item->IsMarked()
? VOLUME_USE_PHYS_OUTPUT : VOLUME_USE_MIXER;
if (VolumeToolTip* tip = dynamic_cast<VolumeToolTip*>(ToolTip()))
tip->SetWhich(fVolumeWhich);
break;
}
case B_MOUSE_WHEEL_CHANGED:
{
float deltaY;
if (message->FindFloat("be:wheel_delta_y", &deltaY) == B_OK
&& deltaY != 0.0) {
MixerControl mixerControl;
mixerControl.Connect(fVolumeWhich);
mixerControl.ChangeVolumeBy(deltaY < 0 ? 6 : -6);
VolumeToolTip* tip = dynamic_cast<VolumeToolTip*>(ToolTip());
if (tip != NULL) {
tip->Update();
ShowToolTip(tip);
}
}
break;
}
default:
BView::MessageReceived(message);
break;
}
}
