Exemple #1
0
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;
}
Exemple #2
0
void
TemplateWindow::MessageReceived(BMessage *msg)
{
	switch (msg->what)
	{
		case M_NAME_CHANGED:
		case M_TARGET_CHANGED:
		{
			if (fNameBox->Text() && strlen(fNameBox->Text()) > 0 &&
				fTargetBox->Text() && strlen(fTargetBox->Text()) > 0)
				fOK->SetEnabled(true);
			else
				fOK->SetEnabled(false);
			break;
		}
		case M_CREATE_PROJECT:
		{
			BMenu *menu = fTemplateField->Menu();
			BMenuItem *item = menu->FindMarked();
			if (!item)
				break;
			
			int32 selection = menu->IndexOf(item);
			ProjectTemplate *ptemp = fTempList.TemplateAt(selection);
			
			BMessage projmsg(M_CREATE_PROJECT),reply;
			projmsg.AddString("name",fNameBox->Text());
			projmsg.AddString("target",fTargetBox->Text());
			projmsg.AddInt32("type",ptemp->TargetType());
			projmsg.AddString("path",fPathBox->Path());
			projmsg.AddString("template", ptemp->GetRef().name);
			projmsg.AddString("pldfile", ptemp->ProjectFileName());
			
			BMenu *scmMenu = fSCMChooser->Menu();
			int32 scm = scmMenu->IndexOf(scmMenu->FindMarked());
			projmsg.AddInt32("scmtype",scm);
			
			if (!ptemp->ProjectFileName())
			{
				for (int32 i = 0; i < ptemp->CountFiles(); i++)
					projmsg.AddRef("refs",ptemp->FileAt(i));
				
				for (int32 i = 0; i < ptemp->CountLibs(); i++)
					projmsg.AddRef("libs",ptemp->LibAt(i));
			}
			
			projmsg.AddBool("createfolder",(fCreateFolder->Value() == B_CONTROL_ON));
			be_app_messenger.SendMessage(&projmsg,&reply);
			PostMessage(B_QUIT_REQUESTED);
			break;
		}
		default:
		{
			DWindow::MessageReceived(msg);
			break;
		}
	}
}
void
Renamer_Remove::DetachedFromWindow()
{
	BMessage msg;
	msg.AddInt32("pos1", fPosition1->Value());
	msg.AddInt32("pos2", fPosition2->Value());

	BMenu* menu = fDirection1->Menu();
	msg.AddBool("direction1", bool(menu->IndexOf(menu->FindMarked())));
	menu = fDirection2->Menu();
	msg.AddBool("direction2", bool(menu->IndexOf(menu->FindMarked())));

	UpdatePreferences("ren_remove", msg);
}
// -------------------------------------------------------------------
void
DRRegrView::MessageReceived(BMessage* theMesg)
{
	BMessage* dispMesg;
	int16 itemChecked;
	BMenu* theMenu;
	
	switch (theMesg->what) {
	
		case apply_change :
			dispMesg = new BMessage(set_display);
			dispMesg->AddInt64(disp_set_name,mKey);
			dispMesg->AddInt16(disp_mark_name,mPlotMark->PlotMark());
			dispMesg->AddInt32(mark_col_name,mColorCtrl->Value());
			theMenu = mLineSelect->Menu();
			itemChecked = theMenu->IndexOf(theMenu->FindMarked());
			dispMesg->AddInt16(disp_line_name,itemChecked);
			be_app->PostMessage(dispMesg);
			delete dispMesg;
			break;
			
		default :
			BView::MessageReceived(theMesg);
	}
}		
Exemple #5
0
int32
GoGoEncoder::GetFormat(char* format) {
	PRINT(("GoGoEncoder::GetFormat(char*)\n"));

	BMenuItem* item;
	BMenu* formatMenu;

	item = menu->FindItem(OUTPUT_FORMAT_STR);
	if (!item) {
		return B_ERROR;
	}
	formatMenu = item->Submenu();
	if (!formatMenu) {
		return B_ERROR;
	}

	item = formatMenu->FindMarked();
	if (!item) {
		return B_ERROR;
	}

	const char* label = item->Label();

	if (strcmp(label, STEREO) == 0) {
		strcpy(format, STEREO_CODE);
	} else if (strcmp(label, MONO) == 0) {
		strcpy(format, MONO_CODE);
	} else if (strcmp(label, JSTEREO) == 0) {
		strcpy(format, JSTEREO_CODE);
	}

	return B_OK;
}
Exemple #6
0
void PecoApp::NoRenamer() {
	if (fRenameMode == MODE_NONE) return;

	fWindow->Lock();
	BMenuField	*myField = (BMenuField *)fWindow->FindView("selectMode");
	BMenu		*myMenu = myField->Menu();
	
	myMenu->FindMarked()->SetMarked(false);

	myField->MenuItem()->SetLabel(STR_PLEASE_SELECT);
	
	BView	*bottomView = fWindow->FindView("bottomView");
	bottomView->RemoveChild((BView *)((PecoApp *)be_app)->fRenamers[fRenameMode]);

	fRenameMode = MODE_NONE;

	float deltaHeight = - be_plain_font->Size()*2 - 40;

	float min_h, max_h, min_v, max_v;
	fWindow->GetSizeLimits( &min_h, &max_h, &min_v, &max_v );
	fWindow->SetSizeLimits( min_h, max_h, min_v + deltaHeight, max_v );

	fWindow->FindView("topView")->SetResizingMode(0);
	fWindow->FindView("bottomView")->SetResizingMode(B_FOLLOW_TOP_BOTTOM);	
	fWindow->ResizeBy(0, deltaHeight);
	fWindow->FindView("topView")->SetResizingMode(B_FOLLOW_TOP_BOTTOM);
	fWindow->FindView("bottomView")->SetResizingMode(B_FOLLOW_BOTTOM);	

	fWindow->Unlock();

}
/***********************************************************
 * Attribute
 ***********************************************************/
int32
HCriteriaView::Attribute() const
{
	BMenu *menu = fAttrMenu->Menu();
	BMenuItem *item = menu->FindMarked();
	if(item)
		return menu->IndexOf(item);
	return 0;	
}
/***********************************************************
 * Operator2
 ***********************************************************/
int32
HCriteriaView::Operator2() const
{
	BMenu *menu = fOp2Menu->Menu();
	BMenuItem *item = menu->FindMarked();
	if(item)
		return menu->IndexOf(item);
	return 0;	
}
/***********************************************************
 * AccountName
 ***********************************************************/
