screenwindow.cpp

ati driver

	item = fCombineMenu->ItemAt( i );
	// paranoia
	if( item )
		item->SetMarked( true );

	for( i = sizeof( bpp_list ) / sizeof( bpp_list[0] ) - 1; i >= 0; --i ) {
		if( bpp_list[i].space == mode.space )
			break;
	}

	// fall back to 8 bits if colour space is unknown 
	// (shouldn't happen as we know all colour spaces the 
	//  application server supports)
	if( i < 0 )
		i = 0;
	
	item = fColorsMenu->ItemAt( i );
	// well - this test is paranoid, but - who knows 8|
	if( item )
		item->SetMarked( true );

	fSelectedBpp = fActiveBpp = bpp_list[i].bpp;

	ReflectSelectedResolution();
	ReflectSelectedRefresh();

	CheckApplyEnabled();
}

bool ScreenWindow::QuitRequested()
{
	be_app->PostMessage(B_QUIT_REQUESTED);
	
	return(true);
}

void ScreenWindow::FrameMoved(BPoint position)
{
	fSettings->SetWindowFrame(Frame());
}

void ScreenWindow::ScreenChanged(BRect frame, color_space mode)
{
	if (frame.right <= Frame().right
				&& frame.bottom <= Frame().bottom)
		MoveTo(((frame.right / 2) - 178), ((frame.right / 2) - 101));
}

// if another workspace gets activated, we forget everything
// and start from scratch
void ScreenWindow::WorkspaceActivated( int32 ws, bool active )
{
	if( fChangingAllWorkspaces )
		return;
		
	BScreen( this ).GetMode( &fOrigMode );
	
	ReflectActiveMode();
	
	PostMessage(new BMessage(UPDATE_DESKTOP_COLOR_MSG), fScreenDrawView);
}

// there is something to apply if active and selected mode differ
bool ScreenWindow::canApply()
{
	if( fSelectedWidth != fActiveWidth || fSelectedHeight != fActiveHeight 
		|| fSelectedSpace != fActiveSpace || fSelectedRefresh10 != fActiveRefresh10 
		|| fSelectedCombineMode != fActiveCombineMode 
		|| fSelectedSwapDisplays != fActiveSwapDisplays 
		|| fSelectedUseLaptopPanel != fActiveUseLaptopPanel 
		|| fSelectedTVStandard != fActiveTVStandard )
		return true;

	return false;
}

// as reverting means to falling-back to mode encountered
// at program start (aka workspace switch), we enable this
// button if active mode (fPrev...) and original mode differ
// or if some settings have been changed by user
bool ScreenWindow::canRevert()
{
	if( memcmp( &fActiveMode, &fOrigMode, sizeof( display_mode )) != 0 )
		return true;
		
	if( canApply() )
		return true;
		
	return false;
}

// enable/disable "apply" and "revert" buttons
void ScreenWindow::CheckApplyEnabled()
{
	fRevertButton->SetEnabled( canRevert() );
	fApplyButton->SetEnabled( canApply() );
}

// extract selected mode to "mode", return true = success
bool ScreenWindow::getSelectedMode( display_mode *mode )
{
	uint i;
	uint16 virtual_width, virtual_height;
	
	virtual_width = fSelectedCombineMode == cb_horizontally ? 
		fSelectedWidth * 2 : fSelectedWidth;
	virtual_height = fSelectedCombineMode == cb_vertically ? 
		fSelectedHeight * 2 : fSelectedHeight;
	
	// try to find mode in list provided by driver
	for( i = 0; i < fModeListCount; ++i ) {
		if( fModeList[i].virtual_width == virtual_width &&
			fModeList[i].virtual_height == virtual_height &&
			fModeList[i].space == fSelectedSpace &&
			getModeRefresh10( &fModeList[i] ) == fSelectedRefresh10 )
		{
			break;
		}
	}
	
	if( i < fModeListCount ) {
		// we have luck - use this mode directly
		*mode = fModeList[i];
		mode->h_display_start = 0;
		mode->v_display_start = 0;
		return true;
	}

	// now, we are better of using GMT formula, but
	// as we don't have it, we look for a mode with
	// same resultion and colour space and a similar
	// refresh rate and tweak its pixel clock
	int best_idx = -1;
	int best_diff = INT_MAX;
	
	for( i = 0; i < fModeListCount; ++i ) {
		if( fModeList[i].virtual_width == virtual_width &&
			fModeList[i].virtual_height == virtual_height &&
			fModeList[i].space == fSelectedSpace ) 
		{
			int diff;
			
			diff = abs( getModeRefresh10( &fModeList[i] ) - fSelectedRefresh10 );
			if( diff < best_diff ) {
				best_diff = diff;
				best_idx = i;
			}
		}
	}
	
	if( best_idx < 0 )
		return false;
		
	*mode = fModeList[best_idx];

	// after some fiddling, it looks like this is the formula
	// used by the original panel (notice that / 10 happens before
	// multiplying with refresh rate - this leads to different
	// rounding)
	mode->timing.pixel_clock = 
		((uint32)mode->timing.h_total * mode->timing.v_total / 10 
		* fSelectedRefresh10) / 1000;
		
	mode->h_display_start = 0;
	mode->v_display_start = 0;
	
	return true;
}

