示例#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;
}
示例#2
0
void PecoApp::ChangeRenamer() {
	BMenuField	*myField = (BMenuField *)fWindow->FindView("selectMode");
	BMenu		*myMenu = myField->Menu();
	if (fRenameMode != myMenu->IndexOf(myField->Menu()->FindMarked())) {
		BView	*bottomView = fWindow->FindView("bottomView");
		fWindow->Lock();
		if (fRenameMode != -1) 
			bottomView->RemoveChild((BView *)((PecoApp *)be_app)->fRenamers[fRenameMode]);
		else {
			float deltaHeight = be_plain_font->Size()*2 + 40;
			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);	
			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 );
		}
		fRenameMode = myMenu->IndexOf(myField->Menu()->FindMarked());
		bottomView->AddChild(((PecoApp *)be_app)->fRenamers[fRenameMode]);
		if (((PecoApp *)be_app)->fRenamers[fRenameMode]->ChildAt(0) != NULL) 
			((PecoApp *)be_app)->fRenamers[fRenameMode]->ChildAt(0)->MakeFocus();
		else
			fWindow->FindView("DoIt")->MakeFocus();
		fWindow->Unlock();
		MakeList();
	}
}
示例#3
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;
		}
	}
}
示例#4
0
void
PPPoEView::MessageReceived(BMessage *message)
{
	switch(message->what) {
		case kMsgSelectInterface: {
			BMenuItem *item = fInterface->Menu()->FindMarked();
			if(item)
				fInterfaceName = item->Label();
		} break;
		
		case kMsgSelectOther:
			(new TextRequestDialog("InterfaceName", NULL, kRequestInterfaceName,
				fInterfaceName.String()))->Go(new BInvoker(
				new BMessage(kMsgFinishSelectOther), this));
		break;
		
		case kMsgFinishSelectOther: {
			int32 which;
			message->FindInt32("which", &which);
			
			const char *name = message->FindString("text");
			BMenu *menu = fInterface->Menu();
			BMenuItem *item;
			if(which != 1 || !name || strlen(name) == 0) {
				item = menu->FindItem(fInterfaceName.String());
				if(item && menu->IndexOf(item) <= menu->CountItems() - 2)
					item->SetMarked(true);
				else
					fOtherInterface->SetMarked(true);
				
				return;
			}
			
			fInterfaceName = name;
			
			item = menu->FindItem(fInterfaceName.String());
			if(item && menu->IndexOf(item) <= menu->CountItems() - 2) {
				item->SetMarked(true);
				return;
			}
			
			BString label(kLabelOtherInterface);
			label << " " << name;
			fOtherInterface->SetLabel(label.String());
			fOtherInterface->SetMarked(true);
				// XXX: this is needed to tell the owning menu to update its label
		} break;
		
		default:
			BView::MessageReceived(message);
	}
}
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);
}
示例#6
0
// -------------------------------------------------------------------
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);
	}
}		
示例#7
0
/***********************************************************
 * Operator2
 ***********************************************************/
int32
HCriteriaView::Operator2() const
{
	BMenu *menu = fOp2Menu->Menu();
	BMenuItem *item = menu->FindMarked();
	if(item)
		return menu->IndexOf(item);
	return 0;	
}
示例#8
0
/***********************************************************
 * Attribute
 ***********************************************************/