const char*
HAddressView::AccountName()
{
	BMenuField *field = cast_as(FindView("FromMenu"),BMenuField);
	BMenu *menu = field->Menu();
	BMenuItem *item = menu->FindMarked();
	if(!item)
		return NULL;
	return item->Label();
}
Exemple #10
0
void
PreferenceFont::MessageReceived (BMessage *msg)
{
	switch (msg->what)
	{
		case M_FONT_CHANGE:
		{
			const char *family, *style;
			BMenuItem *item;
			int32 which;

			msg->FindInt32 ("which", &which);

			// Unmark
			for (int32 i = 0; i < clientFont[which]->Menu()->CountItems(); ++i)
			{
				BMenu *menu (clientFont[which]->Menu()->SubmenuAt (i));

				if ((item = menu->FindMarked()) != 0)
				{
					item->SetMarked (false);
					break;
				}
			}

			msg->FindPointer ("source", reinterpret_cast<void **>(&item));
			item->SetMarked (true);

			msg->FindString ("family", &family);
			msg->FindString ("style", &style);

			clientFont[which]->MenuItem()->SetLabel (family);
			bowser_app->ClientFontFamilyAndStyle (which, family, style);
			break;
		}

		case M_FONT_SIZE_CHANGE:
		{
			int32 which, size;

			msg->FindInt32 ("which", &which);
			msg->FindInt32 ("size", &size);
			bowser_app->ClientFontSize (which, size);
		}

		default:
			BView::MessageReceived (msg);
	}
}
void T9InputServerMethod::SetMode(T9Mode mode)
{
  BAutolock l(fLocker);
  BMenuItem *item;
  // XXX: check
  fMode = mode;
  item = fDeskbarMenu->FindMarked();
  if (item)
    item->SetMarked(false);
  item = fDeskbarMenu->ItemAt((int32)mode);
  if (item)
    item->SetMarked(true);
  // necessary to update the copy used by the Deskbar icon.
  SetMenu(fDeskbarMenu, BMessenger(this));
}
void
ControlView::_DeselectOldItems()
{
    BMenuItem* oldItem = fFontFamilyMenu->FindMarked();
    if (oldItem) {
        oldItem->SetMarked(false);

        BMenu* submenu = oldItem->Submenu();
        if (submenu) {
            BMenuItem* marked = submenu->FindMarked();
            if (marked)
                marked->SetMarked(false);
        }
    }
}
ArpFont ArpFontControl::Font() const
{
	ArpFont				f;
	if (!mFontCtrl || !mSizeCtrl) return f;
	BMenu*				m = mFontCtrl->Menu();
	if (!m) return f;
	BMenuItem*			item = m->FindMarked();
	if (!item) return f;
	const BString16*	lbl = item->Label();
	if (lbl) {
		BString16		s(*lbl);
		f.SetFamilyAndStyle(&s);
	}
	f.SetSize(float(mSizeCtrl->Value()));
	return f;
}
void
AddPrinterDialog::_HandleChangedTransport(BMessage *msg)
{
	BString name;
	if (msg->FindString("name", &name) != B_OK) {
		name = "";
	}
	fTransportText = name;

	BString path;
	if (msg->FindString("path", &path) == B_OK) {
		// transport path selected
		fTransportPathText = path;

		// mark sub menu
		void* pointer;
		if (msg->FindPointer("source", &pointer) == B_OK) {
			BMenuItem* item = (BMenuItem*)pointer;

			// Update printer name with Transport Path if not filled in
			if (strlen(fName->Text()) == 0)
				fName->SetText(item->Label());

			BMenu* menu = item->Menu();
			int32 index = fTransport->IndexOf(menu);
			item = fTransport->ItemAt(index);
			if (item != NULL)
				item->SetMarked(true);
		}
	} else {
		// transport selected
		fTransportPathText = "";

		// remove mark from item in sub menu of transport sub menu
		for (int32 i = fTransport->CountItems() - 1; i >= 0; i --) {
			BMenu* menu = fTransport->SubmenuAt(i);
			if (menu != NULL) {
				BMenuItem* item = menu->FindMarked();
				if (item != NULL)
					item->SetMarked(false);
			}
		}
	}
	_Update();
}
Exemple #15
0
/*! \brief Gets the currently selected option.
	\param outName A pointer to a string which will held the option's name.
	\param outValue A pointer to an integer which will held the option's value.
	\return The index of the selected option.
*/
int32
BOptionPopUp::SelectedOption(const char **outName, int32 *outValue) const
{
	BMenu *menu = fMenuField->Menu();
	if (menu != NULL) {
		BMenuItem *marked = menu->FindMarked();
		if (marked != NULL) {
			if (outName != NULL)
				*outName = marked->Label();
			if (outValue != NULL)
				marked->Message()->FindInt32("be:value", outValue);
			
			return menu->IndexOf(marked);
		}
	}
	
	return B_ERROR;
}
Exemple #16
0
int HDialog::GetValue(const char *id) const
{
	BView *v = FindView(id);
	if (v == NULL) THROW(("View '%s' not found", id));

		// according to stroustrup I shouldn't do this:

	if (typeid(*v) == typeid(BMenuField))
	{
		BMenu *menu = static_cast<BMenuField*>(v)->Menu();
		return std::max(menu->IndexOf(menu->FindMarked()) + 1, (int32)1);
	}
	else if (typeid(*v) == typeid(BTextControl))
		return atoi(GetText(id));
	else if (typeid(*v) == typeid(BSlider))
		return static_cast<BSlider*>(v)->Value();

	THROW(("view '%s' not of valid type", id));
	return 0;
} // HDialog::GetValue
void AmProgramChangeView::SetTrackRef(AmTrackRef trackRef)
{
	mTrackRef = trackRef;
	BMenu*	menu = Menu();
	if (!menu) return;
	int32			oldIndex = -1;
	BMenuItem*		item = menu->FindMarked();
	if (item) oldIndex = menu->IndexOf(item);
	menu->RemoveItems(0, menu->CountItems(), true);
	if (!mTrackRef.IsValid() ) return;

	// READ TRACK BLOCK
	#ifdef AM_TRACE_LOCKS
	printf("AmProgramChangeView::SetTrackRef() read lock\n");
	#endif
	const AmSong*	song = ReadLock();
	const AmTrack*	track = song ? song->Track( mTrackRef ) : 0;
	if (track) BuildMenu(track, menu, oldIndex);
	ReadUnlock(song);
	// END READ TRACK BLOCK
}
Exemple #18
0
/***********************************************************
 * Destructor
 ***********************************************************/