// apply selected mode
void ScreenWindow::Apply()
{
	BScreen screen( B_MAIN_SCREEN_ID );
	display_mode mode;
	
	if( !getSelectedMode( &mode ))
		return;
	
	if( fWorkspaceMenu->FindMarked() == fAllWorkspacesItem )	{
		BAlert *WorkspacesAlert = new BAlert("WorkspacesAlert", "Change all workspaces? 
This action cannot be reverted", "Okay", "Cancel", 
			NULL, B_WIDTH_AS_USUAL, B_WARNING_ALERT);
	
		if( WorkspacesAlert->Go() == 1 )
			return;
	}
	
	SetSwapDisplays( &screen, fSelectedSwapDisplays );
	SetUseLaptopPanel( &screen, fSelectedUseLaptopPanel );
	SetTVStandard( &screen, fSelectedTVStandard );
	screen.SetMode( &mode, true );
		
	BRect Rect;

	Rect.Set(100.0, 100.0, 400.0, 193.0);
	
	Rect.left = (screen.Frame().right / 2) - 150;
	Rect.top = (screen.Frame().bottom / 2) - 42;
	Rect.right = Rect.left + 300.0;
	Rect.bottom = Rect.top + 93.0;
	
	new AlertWindow( this, Rect);
}

void ScreenWindow::MessageReceived(BMessage* message)
{
	switch(message->what) {
		case WORKSPACE_CHECK_MSG:
			fApplyButton->SetEnabled(true);
			break;
			
		case POP_COLORS_MSG: 
			// new colour has been chosen
			message->FindInt32( "bpp", &fSelectedBpp );
			message->FindInt32( "space", (int32 *)&fSelectedSpace );
			
			CheckApplyEnabled();
			break;
			
		case POP_REFRESH_MSG:
			// new (standard) refresh rate has been chosen
			message->FindInt32( "refresh10", &fSelectedRefresh10 );
			
			fOtherRefresh->SetLabel( "Other..." );
			
			CheckApplyEnabled();
			break;
	
		case POP_WORKSPACE_CHANGED_MSG: {		
			BMenuItem *Item = fWorkspaceCountMenu->FindMarked();
		
			set_workspace_count( fWorkspaceCountMenu->IndexOf(Item) + 1 );
			break;
		}
		
		case POP_RESOLUTION_MSG: {
			// new resolution has been chosen
			// we need to update bpp and refresh according to
			// card's capabilities and redraw screen icon
			message->FindInt32( "width", &fSelectedWidth );
			message->FindInt32( "height", &fSelectedHeight );

			ReflectSelectedResolution();

			UpdateModeOptions( fSelectedWidth, fSelectedHeight, fSelectedCombineMode );

			ReflectSelectedRefresh();
			
			CheckApplyEnabled();			
			break;
		}
		
		case POP_COMBINE_DISPLAYS_MSG: {
			int32 tmp;
			
			// new combine mode has bee chosen
			message->FindInt32( "mode", &tmp );
			
			fSelectedCombineMode = (CombineMode)tmp;
			
			UpdateResolutions( fSelectedCombineMode );
			
			CheckApplyEnabled();
			break;
		}
		
		case POP_SWAP_DISPLAYS_MSG: {
			message->FindBool( "swap", &fSelectedSwapDisplays );
			
			CheckApplyEnabled();
			break;
		}
		
		case POP_USE_LAPTOP_PANEL_MSG: {
			message->FindBool( "use", &fSelectedUseLaptopPanel );
			
			CheckApplyEnabled();
			break;
		}
		
		case POP_TV_STANDARD_MSG: {
			message->FindInt32( "tv_standard", (int32 *)&fSelectedTVStandard );
			
			CheckApplyEnabled();
			break;
		}
		
		case POP_OTHER_REFRESH_MSG: {
			// user pressed "other..." in refresh rate list;
			// take last refresh as a base 
			CheckApplyEnabled();
			
			// make sure menu shows something usefull
			ReflectSelectedRefresh();
		
			fRefreshWindow = new RefreshWindow(
				this,
				BRect(
					(Frame().left + 201.0), (Frame().top + 34.0), 
					(Frame().left + 509.0), (Frame().top + 169.0)), 
				fSelectedRefresh10 );
		
			break;
		}
		
		case BUTTON_DEFAULTS_MSG: {	
			// user pressed "default" button;
			// this chooses 640x480x8@60 but *doesn't* activate it
			BMenuItem *item;
			
			// well, every driver should support 640x480, 
			// but think about VESA 
			item = fResolutionMenu->FindItem("640 x 480");
			if( item ) {
				fSelectedWidth = 640;
				fSelectedHeight = 480;
				item->SetMarked(true);
			}
				
			fColorsMenu->FindItem("8 Bits/Pixel")->SetMarked(true);
			fSelectedBpp = 8;
			fSelectedSpace = B_CMAP8;
			
			fSelectedRefresh10 = 600;
			ReflectSelectedRefresh();
			
			CheckApplyEnabled();	
			break;
		}
		
		case BUTTON_REVERT_MSG:	{
			// user pressed "revert"
			// switch back to mode that was active when this
			// panel was started or the current workspace was
			// activated; don't ask anything, just do it
			BScreen screen( this );
			
			SetSwapDisplays( &screen, fOrigSwapDisplays );
			SetUseLaptopPanel( &screen, fOrigUseLaptopPanel );
			SetTVStandard( &screen, fOrigTVStandard );
			screen.SetMode( &fOrigMode, true );
			
			ReflectActiveMode();
			break;
		}
			
		case BUTTON_APPLY_MSG: {
			// user asks to apply the mode he has chosen;
			// after changing the mode (and a warning, if
			// the refresh is very high), a confirmation
			// box pops up, reverting to previous mode after
			// a timeout
			Apply();
			break;
		}
		
		case SET_INITIAL_MODE_MSG: {
			// user pressed "revert" in confirmation box;
			// revert to mode previously active
			BScreen screen( this );
			
			SetSwapDisplays( &screen, fActiveSwapDisplays );
			SetUseLaptopPanel( &screen, fActiveUseLaptopPanel );
			SetTVStandard( &screen, fActiveTVStandard );
			BScreen( this ).SetMode( &fActiveMode, true );
			
			ReflectActiveMode();
			break;
		}
		
		case SET_CUSTOM_REFRESH_MSG: {
			// user pressed "done" in "other..." refresh dialog;
			// select the refresh rate chosen
			message->FindInt32( "refresh10", &fSelectedRefresh10 );
			
			ReflectSelectedRefresh();
			CheckApplyEnabled();
			break;
		}
		
		case MAKE_INITIAL_MSG: {
			// user pressed "keep" in confirmation box;
			// select this mode in dialog and mark it as
			// previous mode; if "all workspaces" is selected, 
			// distribute mode to all workspaces 
	
			display_mode new_mode;
			BScreen screen( this );
					
			// use the mode that has eventually been set and
			// thus we know to be working; it can differ from 
			// the mode selected by user due to hardware limitation
			screen.GetMode( &new_mode );
			
			if (fWorkspaceMenu->FindMarked() == fAllWorkspacesItem )	{
				int32 orig, i;
								
				// the original panel activates each workspace in turn;
				// this is disguisting and there is a SetMode
				// variant that accepts a workspace id, so let's take
				// this one
				orig = current_workspace();

				// well, this "cannot be reverted" message is not
				// entirely true - at least, you can revert it
				// for current workspace; to not overwrite original
				// mode during workspace switch, we use this flag
				fChangingAllWorkspaces = true;

				for( i = 0; i < count_workspaces(); ++i ) {
					if( i != orig )
						screen.SetMode( i, &new_mode, true );
				}
			
				fChangingAllWorkspaces = false;
			} 
						
			ReflectActiveMode();
			break;
		}
		
		default:
			BWindow::MessageReceived(message);
		
			break;
	}
}