int32
HCriteriaView::Attribute() const
{
	BMenu *menu = fAttrMenu->Menu();
	BMenuItem *item = menu->FindMarked();
	if(item)
		return menu->IndexOf(item);
	return 0;	
}
示例#9
0
void
PPPoEView::ReloadInterfaces()
{
	// delete all items and request a new bunch from the pppoe kernel module
	BMenu *menu = fInterface->Menu();
	while(menu->CountItems() > 2)
		delete menu->RemoveItem((int32) 0);
	fOtherInterface->SetLabel(kLabelOtherInterface);
	
	PPPManager manager;
	char *interfaces = new char[8192];
		// reserve enough space for approximately 512 entries
	int32 count = manager.ControlModule("pppoe", PPPoE_GET_INTERFACES, interfaces,
		8192);
	
	BMenuItem *item;
	char *name = interfaces;
	int32 insertAt;
	for(int32 index = 0; index < count; index++) {
		item = new BMenuItem(name, new BMessage(kMsgSelectInterface));
		insertAt = FindNextMenuInsertionIndex(menu, name);
		if(insertAt > menu->CountItems() - 2)
			insertAt = menu->CountItems() - 2;
		
		item->SetTarget(this);
		menu->AddItem(item, insertAt);
		name += strlen(name) + 1;
	}
	
	// set interface or some default value if nothing was found
	if(Addon()->InterfaceName() && strlen(Addon()->InterfaceName()) > 0)
		fInterfaceName = Addon()->InterfaceName();
	else if(count > 0)
		fInterfaceName = interfaces;
	else
		fInterfaceName = "";
	
	delete interfaces;
	
	item = menu->FindItem(fInterfaceName.String());
	if(item && menu->IndexOf(item) <= menu->CountItems() - 2)
		item->SetMarked(true);
	else if(Addon()->InterfaceName()) {
		BString label(kLabelOtherInterface);
		label << " " << fInterfaceName;
		fOtherInterface->SetLabel(label.String());
		fOtherInterface->SetMarked(true);
	}
}
示例#10
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;
}
示例#11
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
示例#12
0
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
}
示例#13
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);
}
示例#14
0
void
TFilePanel::Init(const BMessage*)
{
	BRect windRect(Bounds());
	AddChild(fBackView = new BackgroundView(windRect));

	// add poseview menu bar
	fMenuBar = new BMenuBar(BRect(0, 0, windRect.Width(), 1), "MenuBar");
	fMenuBar->SetBorder(B_BORDER_FRAME);
	fBackView->AddChild(fMenuBar);

	AddMenus();
	AddContextMenus();

	FavoritesMenu* favorites = new FavoritesMenu(B_TRANSLATE("Favorites"),
		new BMessage(kSwitchDirectory), new BMessage(B_REFS_RECEIVED),
		BMessenger(this), IsSavePanel(), fPoseView->RefFilter());
	favorites->AddItem(new BMenuItem(B_TRANSLATE("Add current folder"),
		new BMessage(kAddCurrentDir)));
	favorites->AddItem(new BMenuItem(
		B_TRANSLATE("Edit favorites" B_UTF8_ELLIPSIS),
		new BMessage(kEditFavorites)));

	fMenuBar->AddItem(favorites);

	// configure menus
	BMenuItem* item = fMenuBar->FindItem(B_TRANSLATE("Window"));
	if (item) {
		fMenuBar->RemoveItem(item);
		delete item;
	}

	item = fMenuBar->FindItem(B_TRANSLATE("File"));
	if (item) {
		BMenu* menu = item->Submenu();
		if (menu) {
			item = menu->FindItem(kOpenSelection);
			if (item && menu->RemoveItem(item))
				delete item;

			item = menu->FindItem(kDuplicateSelection);
			if (item && menu->RemoveItem(item))
				delete item;

			// remove add-ons menu, identifier menu, separator
			item = menu->FindItem(B_TRANSLATE("Add-ons"));
			if (item) {
				int32 index = menu->IndexOf(item);
				delete menu->RemoveItem(index);
				delete menu->RemoveItem(--index);
				delete menu->RemoveItem(--index);
			}

			// remove separator
			item = menu->FindItem(B_CUT);
			if (item) {
				item = menu->ItemAt(menu->IndexOf(item)-1);
				if (item && menu->RemoveItem(item))
					delete item;
			}
		}
	}

	// add directory menu and menufield
	fDirMenu = new BDirMenu(0, this, kSwitchDirectory, "refs");

	font_height ht;
	be_plain_font->GetHeight(&ht);
	float f_height = ht.ascent + ht.descent + ht.leading;

	BRect rect;
	rect.top = fMenuBar->Bounds().Height() + 8;
	rect.left = windRect.left + 8;
	rect.right = rect.left + 300;
	rect.bottom = rect.top + (f_height > 22 ? f_height : 22);

	fDirMenuField = new BMenuField(rect, "DirMenuField", "", fDirMenu);
	fDirMenuField->MenuBar()->SetFont(be_plain_font);
	fDirMenuField->SetDivider(0);
	fDirMenuField->MenuBar()->SetMaxContentWidth(rect.Width() - 26.0f);
		// Make room for the icon

	fDirMenuField->MenuBar()->RemoveItem((int32)0);
	fDirMenu->SetMenuBar(fDirMenuField->MenuBar());
		// the above is a weird call from BDirMenu
		// ToDo: clean up

	BEntry entry(TargetModel()->EntryRef());
	if (entry.InitCheck() == B_OK)
		fDirMenu->Populate(&entry, 0, true, true, false, true);
	else
		fDirMenu->Populate(0, 0, true, true, false, true);

	fBackView->AddChild(fDirMenuField);

	// add file name text view
	if (fIsSavePanel) {
		BRect rect(windRect);
		rect.top = rect.bottom - 35;
		rect.left = 8;
		rect.right = rect.left + 170;
		rect.bottom = rect.top + 13;

		fTextControl = new BTextControl(rect, "text view",
			B_TRANSLATE("save text"), "", NULL,
			B_FOLLOW_LEFT | B_FOLLOW_BOTTOM);
		DisallowMetaKeys(fTextControl->TextView());
		DisallowFilenameKeys(fTextControl->TextView());
		fBackView->AddChild(fTextControl);
		fTextControl->SetDivider(0.0f);
		fTextControl->TextView()->SetMaxBytes(B_FILE_NAME_LENGTH - 1);

		fButtonText.SetTo(B_TRANSLATE("Save"));
	} else
		fButtonText.SetTo(B_TRANSLATE("Open"));

	rect = windRect;
	rect.OffsetTo(10, fDirMenuField->Frame().bottom + 10);
	rect.bottom = windRect.bottom - 60;
	rect.right -= B_V_SCROLL_BAR_WIDTH + 20;

	// re-parent the poseview to our backview
	// ToDo:
	// This is terrible, fix it up
	PoseView()->RemoveSelf();
	if (fIsSavePanel)
		fBackView->AddChild(PoseView(), fTextControl);
	else
		fBackView->AddChild(PoseView());

	PoseView()->MoveTo(rect.LeftTop());
	PoseView()->ResizeTo(rect.Width(), rect.Height());
	PoseView()->AddScrollBars();
	PoseView()->SetDragEnabled(false);
	PoseView()->SetDropEnabled(false);
	PoseView()->SetSelectionHandler(this);
	PoseView()->SetSelectionChangedHook(true);
	PoseView()->DisableSaveLocation();
	PoseView()->VScrollBar()->MoveBy(0, -1);
	PoseView()->VScrollBar()->ResizeBy(0, 1);


	AddShortcut('W', B_COMMAND_KEY, new BMessage(kCancelButton));
	AddShortcut('H', B_COMMAND_KEY, new BMessage(kSwitchToHome));
	AddShortcut('A', B_COMMAND_KEY | B_SHIFT_KEY,
		new BMessage(kShowSelectionWindow));
	AddShortcut('A', B_COMMAND_KEY, new BMessage(B_SELECT_ALL), PoseView());
	AddShortcut('S', B_COMMAND_KEY, new BMessage(kInvertSelection),
		PoseView());
	AddShortcut('Y', B_COMMAND_KEY, new BMessage(kResizeToFit), PoseView());
	AddShortcut(B_DOWN_ARROW, B_COMMAND_KEY, new BMessage(kOpenDir));
	AddShortcut(B_DOWN_ARROW, B_COMMAND_KEY | B_OPTION_KEY,
		new BMessage(kOpenDir));
	AddShortcut(B_UP_ARROW, B_COMMAND_KEY, new BMessage(kOpenParentDir));
	AddShortcut(B_UP_ARROW, B_COMMAND_KEY | B_OPTION_KEY,
		new BMessage(kOpenParentDir));

	// New code to make buttons font sensitive
	rect = windRect;
	rect.top = rect.bottom - 35;
	rect.bottom -= 10;
	rect.right -= 25;
	float default_width
		= be_plain_font->StringWidth(fButtonText.String()) + 20;
	rect.left = default_width > 75
		? rect.right - default_width : rect.right - 75;

	BButton* default_button = new BButton(rect, "default button",
		fButtonText.String(), new BMessage(kDefaultButton),
		B_FOLLOW_RIGHT + B_FOLLOW_BOTTOM);
	fBackView->AddChild(default_button);

	rect.right = rect.left -= 10;
	float cancel_width
		= be_plain_font->StringWidth(B_TRANSLATE("Cancel")) + 20;
	rect.left = cancel_width > 75
		? rect.right - cancel_width : rect.right - 75;

	BButton* cancel_button = new BButton(rect, "cancel button",
		B_TRANSLATE("Cancel"), new BMessage(kCancelButton),
		B_FOLLOW_RIGHT + B_FOLLOW_BOTTOM);
	fBackView->AddChild(cancel_button);

	if (!fIsSavePanel)
		default_button->SetEnabled(false);

	default_button->MakeDefault(true);

	RestoreState();

	PoseView()->ScrollTo(B_ORIGIN);
	PoseView()->UpdateScrollRange();
	PoseView()->ScrollTo(B_ORIGIN);

	if (fTextControl) {
		fTextControl->MakeFocus();
		fTextControl->TextView()->SelectAll();
	} else
		PoseView()->MakeFocus();

	app_info info;
	BString title;
	if (be_app->GetAppInfo(&info) == B_OK) {
		if (!gLocalizedNamePreferred
			|| BLocaleRoster::Default()->GetLocalizedFileName(
				title, info.ref, false) != B_OK)
			title = info.ref.name;
		title << ": ";
	}
	title << fButtonText;	// Open or Save

	SetTitle(title.String());

	SetSizeLimits(370, 10000, 200, 10000);
}
示例#15
0
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);
}
示例#16
0
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);
    }
}
示例#17
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;
	}
}
示例#18
0
void
TBarMenuTitle::DrawContent()
{
	BMenu* menu = Menu();
	BRect frame(Frame());

	if (be_control_look != NULL) {
		menu->SetDrawingMode(B_OP_ALPHA);

		if (fIcon != NULL) {
			BRect dstRect(fIcon->Bounds());
			dstRect.OffsetTo(frame.LeftTop());
			dstRect.OffsetBy(rintf(((frame.Width() - dstRect.Width()) / 2)
				- 1.0f), rintf(((frame.Height() - dstRect.Height()) / 2)
				- 0.0f));

			menu->DrawBitmapAsync(fIcon, dstRect);
		}
		return;
	}

	rgb_color menuColor = menu->ViewColor();
	rgb_color dark = tint_color(menuColor, B_DARKEN_1_TINT);
	rgb_color light = tint_color(menuColor, B_LIGHTEN_2_TINT);
	rgb_color black = {0, 0, 0, 255};

	bool inExpandoMode = dynamic_cast<TExpandoMenuBar*>(menu) != NULL;

	BRect bounds(menu->Window()->Bounds());
	if (bounds.right < frame.right)
		frame.right = bounds.right;

	menu->SetDrawingMode(B_OP_COPY);

	if (!IsSelected() && !menu->IsRedrawAfterSticky()) {
		menu->BeginLineArray(8);
		menu->AddLine(frame.RightTop(), frame.LeftTop(), light);
		menu->AddLine(frame.LeftBottom(), frame.RightBottom(), dark);
		menu->AddLine(frame.LeftTop(),
			frame.LeftBottom()+BPoint(0, inExpandoMode ? 0 : -1), light);
		menu->AddLine(frame.RightBottom(), frame.RightTop(), dark);
		if (inExpandoMode) {
			frame.top += 1;
			menu->AddLine(frame.LeftTop(), frame.RightTop() + BPoint(-1, 0),
				light);
		}

		menu->EndLineArray();

		frame.InsetBy(1, 1);
		menu->SetHighColor(menuColor);
		menu->FillRect(frame);
		menu->SetHighColor(black);
		frame.InsetBy(-1, -1);
		if (inExpandoMode)
			frame.top -= 1;
	}

	ASSERT(IsEnabled());
	if (IsSelected() && !menu->IsRedrawAfterSticky()) {
		menu->SetHighColor(tint_color(menuColor, B_HIGHLIGHT_BACKGROUND_TINT));
		menu->FillRect(frame);

		if (menu->IndexOf(this) > 0) {
			menu->SetHighColor(tint_color(menuColor, B_DARKEN_4_TINT));
			menu->StrokeLine(frame.LeftTop(), frame.LeftBottom());
		}

		menu->SetHighColor(black);
	}

	menu->SetDrawingMode(B_OP_ALPHA);

	if (fIcon != NULL) {
		BRect dstRect(fIcon->Bounds());
		dstRect.OffsetTo(frame.LeftTop());
		dstRect.OffsetBy(rintf(((frame.Width() - dstRect.Width()) / 2) - 1.0f),
			rintf(((frame.Height() - dstRect.Height()) / 2) - 0.0f));

		menu->DrawBitmapAsync(fIcon, dstRect);
	}
}