HAddressView::~HAddressView()
{
	// Save send account
	int32 smtp_account;
	BMenuField *field = cast_as(FindView("FromMenu"),BMenuField);
	BMenu *menu = field->Menu();
	smtp_account = menu->IndexOf(menu->FindMarked());
	((HApp*)be_app)->Prefs()->SetData("smtp_account",smtp_account);
	
	// free memories
	int32 count = fAddrList.CountItems();
	while(count>0)
	{
		char *p = (char*)fAddrList.RemoveItem(--count);
		if(p)
			free(p);
	}
	fTo->SetModificationMessage(NULL);
	fCc->SetModificationMessage(NULL);
	fBcc->SetModificationMessage(NULL);
	fSubject->SetModificationMessage(NULL);
}
Exemple #19
0
int32
OggEncoder::GetBitrate(char* bitrate) {
	PRINT(("OggEncoder::GetBitrate(char*)\n"));

	BMenuItem* item;
	BMenu* bitrateMenu;

	item = menu->FindItem(BITRATE_STR);
	if (!item) {
		return B_ERROR;
	}
	bitrateMenu = item->Submenu();
	if (!bitrateMenu) {
		return B_ERROR;
	}

	item = bitrateMenu->FindMarked();
	if (!item) {
		return B_ERROR;
	}

	const char* label = item->Label();
	if (strcmp(label, _112KBPS) == 0) {
		strcpy(bitrate, "112");
	} else if (strcmp(label, _128KBPS) == 0) {
		strcpy(bitrate, "128");
	} else if (strcmp(label, _160KBPS) == 0) {
		strcpy(bitrate, "160");
	} else if (strcmp(label, _192KBPS) == 0) {
		strcpy(bitrate, "192");
	} else if (strcmp(label, _256KBPS) == 0) {
		strcpy(bitrate, "256");
	} else if (strcmp(label, _350KBPS) == 0) {
		strcpy(bitrate, "350");
	}

	return B_OK;
}
Exemple #20
0
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;
		}
	}
}
Exemple #21
0
TemplateWindow::TemplateWindow(const BRect &frame)
	:	DWindow(frame,TR("Choose a Project Type"),B_TITLED_WINDOW, B_ASYNCHRONOUS_CONTROLS |
				B_NOT_V_RESIZABLE)
{
	RegisterWindow();
	
	MakeCenteredOnShow(true);
	
	CheckTemplates();
	
	DPath templatePath(gAppPath.GetFolder());
	templatePath << TR("Templates");
	fTempList.ScanFolder(templatePath.GetFullPath());
	
	BView *top = GetBackgroundView();
	
	if (Bounds().Height() < 100)
		ResizeTo(Bounds().Width(),100);
	if (Bounds().Width() < 100)
		ResizeTo(100,Bounds().Height());
	
	BRect r(Bounds());
	BRect bounds(r);
	
	float divider = be_plain_font->StringWidth(TR("Source Control:")) + 5.0;
	
	BMenu *menu = new BMenu("Project Type");
	for (int32 i = 0; i < fTempList.CountTemplates(); i++)
	{
		ProjectTemplate *ptemp = fTempList.TemplateAt(i);
		entry_ref ref = ptemp->GetRef();
		menu->AddItem(new BMenuItem(ref.name,new BMessage(M_TEMPLATE_SELECTED)));
	}
	
	menu->SetRadioMode(true);
	menu->SetLabelFromMarked(true);
	menu->ItemAt(0L)->SetMarked(true);
	
	font_height fh;
	be_plain_font->GetHeight(&fh);
	float fontHeight = fh.ascent + fh.descent + fh.leading;
	r.bottom = MAX(fontHeight,20.0);
	
	r.OffsetBy(10,10);
	fTemplateField = new BMenuField(r,"templatefield",TR("Project Type: "), menu);
	fTemplateField->SetDivider(be_plain_font->StringWidth(TR("Project Type:")) + 5);
	top->AddChild(fTemplateField);
	
	// controls for the options for all project types
	r.OffsetBy(0,r.IntegerHeight() + 10);
	fNameBox = new AutoTextControl(r,"namebox",TR("Project Name:"),NULL,
									new BMessage(M_NAME_CHANGED),
									B_FOLLOW_LEFT_RIGHT | B_FOLLOW_TOP);
	top->AddChild(fNameBox);
	fNameBox->ResizeToPreferred();
	r.bottom = r.top + fNameBox->Bounds().Height();
	fNameBox->ResizeTo(bounds.Width() - 20.0,r.Height());
	fNameBox->SetDivider(divider);
	SetToolTip(fNameBox, "The name of your project. It can be the same as the Target Name, "
						"but it does not have to be.");
	
	r.OffsetBy(0,r.IntegerHeight() + 10);
	fTargetBox = new AutoTextControl(r,"targetbox",TR("Target Name:"),"BeApp",
									new BMessage(M_TARGET_CHANGED),
									B_FOLLOW_LEFT_RIGHT | B_FOLLOW_TOP);
	top->AddChild(fTargetBox);
	fTargetBox->ResizeToPreferred();
	r.bottom = r.top + fTargetBox->Bounds().Height();
	fTargetBox->ResizeTo(bounds.Width() - 20.0,r.Height());
	fTargetBox->SetDivider(divider);
	SetToolTip(fTargetBox, "The name of the compiled application or library");
	
	if (!BEntry(PROJECT_PATH).Exists())
		create_directory(PROJECT_PATH,0777);
	
	r.OffsetBy(0,r.Height() + 10);
	fPathBox = new PathBox(r,"pathbox",gProjectPath.GetFullPath(),TR("Location:"),
							B_FOLLOW_LEFT_RIGHT | B_FOLLOW_TOP);
	top->AddChild(fPathBox);
	fPathBox->ResizeToPreferred();
	r.bottom = r.top + fPathBox->Bounds().Height();
	fPathBox->ResizeTo(bounds.Width() - 20.0,r.Height());
	fPathBox->SetDivider(divider);
	SetToolTip(fPathBox, "Set the location for your project.");
	
	menu = new BMenu("SCM Chooser");
	menu->AddItem(new BMenuItem("Mercurial", new BMessage()));
	menu->AddItem(new BMenuItem("Git", new BMessage()));
	menu->AddItem(new BMenuItem("Subversion", new BMessage()));
	menu->AddItem(new BMenuItem("None", new BMessage()));
	
	if (!gHgAvailable)
	{
		menu->ItemAt(0)->SetEnabled(false);
		menu->ItemAt(0)->SetLabel("Mercurial Unavailable");
	}
	
	if (!gGitAvailable)
	{
		menu->ItemAt(1)->SetEnabled(false);
		menu->ItemAt(1)->SetLabel("Git Unavailable");
	}
	
	if (!gSvnAvailable)
	{
		menu->ItemAt(2)->SetEnabled(false);
		menu->ItemAt(2)->SetLabel("Subversion Unavailable");
	}
	
	
	r.OffsetBy(0,r.Height() + 5.0);
	fSCMChooser = new BMenuField(r, "scmchooser", "Source Control: ", menu);
	top->AddChild(fSCMChooser);
	fSCMChooser->SetDivider(divider);
	SetToolTip(fSCMChooser, "Choose the source control manager for your project, if any.");
	
	menu->SetLabelFromMarked(true);
	menu->ItemAt(gDefaultSCM)->SetMarked(true);
	
	BMenuItem *item = menu->FindMarked();
	if (!item->IsEnabled())
	{
		item->SetMarked(false);
		for (int32 i = 0; i < menu->CountItems(); i++)
		{
			if (menu->ItemAt(i)->IsEnabled())
			{
				menu->ItemAt(i)->SetMarked(true);
				break;
			}
		}
	}
	menu->SetLabelFromMarked(true);
	
	r.OffsetBy(0,r.Height() + 5.0);
	fCreateFolder = new BCheckBox(r,"createfolder",TR("Create Project Folder"),NULL);
	fCreateFolder->MoveTo(divider + 10.0, r.top);
	fCreateFolder->SetValue(B_CONTROL_ON);
	top->AddChild(fCreateFolder);
	SetToolTip(fCreateFolder, "If checked, a folder for your project will be created "
							"in the folder in the Location box above.");
	
	r.OffsetBy(0,r.Height() + 5.0);
	fOK = new BButton(r,"ok",TR("Create Project…"), new BMessage(M_CREATE_PROJECT));
	fOK->ResizeToPreferred();
	top->AddChild(fOK);
	fOK->SetEnabled(false);
	fOK->MakeDefault(true);
	
	float offset = fPathBox->Divider();
	fOK->MoveBy(offset,0);
	
	float minwidth = Bounds().Width();
	float minheight = fOK->Frame().bottom + 10.0;
	SetSizeLimits(minwidth,30000,minheight,30000);
	
	gSettings.Lock();
	BRect savedframe;
	if (gSettings.FindRect("template_frame",&savedframe) == B_OK)
		ResizeTo(savedframe.Width(),savedframe.Height());
	else
		ResizeTo(minwidth,minheight);
	gSettings.Unlock();
		
	fNameBox->MakeFocus(true);
}
Exemple #22
0
int32
GoGoEncoder::GetBitrate(char* bitrate, bool* vbr) {
	PRINT(("GoGoEncoder::GetBitrate(char*,bool*)\n"));

	BMenuItem* item;
	BMenu* bitrateMenu;

	item = menu->FindItem(BITRATE_STR);
	if (!item) {
		return B_ERROR;
	}
	bitrateMenu = item->Submenu();
	if (!bitrateMenu) {
		return B_ERROR;
	}

	item = bitrateMenu->FindMarked();
	if (!item) {
		return B_ERROR;
	}

	const char* label = item->Label();
	if (strcmp(label, _32KBPS) == 0) {
		*vbr = false;
		strcpy(bitrate, "32");
	}
	if (strcmp(label, _48KBPS) == 0) {
		*vbr = false;
		strcpy(bitrate, "48");
	}
	if (strcmp(label, _64KBPS) == 0) {
		*vbr = false;
		strcpy(bitrate, "64");
	} else if (strcmp(label, _96KBPS) == 0) {
		*vbr = false;
		strcpy(bitrate, "96");
	} else if (strcmp(label, _128KBPS) == 0) {
		*vbr = false;
		strcpy(bitrate, "128");
	} else if (strcmp(label, _160KBPS) == 0) {
		*vbr = false;
		strcpy(bitrate, "160");
	} else if (strcmp(label, _192KBPS) == 0) {
		*vbr = false;
		strcpy(bitrate, "192");
	} else if (strcmp(label, _256KBPS) == 0) {
		*vbr = false;
		strcpy(bitrate, "256");
	} else if (strcmp(label, _320KBPS) == 0) {
		*vbr = false;
		strcpy(bitrate, "320");
	} else if (strcmp(label, VBR_0) == 0) {
		*vbr = true;
		strcpy(bitrate, "0");
	} else if (strcmp(label, VBR_1) == 0) {
		*vbr = true;
		strcpy(bitrate, "1");
	} else if (strcmp(label, VBR_2) == 0) {
		*vbr = true;
		strcpy(bitrate, "2");
	} else if (strcmp(label, VBR_3) == 0) {
		*vbr = true;
		strcpy(bitrate, "3");
	} else if (strcmp(label, VBR_4) == 0) {
		*vbr = true;
		strcpy(bitrate, "4");
	} else if (strcmp(label, VBR_5) == 0) {
		*vbr = true;
		strcpy(bitrate, "5");
	} else if (strcmp(label, VBR_6) == 0) {
		*vbr = true;
		strcpy(bitrate, "6");
	} else if (strcmp(label, VBR_7) == 0) {
		*vbr = true;
		strcpy(bitrate, "7");
	} else if (strcmp(label, VBR_8) == 0) {
		*vbr = true;
		strcpy(bitrate, "8");
	} else if (strcmp(label, VBR_9) == 0) {
		*vbr = true;
		strcpy(bitrate, "9");
	}

	return B_OK;
}
Exemple #23
0
void
ChatWindow::MessageReceived( BMessage * msg )
{
	switch ( msg->what )
	{
		case IM::SETTINGS_UPDATED: {
			if (msg->FindString("people_handler", &fPeopleHandler) != B_OK) {
				fPeopleHandler = kDefaultPeopleHandler;
			};
			
			RebuildDisplay();
		} break;
		case IM::USER_STOPPED_TYPING: {
			BMessage im_msg(IM::MESSAGE);
			im_msg.AddInt32("im_what",IM::USER_STOPPED_TYPING);
			im_msg.AddRef("contact",&fEntry);
			fMan->SendMessage(&im_msg);
			
			stopSelfTypingTimer();
		} break;
		case IM::USER_STARTED_TYPING: {
			BMessage im_msg(IM::MESSAGE);
			im_msg.AddInt32("im_what", IM::USER_STARTED_TYPING);
			im_msg.AddRef("contact", &fEntry);
			fMan->SendMessage(&im_msg);
			
			startSelfTypingTimer();
		} break;
		case IM::DESKBAR_ICON_CLICKED:
		{ // deskbar icon clicked, move to current workspace and activate
			SetWorkspaces( 1 << current_workspace() );
			Activate();
		}	break;
		
		case IM::ERROR:
		case IM::MESSAGE:
		{
			entry_ref contact;
			
			if ( msg->FindRef("contact",&contact) != B_OK )
				return;
				
			if ( contact != fEntry )
				// message not for us, skip it.
				return;
			
			int32 im_what=IM::ERROR;
			
			if ( msg->FindInt32("im_what",&im_what) != B_OK )
				im_what = IM::ERROR;
			
//			int32 old_sel_start, old_sel_end;
			
			char timestr[10];
			time_t now = time(NULL);
			strftime(timestr, sizeof(timestr),"[%H:%M]: ", localtime(&now) );
				
			switch ( im_what )
			{
				case IM::STATUS_CHANGED:
				{
					// This means we're rebuilding menus we don't rally need to rebuild..
					BuildProtocolMenu();
				}	break;
				
				case IM::MESSAGE_SENT:
				{
					fText->Append(timestr, C_TIMESTAMP, C_TIMESTAMP, F_TIMESTAMP);

					BString message;
					msg->FindString("message", &message);
					if (message.Compare("/me ", 4) == 0) {
						fText->Append(_T("* You "), C_ACTION, C_ACTION, F_ACTION);
						message.Remove(0, 4);
						fText->Append(message.String(), C_ACTION, C_ACTION, F_ACTION);
					} else {
						fText->Append(_T("You say: "), C_OWNNICK, C_OWNNICK, F_TEXT);
						//fText->Append(msg->FindString("message"), C_TEXT, C_TEXT, F_TEXT);
					    emoticor->AddText(fText,msg->FindString("message"), C_TEXT, F_TEXT,C_TEXT,F_EMOTICON); //by xeD

					}
					fText->Append("\n", C_TEXT, C_TEXT, F_TEXT);
					fText->ScrollToSelection();
				}	break;
				
				case IM::ERROR:
				{
					BMessage error;
					msg->FindMessage("message", &error);
					
					int32 error_what = -1;
					
					error.FindInt32("im_what", &error_what );
					
					if ( error_what != IM::USER_STARTED_TYPING && 
						 error_what != IM::USER_STOPPED_TYPING )
					{ // ignore messages du to typing
						fText->Append(timestr, C_TIMESTAMP, C_TIMESTAMP, F_TIMESTAMP);
						fText->Append("Error: ", C_TEXT, C_TEXT, F_TEXT);
						fText->Append(msg->FindString("error"), C_TEXT, C_TEXT, F_TEXT);
						fText->Append("\n", C_TEXT, C_TEXT, F_TEXT);
					
						if (!IsActive()) startNotify();
					}
				}	break;
				
				case IM::MESSAGE_RECEIVED:
				{
					if ( msg->FindString("message") == NULL )
					{ // no message to display, probably opened by user
						return;
					}
					
					fText->Append(timestr, C_TIMESTAMP, C_TIMESTAMP, F_TIMESTAMP);
					
					BString protocol = msg->FindString("protocol");
					BString message = msg->FindString("message");
					
					
										
					if (protocol.Length() > 0) {
						fName.ReplaceAll("$protocol$",protocol.String());
					} else {
						fName.ReplaceAll("$protocol$"," ");
					};
					
					if (message.Compare("/me ", 4) == 0) {
						fText->Append("* ", C_ACTION, C_ACTION, F_ACTION);
						fText->Append(fName.String(), C_ACTION, C_ACTION, F_ACTION);
						fText->Append(" ", C_ACTION, C_ACTION, F_ACTION);
						message.Remove(0, 4);
						fText->Append(message.String(), C_ACTION, C_ACTION, F_ACTION);
					} else {
						fText->Append(fName.String(), C_OTHERNICK, C_OTHERNICK, F_TEXT);
						fText->Append(": ", C_OTHERNICK, C_OTHERNICK, F_TEXT);
						emoticor->AddText(fText,msg->FindString("message"), C_TEXT, F_TEXT,C_TEXT,F_EMOTICON); //by xeD

					}
					fText->Append("\n", C_TEXT, C_TEXT, F_TEXT);
					fText->ScrollToSelection();

					if (!IsActive()) startNotify();
					
					stopTypingTimer();
				}	break;
				
				case IM::CONTACT_STARTED_TYPING: {	
					startTypingTimer();
				} break;
				
				case IM::CONTACT_STOPPED_TYPING: {
					stopTypingTimer();
				} break;
				
			}
			
			fText->ScrollToSelection();
			
		}	break;
		
		case SEND_MESSAGE:
		{
			if (fInput->TextLength() == 0) return;
			BMessage im_msg(IM::MESSAGE);
			im_msg.AddInt32("im_what",IM::SEND_MESSAGE);
			im_msg.AddRef("contact",&fEntry);
			im_msg.AddString("message", fInput->Text() );
			
			BMenu *menu = fProtocolMenu->Menu();
			if (menu) {
				IconMenuItem *item = dynamic_cast<IconMenuItem*>(menu->FindMarked());
				if ( item )
				{
					BString connection = item->Extra();
					if (connection.Length() > 0) 
					{
						IM::Connection conn(connection.String());
						
						im_msg.AddString("protocol", conn.Protocol());
						im_msg.AddString("id", conn.ID());
					}
				}	
			};
			
			if ( fMan->SendMessage(&im_msg) == B_OK ) {
				fInput->SetText("");
			} else {
				LOG("im_emoclient", liHigh, "Error sending message to im_server");

				fText->Append(_T("Error: im_server not running, can't send message\n"), C_TEXT, C_TEXT, F_TEXT);
					
				fText->ScrollToSelection();
			};
		}	break;
		
		case SHOW_INFO:
		{
			BMessage open_msg(B_REFS_RECEIVED);
			open_msg.AddRef("refs", &fEntry);
			
			be_roster->Launch(fPeopleHandler.String(), &open_msg);
		}	break;
		
		case VIEW_LOG: {
			BMessage open(B_REFS_RECEIVED);
			open.AddRef("refs", &fEntry);
			be_roster->Launch("application/x-vnd.BeClan.im_binlog_viewer", &open);
		} break;
		
		case VIEW_WEBPAGE: {
			entry_ref htmlRef;
			be_roster->FindApp("application/x-vnd.Be.URL.http", &htmlRef);
			BPath htmlPath(&htmlRef);

			BMessage argv(B_ARGV_RECEIVED);
			argv.AddString("argv", htmlPath.Path());

			int32 length = -1;
			char *url = ReadAttribute(BNode(&fEntry), "META:url", &length);
			if ((url != NULL) && (length > 1)) {
				url = (char *)realloc(url, (length + 1) * sizeof(char));
				url[length] = '\0';
				
				argv.AddString("argv", url);	
				argv.AddInt32("argc", 2);
	
				be_roster->Launch(&htmlRef, &argv);
			} else {
				LOG("im_emoclient", liMedium, "Contact had no homepage");
			};
			
			if (url) free(url);
		} break;
		case VIEW_EMOTICONS: {
			//find emoticon button
 			BView* button = FindView("Emoticons");
 			BRect buttonBounds = button->Bounds();
 			//move emoticon window to just below the button
 			BPoint emotLeftBottom = button->ConvertToScreen(buttonBounds.LeftBottom());
 				
 			popup->SetTargetForItems(this);	
			popup->Go(emotLeftBottom,true,true);
			
		} break;
		case ADD_EMOTICON:
		{
			
			int32 index=msg->FindInt32("index");
			BString txt;
			emoticor->config->menu.FindString("face",index,&txt);
			txt << " ";
			fInput->Insert(txt.String());
		} break;
		case EMAIL:
		{
			BMessage open_msg(B_REFS_RECEIVED);
			open_msg.AddRef("refs", &fEntry);
			// "application/x-vnd.Be-MAIL"
			be_roster->Launch("text/x-email", &open_msg );
		}	break;
		
		case BLOCK:
		{
			IM::Contact contact(fEntry);
			
			char status[256];
			
			if ( contact.GetStatus( status, sizeof(status) ) != B_OK )
				status[0] = 0;
			
			if ( strcmp(status, BLOCKED_TEXT) == 0 )
			{ // already blocked, unblocked
				contact.SetStatus(OFFLINE_TEXT);
				
				BMessage update_msg(IM::UPDATE_CONTACT_STATUS);
				update_msg.AddRef("contact", &fEntry);
				
				fMan->SendMessage( &update_msg );
			} else
			{
				if ( contact.SetStatus(BLOCKED_TEXT) != B_OK )
				{
					LOG("im_emoclient", liHigh, "Block: Error setting contact status");
				}
			}
		}	break;
		
		case AUTH:
		{
			BMessage auth_msg(IM::MESSAGE);
			auth_msg.AddInt32("im_what", IM::REQUEST_AUTH);
			auth_msg.AddRef("contact", &fEntry);
			
			fMan->SendMessage( &auth_msg );
		}	break;
		
		case B_NODE_MONITOR:
		{
			int32 opcode=0;
			
			if ( msg->FindInt32("opcode",&opcode) != B_OK )
				return;
			
			switch ( opcode )
			{
				case B_ENTRY_REMOVED: {
					// oops. should we close down this window now?
					// Nah, we'll just disable everything.
					fInput->MakeEditable(false);
					fInput->SetViewColor( 198,198,198 );
					fInput->Invalidate();
					
					BString title( Title() );
					title += " - DELETED!";
					SetTitle( title.String() );
				}	break;
				case B_ENTRY_MOVED:
				{
					entry_ref ref;
					
					msg->FindInt32("device", &ref.device);
					msg->FindInt64("to directory", &ref.directory);
					ref.set_name( msg->FindString("name") );
					
					fEntry = ref;
					
					BEntry entry(&fEntry);
					if ( !entry.Exists() )
					{
						LOG("im_emoclient", liHigh, "Entry moved: New entry invalid");
					}
				}	break;
				case B_STAT_CHANGED:
				case B_ATTR_CHANGED:
					reloadContact();
					BuildProtocolMenu();
					break;
			}
		}	break;
		
		case kResizeMessage: {
			BView *view = NULL;
			msg->FindPointer("view", reinterpret_cast<void**>(&view));
			if (dynamic_cast<BScrollView *>(view)) {
				BPoint point;
				msg->FindPoint("loc", &point);
				
				fResize->MoveTo(fResize->Frame().left, point.y);
				
				fTextScroll->ResizeTo(fTextScroll->Frame().Width(), point.y - 1 - fDock->Frame().Height() - 1);
				
				fInputScroll->MoveTo(fInputScroll->Frame().left, point.y + 3);
				fInputScroll->ResizeTo( 
					fInputScroll->Bounds().Width(),
					fStatusBar->Frame().top - fInputScroll->Frame().top
				);
				fInput->SetTextRect(fInput->Bounds());
				fInput->ScrollToSelection();
				
				if ( fSendButton )
				{
					fSendButton->MoveTo(fSendButton->Frame().left, point.y + 3);
					fSendButton->ResizeTo( 
						fSendButton->Bounds().Width(),
						fStatusBar->Frame().top - fSendButton->Frame().top
					);
				}
			};
		} break;
		
		case B_MOUSE_WHEEL_CHANGED: {
			fText->MessageReceived(msg);
		} break;
		
		case B_COPY: {
			int32 start = 0;
			int32 end = 0;
			
			fInput->GetSelection(&start, &end);
			
			//printf("%ld - > %ld\n", start, end);
		} break;
		
		case B_SIMPLE_DATA: {
			entry_ref ref;
			BNode node;
//			attr_info info;
			
			for (int i = 0; msg->FindRef("refs", i, &ref) == B_OK; i++) {
				node = BNode(&ref);
				
				char *type = ReadAttribute(node, "BEOS:TYPE");
				if (strcmp(type, "application/x-person") == 0) {
					char *name = ReadAttribute(node, "META:name");
					char *nickname = ReadAttribute(node, "META:nickname");
					char connection[100];
					IM::Contact con(ref);
					con.ConnectionAt(0, connection);

					if (fInput->TextLength() > 0) fInput->Insert("\n");
					fInput->Insert(name);
					fInput->Insert(" (");
					fInput->Insert(nickname);
					fInput->Insert("): ");
					fInput->Insert(connection);

					free(name);
					free(nickname);
				};
				free(type);
			};
			fInput->ScrollToOffset(fInput->TextLength());
		} break;
		
		case CLEAR_TYPING:
			stopTypingTimer();
			break;
		
		case PROTOCOL_SELECTED: {
			// a protocol has been selected. Since BMenuField doesn't resize until later,
			// we have to wait 1000us before actually responding to the change, see below
			if ( fProtocolHack )
				delete fProtocolHack;
			BMessage protoHack(PROTOCOL_SELECTED2);
			fProtocolHack = new BMessageRunner( BMessenger(this), &protoHack, 1000, 1 );
		}	break;
		
		case PROTOCOL_SELECTED2:
			// do what should be done on protocol change
			fStatusBar->PositionViews();
			fInfoView->ResizeTo(
				fStatusBar->Bounds().Width() - fInfoView->Frame().left,
				fInfoView->Bounds().Height()
			);
			break;
		
		default:
			BWindow::MessageReceived(msg);
	}
}
Exemple #24
0
void
EthernetSettingsView::_ShowConfiguration(Settings* settings)
{
    fCurrentSettings = settings;

    // Clear the inputs.
    fIPTextControl->SetText("");
    fGatewayTextControl->SetText("");
    fNetMaskTextControl->SetText("");
    fPrimaryDNSTextControl->SetText("");
    fSecondaryDNSTextControl->SetText("");
    fDomainTextControl->SetText("");

    fDeviceMenuField->SetEnabled(settings != NULL);
    fTypeMenuField->SetEnabled(settings != NULL);

    bool enableControls = false;
    BMenuItem* item;

    if (settings == NULL || settings->IsDisabled())
        item = fTypeMenuField->Menu()->FindItem(B_TRANSLATE("Disabled"));
    else if (settings->AutoConfigure())
        item = fTypeMenuField->Menu()->FindItem(B_TRANSLATE("DHCP"));
    else {
        item = fTypeMenuField->Menu()->FindItem(B_TRANSLATE("Static"));
        enableControls = true;
    }
    if (item != NULL)
        item->SetMarked(true);

    if (settings == NULL) {
        if (!fNetworkMenuField->IsHidden(fNetworkMenuField))
            fNetworkMenuField->Hide();
        _EnableTextControls(false);
        return;
    }

    // Show/hide networks menu
    BNetworkDevice device(settings->Name());
    if (fNetworkMenuField->IsHidden(fNetworkMenuField) && device.IsWireless()) {
        fNetworkMenuField->Show();
        Window()->InvalidateLayout();
    } else if (!fNetworkMenuField->IsHidden(fNetworkMenuField)
               && !device.IsWireless()) {
        fNetworkMenuField->Hide();
        Window()->InvalidateLayout();
    }

    if (device.IsWireless()) {
        // Rebuild network menu
        BMenu* menu = fNetworkMenuField->Menu();
        menu->RemoveItems(0, menu->CountItems(), true);

        wireless_network network;
        int32 count = 0;
        uint32 cookie = 0;
        while (device.GetNextNetwork(cookie, network) == B_OK) {
            BMessage* message = new BMessage(kMsgNetwork);
            message->AddString("device", device.Name());
            message->AddString("name", network.name);

            BMenuItem* item = new WirelessNetworkMenuItem(network.name,
                    network.signal_strength,
                    (network.flags & B_NETWORK_IS_ENCRYPTED) != 0, message);
            if (fCurrentSettings->WirelessNetwork() == network.name)
                item->SetMarked(true);
            menu->AddItem(item);

            count++;
        }
        if (count == 0) {
            BMenuItem* item = new BMenuItem(
                B_TRANSLATE("<no wireless networks found>"), NULL);
            item->SetEnabled(false);
            menu->AddItem(item);
        } else {
            BMenuItem* item = new BMenuItem(
                B_TRANSLATE("Choose automatically"), NULL);
            if (menu->FindMarked() == NULL)
                item->SetMarked(true);
            menu->AddItem(item, 0);
            menu->AddItem(new BSeparatorItem(), 1);
        }
        menu->SetTargetForItems(this);
    }

    item = fDeviceMenuField->Menu()->FindItem(settings->Name());
    if (item != NULL)
        item->SetMarked(true);

    fIPTextControl->SetText(settings->IP());
    fGatewayTextControl->SetText(settings->Gateway());
    fNetMaskTextControl->SetText(settings->Netmask());

    if (settings->NameServers().CountItems() >= 2) {
        fSecondaryDNSTextControl->SetText(
            settings->NameServers().ItemAt(1)->String());
    }

    if (settings->NameServers().CountItems() >= 1) {
        fPrimaryDNSTextControl->SetText(
            settings->NameServers().ItemAt(0)->String());
    }
    fDomainTextControl->SetText(settings->Domain());

    _EnableTextControls(enableControls);
}
Exemple #25
0
void CharismaWindow::update_proxy_settings()
{
	const long sroffsets[]={
		0,
		0,
		0,
		0,
		0,
		3600,
		3600*6,
		3600*12,
		0,
		3600*24,
		3600*24*2,
		3600*24*3,
		0,
		3600*24*7,
		3600*24*14,
		0,
		3600*24*30,
		3600*24*30*2,
		3600*24*30*6,
		0,
		3600*24*365,
		3600*24*365*2,
		0,
		3600*24*365*10
	};
	
	BMenu *m;
	int i;
	struct system_info sinfo;

	// g_mode
	m=modemenu->Menu();
	g_mode=m->IndexOf(m->FindMarked());
	smartrefresh->SetEnabled(g_mode==k_online);

	// g_extcontrol
	g_extcontrol=extcontrol_item->IsMarked();

	// g_refreshdate
	m=smartrefresh->Menu();
	i=m->IndexOf(m->FindMarked());
	switch(i){
	case 0:		// dumb
		g_refreshdate=0;
		break;
	case 2:		// always
		g_refreshdate=LONG_MAX;
		break;
	case 3:		// once per session
		get_system_info(&sinfo);
		g_refreshdate=sinfo.boot_time/1000000;
		break;
	case 23:	// never
		g_refreshdate=-2;
		break;
	default:
		g_refreshdate=-sroffsets[i];
		// il faut ajouter time(NULL) à cette valeur !
		// (voir proxy.cpp)
		break;
	}
}
Exemple #26
0
status_t
InterfaceHardwareView::Update()
{
	// Populate fields with current settings
	if (fSettings->HasLink()) {
		if (fSettings->IsWireless()) {
			BString network = fSettings->WirelessNetwork();
			network.Prepend(" (");
			network.Prepend(B_TRANSLATE("connected"));
			network.Append(")");
			fStatusField->SetText(network.String());
		} else {
			fStatusField->SetText(B_TRANSLATE("connected"));
		}
	} else
		fStatusField->SetText(B_TRANSLATE("disconnected"));

	fMacAddressField->SetText(fSettings->HardwareAddress());

	// TODO : Find how to get link speed
	fLinkSpeedField->SetText("100 Mb/s");

	// Update Link stats
	ifreq_stats stats;
	char buffer[100];
	fSettings->Stats(&stats);

	string_for_size(stats.send.bytes, buffer, sizeof(buffer));
	fLinkTxField->SetText(buffer);

	string_for_size(stats.receive.bytes, buffer, sizeof(buffer));
	fLinkRxField->SetText(buffer);

	// TODO move the wireless info to a separate tab. We should have a
	// BListView of available networks, rather than a menu, to make them more
	// readable and easier to browse and select.
	if (fNetworkMenuField->IsHidden(fNetworkMenuField)
		&& fSettings->IsWireless()) {
		fNetworkMenuField->Show();
	} else if (!fNetworkMenuField->IsHidden(fNetworkMenuField)
		&& !fSettings->IsWireless()) {
		fNetworkMenuField->Hide();
	}

	if (fSettings->IsWireless()) {
		// Rebuild network menu
		BMenu* menu = fNetworkMenuField->Menu();
		menu->RemoveItems(0, menu->CountItems(), true);

		std::set<BNetworkAddress> associated;
		BNetworkAddress address;
		uint32 cookie = 0;
		while (fSettings->GetNextAssociatedNetwork(cookie, address) == B_OK)
			associated.insert(address);

		wireless_network network;
		int32 count = 0;
		cookie = 0;
		while (fSettings->GetNextNetwork(cookie, network) == B_OK) {
			BMessage* message = new BMessage(kMsgNetwork);

			message->AddString("device", fSettings->Name());
			message->AddString("name", network.name);

			BMenuItem* item = new WirelessNetworkMenuItem(network.name,
				network.signal_strength,
				network.authentication_mode, message);
			if (associated.find(network.address) != associated.end())
				item->SetMarked(true);
			menu->AddItem(item);

			count++;
		}
		if (count == 0) {
			BMenuItem* item = new BMenuItem(
				B_TRANSLATE("<no wireless networks found>"), NULL);
			item->SetEnabled(false);
			menu->AddItem(item);
		} else {
			BMenuItem* item = new BMenuItem(
				B_TRANSLATE("Choose automatically"), NULL);
			if (menu->FindMarked() == NULL)
				item->SetMarked(true);
			menu->AddItem(item, 0);
			menu->AddItem(new BSeparatorItem(), 1);
		}
		menu->SetTargetForItems(this);
	}

	fRenegotiate->SetEnabled(!fSettings->IsDisabled());
	fOnOff->SetLabel(fSettings->IsDisabled() ? "Enable" : "Disable");

	return B_OK;
}
Exemple #27
0
void
SCMImportWindow::SetProvider(SCMProjectImporter *importer)
{
	if (importer && !fProvider)
	{
		fSCMField->SetEnabled(true);
		fProjectBox->SetEnabled(true);
		fAnonymousBox->SetEnabled(true);
		fUserNameBox->SetEnabled(true);
		fRepository->SetEnabled(true);
		fCommandView->MakeEditable(false);
		fOK->SetEnabled(false);
		fProjectBox->MakeFocus(true);
		fProvider = importer;
		
		UpdateCommand();
	}
	else if (!importer && fProvider)
	{
		fSCMField->SetEnabled(false);
		fProjectBox->SetEnabled(false);
		fAnonymousBox->SetEnabled(false);
		fUserNameBox->SetEnabled(false);
		fRepository->SetEnabled(false);
		fCommandView->MakeEditable(true);
		fCommandView->SetText("");
		fCommandView->MakeFocus(true);
		fOK->SetEnabled(true);
	}
	
	fProvider = importer;
	if (fProvider)
	{
		BMenu *menu = fSCMField->Menu();
		BMenuItem *item;
		
		item = menu->FindItem("Mercurial");
		if (item)
			item->SetEnabled(fProvider->SupportsSCM(SCM_HG));
			
		item = menu->FindItem("Git");
		if (item)
			item->SetEnabled(fProvider->SupportsSCM(SCM_GIT));
		
		item = menu->FindItem("Subversion");
		if (item)
			item->SetEnabled(fProvider->SupportsSCM(SCM_SVN));
		
		item = menu->FindMarked();
		if (!item->IsEnabled())
		{
			item->SetMarked(false);
			for (int32 i = 0; i < menu->CountItems(); i++)
				if (menu->ItemAt(i)->IsEnabled())
				{
					menu->ItemAt(i)->SetMarked(true);
					break;
			}
		}
	}
	UpdateCommand();
}
void
ControlView::MessageReceived(BMessage* msg)
{
    if (!fMessenger) {
        BView::MessageReceived(msg);
        return;
    }

    switch (msg->what) {
    case TEXT_CHANGED_MSG:
    {
        BMessage fontMsg(TEXT_CHANGED_MSG);
        fontMsg.AddString("_text", fTextControl->Text());
        fMessenger->SendMessage(&fontMsg);
        break;
    }

    case FONTSTYLE_CHANGED_MSG:
        _UpdateAndSendStyle(msg);
        break;

    case FONTFAMILY_CHANGED_MSG:
        _UpdateAndSendFamily(msg);
        break;

    case FONTSIZE_MSG:
    {
        char buff[256];
        sprintf(buff, B_TRANSLATE("Size: %d"),
                static_cast<int>(fFontsizeSlider->Value()));
        fFontsizeSlider->SetLabel(buff);

        BMessage msg(FONTSIZE_MSG);
        msg.AddFloat("_size", static_cast<float>(fFontsizeSlider->Value()));
        fMessenger->SendMessage(&msg);
        break;
    }

    case FONTSHEAR_MSG:
    {
        char buff[256];
        sprintf(buff, B_TRANSLATE("Shear: %d"),
                static_cast<int>(fShearSlider->Value()));
        fShearSlider->SetLabel(buff);

        BMessage msg(FONTSHEAR_MSG);
        msg.AddFloat("_shear", static_cast<float>(fShearSlider->Value()));
        fMessenger->SendMessage(&msg);
        break;
    }

    case ROTATION_MSG:
    {
        char buff[256];
        sprintf(buff, B_TRANSLATE("Rotation: %d"),
                static_cast<int>(fRotationSlider->Value()));
        fRotationSlider->SetLabel(buff);

        BMessage msg(ROTATION_MSG);
        msg.AddFloat("_rotation", static_cast<float>(fRotationSlider->Value()));
        fMessenger->SendMessage(&msg);
        break;
    }

    case SPACING_MSG:
    {
        char buff[256];
        sprintf(buff, B_TRANSLATE("Spacing: %d"),
                (int)fSpacingSlider->Value());
        fSpacingSlider->SetLabel(buff);

        BMessage msg(SPACING_MSG);
        msg.AddFloat("_spacing", static_cast<float>(fSpacingSlider->Value()));
        fMessenger->SendMessage(&msg);
        break;
    }

    case ALIASING_MSG:
    {
        BMessage msg(ALIASING_MSG);
        msg.AddBool("_aliased", static_cast<bool>(fAliasingCheckBox->Value()));
        fMessenger->SendMessage(&msg);
        if (static_cast<bool>(fAliasingCheckBox->Value()) == true)
            printf("Aliasing: true\n");
        else
            printf("Aliasing: false\n");
        break;
    }

    case BOUNDING_BOX_MSG:
    {
        BMessage msg(BOUNDING_BOX_MSG);
        msg.AddBool("_boundingbox", static_cast<bool>(fBoundingboxesCheckBox->Value()));
        fMessenger->SendMessage(&msg);
        if (static_cast<bool>(fBoundingboxesCheckBox->Value()))
            printf("Bounding: true\n");
        else
            printf("Bounding: false\n");
        break;
    }

    case OUTLINE_MSG:
    {
        int8 outlineVal = (int8)fOutlineSlider->Value();

        char buff[256];
        sprintf(buff, B_TRANSLATE("Outline: %d"), outlineVal);
        fOutlineSlider->SetLabel(buff);

        fAliasingCheckBox->SetEnabled(outlineVal < 1);
        fBoundingboxesCheckBox->SetEnabled(outlineVal < 1);

        BMessage msg(OUTLINE_MSG);
        msg.AddInt8("_outline", outlineVal);
        fMessenger->SendMessage(&msg);
        break;
    }

    case CYCLING_FONTS_MSG:
    {
        fCyclingFontButton->SetLabel(fCycleFonts ? \
                                     B_TRANSLATE("Cycle fonts") : B_TRANSLATE("Stop cycling"));
        fCycleFonts = !fCycleFonts;

        if (fCycleFonts) {
            delete fMessageRunner;
            fMessageRunner = new BMessageRunner(this,
                                                new BMessage(CYCLING_FONTS_UPDATE_MSG), 360000*2, -1);
            printf("Cycle fonts enabled\n");
        } else {
            // Delete our MessageRunner and reset the style index
            delete fMessageRunner;
            fMessageRunner = NULL;
            fFontStyleindex	= 0;
            printf("Cycle fonts disabled\n");
        }
        break;
    }

    case CYCLING_FONTS_UPDATE_MSG:
    {
        int32 familyindex = -1;
        BMenuItem* currentFamilyItem = fFontFamilyMenu->FindMarked();

        if (currentFamilyItem) {
            familyindex = fFontFamilyMenu->IndexOf(currentFamilyItem);
            const int32 installedStyles = count_font_styles(
                                              const_cast<char*>(currentFamilyItem->Label()));

            BMenu* submenu = currentFamilyItem->Submenu();
            if (submenu) {
                BMenuItem* markedStyle = submenu->FindMarked();
                fFontStyleindex = submenu->IndexOf(markedStyle);
            }

            if (fFontStyleindex < installedStyles - 1)
                fFontStyleindex++;
            else {
                fFontStyleindex = 0;

                if (familyindex < count_font_families() - 1)
                    familyindex++;
                else
                    familyindex = 0;
            }

            BMenuItem* newFontFamilyItem = fFontFamilyMenu->ItemAt(familyindex);
            BMenuItem* newstyleitem = submenu->ItemAt(fFontStyleindex);

            if (newFontFamilyItem && newstyleitem) {
                if (msg->AddString("_style", newstyleitem->Label()) != B_OK
                        || msg->AddString("_family", newFontFamilyItem->Label()) != B_OK) {
                    printf("Failed to add style or family to the message\n");
                    return;
                }
                printf("InstalledStyles(%ld), Font(%s), Style(%s)\n",
                       installedStyles, newFontFamilyItem->Label(),
                       newstyleitem->Label());
                _UpdateAndSendStyle(msg);
            }
        }
        break;
    }

    default:
        BView::MessageReceived(msg);
    }
}