// Rotate this object about a point
void CDrawPower::Rotate(CDPoint p,int ndir)
{
    // Translate this point so the rotational point is the origin
    m_point_a = CDPoint(m_point_a.x-p.x,m_point_a.y-p.y);
    m_point_b = CDPoint(m_point_b.x-p.x,m_point_b.y-p.y);

    // Perfrom the rotation
    switch (ndir) {
    case 2: // Left
        m_point_a = CDPoint(m_point_a.y,-m_point_a.x);
        m_point_b = CDPoint(m_point_b.y,-m_point_b.x);
        break;
    case 3: // Right
        m_point_a = CDPoint(-m_point_a.y,m_point_a.x);
        m_point_b = CDPoint(-m_point_b.y,m_point_b.x);
        break;
    case 4: // Mirror
        m_point_a = CDPoint(-m_point_a.x,m_point_a.y);
        m_point_b = CDPoint(-m_point_b.x,m_point_b.y);
        break;
    }

    // Re-translate the points back to the original location
    m_point_a = CDPoint(m_point_a.x+p.x,m_point_a.y+p.y);
    m_point_b = CDPoint(m_point_b.x+p.x,m_point_b.y+p.y);

    dir = DoRotate(dir,ndir);
}
Example #2
0
// Rotate this object about a point
void CDrawPower::Rotate(CDPoint p, int ndir)
{
	// Rotate bounding box only if we have a centre point
	if (p != CDPoint(0, 0))
	{
		// Translate this point so the rotational point is the origin
		m_point_a = CDPoint(m_point_a.x - p.x, m_point_a.y - p.y);
		m_point_b = CDPoint(m_point_b.x - p.x, m_point_b.y - p.y);

		// Perfrom the rotation
		switch (ndir)
		{
			case 2: // Left
				m_point_a = CDPoint(m_point_a.y, -m_point_a.x);
				m_point_b = CDPoint(m_point_b.y, -m_point_b.x);
				break;
			case 3: // Right
				m_point_a = CDPoint(-m_point_a.y, m_point_a.x);
				m_point_b = CDPoint(-m_point_b.y, m_point_b.x);
				break;
			case 4: // Mirror
				m_point_a = CDPoint(-m_point_a.x, m_point_a.y);
				m_point_b = CDPoint(-m_point_b.x, m_point_b.y);
				break;
		}

		// Re-translate the points back to the original location
		m_point_a = CDPoint(m_point_a.x + p.x, m_point_a.y + p.y);
		m_point_b = CDPoint(m_point_b.x + p.x, m_point_b.y + p.y);
	}

	dir = (BYTE) DoRotate(dir, ndir);

	CalcLayout();
}
Example #3
0
bool Layer::Rotate( std::vector<RotationElement>& rotations, wxWindow* wnd, wxCommandEvent& event )
{
  bool ret = DoRotate( rotations, wnd, event ); 
  if ( ret )
  {
    ResetTranslate();
    ResetScale();   
    this->SendBroadcast( "LayerTransformed", this, this );
  }
  return ret;
}
Example #4
0
void PlayerControl( int player )
{
	int a = player, b = player;
	bool moved = false;

	if( players == 1 )
	{
		a = 0;
		b = 1;
	}

	if( hitKey[a].left || hitKey[b].left )
	{
		if( GameTickCount() >= timeMove[player] )
		{
			timeMove[player] += 12;
			if( CanGoLeft( player ) )
				GoLeft( player );
		}

		moved = true;
	}

	if( hitKey[a].right || hitKey[b].right )
	{
		if( GameTickCount() >= timeMove[player] )
		{
			timeMove[player] += 12;
			if( CanGoRight( player ) )
				GoRight( player );
		}

		moved = true;
	}

	if( !moved ) timeMove[player] = GameTickCount( );

	if( hitKey[a].rotate == 1 || hitKey[b].rotate == 1 )
	{
		if( CanRotate( player ) )
			DoRotate( player );
	}

	if( hitKey[a].drop == 1 || hitKey[b].drop == 1 )
	{
		DoDrop( player );
	}

	if( hitKey[a].drop == 0 && hitKey[b].drop == 0 )
	{
		StopDrop( player );
	}
}
Example #5
0
void GLWidget::mouseReleaseEvent( QMouseEvent *e)
{
    //TODO:When some pressed mouse button is release
    if (e->button() == Qt::RightButton)
    {
        Rotating = false;
        DoRotate(e->pos(), lastMousePoint);
    }
    else if (e->button() == Qt::LeftButton)
    {
        Scaling = false;
        DoScale(e->pos(), lastMousePoint);
    }
    updateGL();
}
Example #6
0
void GLWidget::mouseMoveEvent( QMouseEvent *e )
{
    //TODO: when the mouse is moved!
    if ((e->buttons() & Qt::RightButton) && Rotating)
    {
        DoRotate(e->pos(), lastMousePoint);
        lastMousePoint = e->pos();
    }
    else if ((e->buttons() & Qt::LeftButton) && Scaling)
    {
        DoScale(e->pos(), lastMousePoint);
        lastMousePoint = e->pos();
    }

    updateGL();
}
void DialogTransformVolume::OnApply()
{
  if (ui->radioButtonRotateManual->isChecked())
  {
    int plane;
    double angle;
    if ( !m_checkRotate[0]->isChecked() &&
         !m_checkRotate[1]->isChecked() &&
         !m_checkRotate[2]->isChecked() )
    {
      QMessageBox::warning( this, "Error",
                            "Must at least select one rotation.");
      return;
    }
    else if ( ( m_checkRotate[0]->isChecked() && !GetRotation( 0, plane, angle ) ) ||
              ( m_checkRotate[1]->isChecked() && !GetRotation( 1, plane, angle ) ) ||
              ( m_checkRotate[2]->isChecked() && !GetRotation( 2, plane, angle ) ) )
    {
      QMessageBox::warning( this, "Error",
                            "Please enter correct rotation angle.");
      return;
    }
  }
  else
  {
    if (ui->comboBoxAxis11->currentIndex() == ui->comboBoxAxis12->currentIndex() ||
        ui->comboBoxAxis21->currentIndex() == ui->comboBoxAxis22->currentIndex() ||
        ui->comboBoxAxisTarget1->currentIndex() == ui->comboBoxAxisTarget2->currentIndex() ||
        (ui->comboBoxAxis11->currentIndex() == ui->comboBoxAxis21->currentIndex() &&
         ui->comboBoxAxis12->currentIndex() == ui->comboBoxAxis22->currentIndex()) ||
        (ui->comboBoxAxis11->currentIndex() == ui->comboBoxAxis22->currentIndex() &&
         ui->comboBoxAxis12->currentIndex() == ui->comboBoxAxis21->currentIndex()))
    {
      QMessageBox::warning(this, "Error", "Something is wrong on the mapping settings. Please correct it.");
      return;
    }
    for (int i = 0; i < this->m_btnPickLandmark.size(); i++)
      m_btnPickLandmark[i]->setChecked(false);
  }

  DoRotate();

  UpdateUI();
}
Example #8
0
void AIControl( int player )
{
	if( timeAI[player] > GameTickCount() )
		return;

	timeAI[player] += moveQuick[player]? character[player].speedRush:
	                                     character[player].speedNormal;

	switch( RandomBefore( 2 ) )
	{
		case 0:
			if( destinationR[player] != blobR[player] )
			{
				if( CanRotate(player) )
				{
					DoRotate( player );
				}
			}
			break;

		case 1:
			if( destinationX[player] != blobX[player] )
			{
				if( destinationX[player] > blobX[player] )
				{
					if( CanGoRight( player ) )
						GoRight( player );
				}
				else
				{
					if( CanGoLeft( player ) )
						GoLeft( player );
				}
			}
			break;
	}

	if( destinationX[player] == blobX[player] &&
		destinationR[player] == blobR[player] &&
		RandomBefore( 100 ) < character[player].intellect )
	{
		DoDrop( player );
	}
}
Example #9
0
void AutoControl( int player )
{
	if( autoPattern )
	{
		switch( autoPattern->command )
		{
			case kMessage:
				StartBalloon( autoPattern->message );
				autoPattern++;
				break;

			case kIdleTicks:
				if( !tutorialTime )
				{
					tutorialTime = GameTickCount() + autoPattern->d1;
				}
				else
				{
					if( GameTickCount() >= tutorialTime )
					{
						tutorialTime = 0;
						autoPattern++;
					}
				}
				break;

			case kRetrieve:
				if( role[player] == kWaitForRetrieval )
				{
					nextA[player] = abs( autoPattern->d1 );
					nextB[player] = abs( autoPattern->d2 );
					nextM[player] = (autoPattern->d1 < 0);
					nextG[player] = (autoPattern->d1 == kBombBottom) && (autoPattern->d2 == kBombTop);

					if( !nextG[player] )
					{
						nextA[player] = pieceMap[ nextA[player] ];
						nextB[player] = pieceMap[ nextB[player] ];
					}

					role[player]  = kRetrieveBlobs;
					autoPattern++;
				}
				break;

			case kPosition:
				if( (role[player] != kFalling) || (blobX[player] == autoPattern->d1) )
				{
					autoPattern++;
				}
				else if( GameTickCount() >= timeMove[player] )
				{
					timeMove[player] = GameTickCount() + 12;

					if( blobX[player] > autoPattern->d1 )
					{
						if( CanGoLeft( player ) )
							GoLeft( player );
					}
					else
					{
						if( CanGoRight( player ) )
							GoRight( player );
					}
				}
				break;

			case kSpin:
				if( role[player] != kFalling )
				{
					autoPattern++;
				}
				else if( CanRotate( player ) )
				{
					DoRotate( player );
					autoPattern++;
				}
				break;

			case kBlockUntilLand:
				if( role[player] != kFalling )
				{
					autoPattern++;
				}
				break;

			case kBlockUntilDrop:
				if( !dropping[player] ) DoDrop( player );

				if( role[player] != kFalling )
				{
					autoPattern++;
				}
				break;

			case kPunish:
				if( role[player] == kWaitForRetrieval )
				{
					lockGrays[player] = autoPattern->d1;
					SetupGrays( player );
					blobTime[player] = GameTickCount( );
					role[player] = kDropGrays;

					autoPattern++;
				}
				break;

			case kComplete:
				EndTutorial( );
				break;

			case kBlockUntilComplete:
				if( role[player] == kWaitForRetrieval )
				{
					autoPattern++;
				}
				break;
		}
	}
}
Example #10
0
void Navigator::StopRotate(double a, double timeInSec)
{
  DoRotate(a, timeInSec);
  m_InAction = false;
}
Example #11
0
/* handle all WM_COMMAND messages here */
LONG WINAPI CommandHandler (
    HWND    hWnd,
    WPARAM  wParam,
    LPARAM  lParam)
{
	HMENU hMenu;

    switch (LOWORD(wParam))
    {
//
// file menu
//
    	case ID_FILE_EXIT:
            /* exit application */
			if (!ConfirmModified())
				return TRUE;

            PostMessage (hWnd, WM_CLOSE, 0, 0L);
			break;

		case ID_FILE_OPEN:
			if (!ConfirmModified())
				return TRUE;
			OpenDialog ();
			break;

		case ID_FILE_NEW:
			if (!ConfirmModified())
				return TRUE;
			Map_New ();
			break;
		case ID_FILE_SAVE:
			if (!strcmp(currentmap, "unnamed.map"))
				SaveAsDialog ();
			else
				Map_SaveFile (currentmap, false);	// ignore region
			break;
		case ID_FILE_SAVEAS:
			SaveAsDialog ();
			break;

		case ID_FILE_LOADPROJECT:
			if (!ConfirmModified())
				return TRUE;
			ProjectDialog ();
			break;

		case ID_FILE_POINTFILE:
			if (g_qeglobals.d_pointfile_display_list)
				Pointfile_Clear ();
			else
				Pointfile_Check ();
			break;

//
// view menu
//
		case ID_VIEW_ENTITY:
			SetInspectorMode(W_ENTITY);
			break;
		case ID_VIEW_CONSOLE:
			SetInspectorMode(W_CONSOLE);
			break;
		case ID_VIEW_TEXTURE:
			SetInspectorMode(W_TEXTURE);
			break;

		case ID_VIEW_100:
			g_qeglobals.d_xy.scale = 1;
			Sys_UpdateWindows (W_XY|W_XY_OVERLAY);
			break;
		case ID_VIEW_ZOOMIN:
			g_qeglobals.d_xy.scale *= 5.0/4;
			if (g_qeglobals.d_xy.scale > 16)
				g_qeglobals.d_xy.scale = 16;
			Sys_UpdateWindows (W_XY|W_XY_OVERLAY);
			break;
		case ID_VIEW_ZOOMOUT:
			g_qeglobals.d_xy.scale *= 4.0/5;
			if (g_qeglobals.d_xy.scale < 0.1)
				g_qeglobals.d_xy.scale = 0.1;
			Sys_UpdateWindows (W_XY|W_XY_OVERLAY);
			break;

		case ID_VIEW_Z100:
			z.scale = 1;
			Sys_UpdateWindows (W_Z|W_Z_OVERLAY);
			break;
		case ID_VIEW_ZZOOMIN:
			z.scale *= 5.0/4;
			if (z.scale > 4)
				z.scale = 4;
			Sys_UpdateWindows (W_Z|W_Z_OVERLAY);
			break;
		case ID_VIEW_ZZOOMOUT:
			z.scale *= 4.0/5;
			if (z.scale < 0.125)
				z.scale = 0.125;
			Sys_UpdateWindows (W_Z|W_Z_OVERLAY);
			break;

		case ID_VIEW_CENTER:
			camera.angles[ROLL] = camera.angles[PITCH] = 0;
			camera.angles[YAW] = 22.5 * 
				floor( (camera.angles[YAW]+11)/22.5 );
			Sys_UpdateWindows (W_CAMERA|W_XY_OVERLAY);
			break;

		case ID_VIEW_UPFLOOR:
			Cam_ChangeFloor (true);
			break;
		case ID_VIEW_DOWNFLOOR:
			Cam_ChangeFloor (false);
			break;

		case ID_VIEW_SHOWNAMES:
			g_qeglobals.d_savedinfo.show_names = !g_qeglobals.d_savedinfo.show_names;
			CheckMenuItem ( GetMenu(g_qeglobals.d_hwndMain), ID_VIEW_SHOWNAMES, MF_BYCOMMAND | (g_qeglobals.d_savedinfo.show_names ? MF_CHECKED : MF_UNCHECKED)  );
			Map_BuildBrushData();
			Sys_UpdateWindows (W_XY);
			break;

		case ID_VIEW_SHOWCOORDINATES:
			g_qeglobals.d_savedinfo.show_coordinates ^= 1;
			CheckMenuItem ( GetMenu(g_qeglobals.d_hwndMain), ID_VIEW_SHOWCOORDINATES, MF_BYCOMMAND | (g_qeglobals.d_savedinfo.show_coordinates ? MF_CHECKED : MF_UNCHECKED)  );
			Sys_UpdateWindows (W_XY);
			break;

		case ID_VIEW_SHOWBLOCKS:
			g_qeglobals.show_blocks ^= 1;
			CheckMenuItem ( GetMenu(g_qeglobals.d_hwndMain), ID_VIEW_SHOWBLOCKS, MF_BYCOMMAND | (g_qeglobals.show_blocks ? MF_CHECKED : MF_UNCHECKED)  );
			Sys_UpdateWindows (W_XY);
			break;

		case ID_VIEW_SHOWLIGHTS:
			if ( ( g_qeglobals.d_savedinfo.exclude ^= EXCLUDE_LIGHTS ) & EXCLUDE_LIGHTS )
				CheckMenuItem ( GetMenu(g_qeglobals.d_hwndMain), ID_VIEW_SHOWLIGHTS, MF_BYCOMMAND | MF_UNCHECKED );
			else
				CheckMenuItem ( GetMenu(g_qeglobals.d_hwndMain), ID_VIEW_SHOWLIGHTS, MF_BYCOMMAND | MF_CHECKED );				
			Sys_UpdateWindows (W_XY|W_CAMERA);
			break;

		case ID_VIEW_SHOWPATH:
			if ( ( g_qeglobals.d_savedinfo.exclude ^= EXCLUDE_PATHS ) & EXCLUDE_PATHS )
				CheckMenuItem ( GetMenu(g_qeglobals.d_hwndMain), ID_VIEW_SHOWPATH, MF_BYCOMMAND | MF_UNCHECKED );
			else
				CheckMenuItem ( GetMenu(g_qeglobals.d_hwndMain), ID_VIEW_SHOWPATH, MF_BYCOMMAND | MF_CHECKED );
			Sys_UpdateWindows (W_XY|W_CAMERA);
			break;

		case ID_VIEW_SHOWENT:
			if ( ( g_qeglobals.d_savedinfo.exclude ^= EXCLUDE_ENT ) & EXCLUDE_ENT )
				CheckMenuItem( GetMenu(g_qeglobals.d_hwndMain), ID_VIEW_SHOWENT, MF_BYCOMMAND | MF_UNCHECKED);
			else
				CheckMenuItem( GetMenu(g_qeglobals.d_hwndMain), ID_VIEW_SHOWENT, MF_BYCOMMAND | MF_CHECKED);
			Sys_UpdateWindows (W_XY|W_CAMERA);
			break;

		case ID_VIEW_SHOWWATER:
			if ( ( g_qeglobals.d_savedinfo.exclude ^= EXCLUDE_WATER ) & EXCLUDE_WATER )
				CheckMenuItem ( GetMenu(g_qeglobals.d_hwndMain), ID_VIEW_SHOWWATER, MF_BYCOMMAND | MF_UNCHECKED );
			else
				CheckMenuItem ( GetMenu(g_qeglobals.d_hwndMain), ID_VIEW_SHOWWATER, MF_BYCOMMAND | MF_CHECKED );
			Sys_UpdateWindows (W_XY|W_CAMERA);
			break;

		case ID_VIEW_SHOWCLIP:
			if ( ( g_qeglobals.d_savedinfo.exclude ^= EXCLUDE_CLIP ) & EXCLUDE_CLIP )
				CheckMenuItem ( GetMenu(g_qeglobals.d_hwndMain), ID_VIEW_SHOWCLIP, MF_BYCOMMAND | MF_UNCHECKED );
			else
				CheckMenuItem ( GetMenu(g_qeglobals.d_hwndMain), ID_VIEW_SHOWCLIP, MF_BYCOMMAND | MF_CHECKED );
			Sys_UpdateWindows (W_XY|W_CAMERA);
			break;

		case ID_VIEW_SHOWDETAIL:
			if ( ( g_qeglobals.d_savedinfo.exclude ^= EXCLUDE_DETAIL ) & EXCLUDE_DETAIL )
			{
				CheckMenuItem ( GetMenu(g_qeglobals.d_hwndMain), ID_VIEW_SHOWDETAIL, MF_BYCOMMAND | MF_UNCHECKED );
				SetWindowText (g_qeglobals.d_hwndCamera, "Camera View (DETAIL EXCLUDED)");
			}
			else
			{
				CheckMenuItem ( GetMenu(g_qeglobals.d_hwndMain), ID_VIEW_SHOWDETAIL, MF_BYCOMMAND | MF_CHECKED );
				SetWindowText (g_qeglobals.d_hwndCamera, "Camera View");
			}
			Sys_UpdateWindows (W_XY|W_CAMERA);
			break;

		case ID_VIEW_SHOWWORLD:
			if ( ( g_qeglobals.d_savedinfo.exclude ^= EXCLUDE_WORLD ) & EXCLUDE_WORLD )
				CheckMenuItem ( GetMenu(g_qeglobals.d_hwndMain), ID_VIEW_SHOWWORLD, MF_BYCOMMAND | MF_UNCHECKED );
			else
				CheckMenuItem ( GetMenu(g_qeglobals.d_hwndMain), ID_VIEW_SHOWWORLD, MF_BYCOMMAND | MF_CHECKED );
			Sys_UpdateWindows (W_XY|W_CAMERA);
			break;


//
// grid menu
//
		case ID_GRID_1:
		case ID_GRID_2:
		case ID_GRID_4:
		case ID_GRID_8:
		case ID_GRID_16:
		case ID_GRID_32:
		case ID_GRID_64:
		{
			hMenu = GetMenu(hWnd);
			
			CheckMenuItem(hMenu, ID_GRID_1, MF_BYCOMMAND | MF_UNCHECKED);
			CheckMenuItem(hMenu, ID_GRID_2, MF_BYCOMMAND | MF_UNCHECKED);
			CheckMenuItem(hMenu, ID_GRID_4, MF_BYCOMMAND | MF_UNCHECKED);
			CheckMenuItem(hMenu, ID_GRID_8, MF_BYCOMMAND | MF_UNCHECKED);
			CheckMenuItem(hMenu, ID_GRID_16, MF_BYCOMMAND | MF_UNCHECKED);
			CheckMenuItem(hMenu, ID_GRID_32, MF_BYCOMMAND | MF_UNCHECKED);
			CheckMenuItem(hMenu, ID_GRID_64, MF_BYCOMMAND | MF_UNCHECKED);

			switch (LOWORD(wParam))
			{
				case ID_GRID_1: g_qeglobals.d_gridsize = 0; break;
				case ID_GRID_2: g_qeglobals.d_gridsize = 1; break;
				case ID_GRID_4: g_qeglobals.d_gridsize = 2; break;
				case ID_GRID_8: g_qeglobals.d_gridsize = 3; break;
				case ID_GRID_16: g_qeglobals.d_gridsize = 4; break;
				case ID_GRID_32: g_qeglobals.d_gridsize = 5; break;
				case ID_GRID_64: g_qeglobals.d_gridsize = 6; break;
			}
			g_qeglobals.d_gridsize = 1 << g_qeglobals.d_gridsize;

			CheckMenuItem(hMenu, LOWORD(wParam), MF_BYCOMMAND | MF_CHECKED);
			Sys_UpdateWindows (W_XY|W_Z);
			break;
		}

//
// texture menu
//
		case ID_VIEW_NEAREST:					
		case ID_VIEW_NEARESTMIPMAP:
		case ID_VIEW_LINEAR:
		case ID_VIEW_BILINEAR:
		case ID_VIEW_BILINEARMIPMAP:
		case ID_VIEW_TRILINEAR:
		case ID_TEXTURES_WIREFRAME:
		case ID_TEXTURES_FLATSHADE:
			Texture_SetMode (LOWORD(wParam));
			break;

		case ID_TEXTURES_SHOWINUSE:
			Sys_BeginWait ();
			Texture_ShowInuse ();
			SetInspectorMode(W_TEXTURE);
			break;

		case ID_TEXTURES_INSPECTOR:
			DoSurface ();
			break;

		case CMD_TEXTUREWAD:
		case CMD_TEXTUREWAD+1:
		case CMD_TEXTUREWAD+2:
		case CMD_TEXTUREWAD+3:
		case CMD_TEXTUREWAD+4:
		case CMD_TEXTUREWAD+5:
		case CMD_TEXTUREWAD+6:
		case CMD_TEXTUREWAD+7:
		case CMD_TEXTUREWAD+8:
		case CMD_TEXTUREWAD+9:
		case CMD_TEXTUREWAD+10:
		case CMD_TEXTUREWAD+11:
		case CMD_TEXTUREWAD+12:
		case CMD_TEXTUREWAD+13:
		case CMD_TEXTUREWAD+14:
		case CMD_TEXTUREWAD+15:
		case CMD_TEXTUREWAD+16:
		case CMD_TEXTUREWAD+17:
		case CMD_TEXTUREWAD+18:
		case CMD_TEXTUREWAD+19:
		case CMD_TEXTUREWAD+20:
		case CMD_TEXTUREWAD+21:
		case CMD_TEXTUREWAD+22:
		case CMD_TEXTUREWAD+23:
		case CMD_TEXTUREWAD+24:
		case CMD_TEXTUREWAD+25:
		case CMD_TEXTUREWAD+26:
		case CMD_TEXTUREWAD+27:
		case CMD_TEXTUREWAD+28:
		case CMD_TEXTUREWAD+29:
		case CMD_TEXTUREWAD+30:
		case CMD_TEXTUREWAD+31:
			Sys_BeginWait ();
			Texture_ShowDirectory (LOWORD(wParam));
			SetInspectorMode(W_TEXTURE);
			break;

//
// bsp menu
//
		case CMD_BSPCOMMAND:
		case CMD_BSPCOMMAND+1:
		case CMD_BSPCOMMAND+2:
		case CMD_BSPCOMMAND+3:
		case CMD_BSPCOMMAND+4:
		case CMD_BSPCOMMAND+5:
		case CMD_BSPCOMMAND+6:
		case CMD_BSPCOMMAND+7:
		case CMD_BSPCOMMAND+8:
		case CMD_BSPCOMMAND+9:
		case CMD_BSPCOMMAND+10:
		case CMD_BSPCOMMAND+11:
		case CMD_BSPCOMMAND+12:
		case CMD_BSPCOMMAND+13:
		case CMD_BSPCOMMAND+14:
		case CMD_BSPCOMMAND+15:
		case CMD_BSPCOMMAND+16:
		case CMD_BSPCOMMAND+17:
		case CMD_BSPCOMMAND+18:
		case CMD_BSPCOMMAND+19:
		case CMD_BSPCOMMAND+20:
		case CMD_BSPCOMMAND+21:
		case CMD_BSPCOMMAND+22:
		case CMD_BSPCOMMAND+23:
		case CMD_BSPCOMMAND+24:
		case CMD_BSPCOMMAND+25:
		case CMD_BSPCOMMAND+26:
		case CMD_BSPCOMMAND+27:
		case CMD_BSPCOMMAND+28:
		case CMD_BSPCOMMAND+29:
		case CMD_BSPCOMMAND+30:
		case CMD_BSPCOMMAND+31:
			{
				extern	char	*bsp_commands[256];

				RunBsp (bsp_commands[LOWORD(wParam-CMD_BSPCOMMAND)]);
			}
			break;

//
// misc menu
//
		case ID_MISC_BENCHMARK:
			SendMessage ( g_qeglobals.d_hwndCamera,
			WM_USER+267,	0, 0);
			break;

		case ID_TEXTUREBK:
			DoColor(COLOR_TEXTUREBACK);
			Sys_UpdateWindows (W_ALL);
			break;

		case ID_MISC_SELECTENTITYCOLOR:
			{
				extern int inspector_mode;
				
				if ( ( inspector_mode == W_ENTITY ) && DoColor(COLOR_ENTITY) == true )
				{
					extern void AddProp( void );
					
					char buffer[100];
					
					sprintf( buffer, "%f %f %f", g_qeglobals.d_savedinfo.colors[COLOR_ENTITY][0],
						g_qeglobals.d_savedinfo.colors[COLOR_ENTITY][1],
						g_qeglobals.d_savedinfo.colors[COLOR_ENTITY][2] );
					
					SetWindowText( hwndEnt[EntValueField], buffer );
					SetWindowText( hwndEnt[EntKeyField], "_color" );
					AddProp();
				}
				Sys_UpdateWindows( W_ALL );
			}
			break;

		case ID_MISC_PRINTXY:
			WXY_Print();
			break;

		case ID_COLORS_XYBK:
			DoColor(COLOR_GRIDBACK);
			Sys_UpdateWindows (W_ALL);
			break;

		case ID_COLORS_MAJOR:
			DoColor(COLOR_GRIDMAJOR);
			Sys_UpdateWindows (W_ALL);
			break;

		case ID_COLORS_MINOR:
			DoColor(COLOR_GRIDMINOR);
			Sys_UpdateWindows (W_ALL);
			break;

		case ID_MISC_GAMMA:
			DoGamma();
			break;

		case ID_MISC_FINDBRUSH:
			DoFind();
			break;

		case ID_MISC_NEXTLEAKSPOT:
			Pointfile_Next();
			break;
		case ID_MISC_PREVIOUSLEAKSPOT:
			Pointfile_Prev();
			break;

//
// brush menu
//
		case ID_BRUSH_3SIDED:
			Brush_MakeSided (3);
			break;
		case ID_BRUSH_4SIDED:
			Brush_MakeSided (4);
			break;
		case ID_BRUSH_5SIDED:
			Brush_MakeSided (5);
			break;
		case ID_BRUSH_6SIDED:
			Brush_MakeSided (6);
			break;
		case ID_BRUSH_7SIDED:
			Brush_MakeSided (7);
			break;
		case ID_BRUSH_8SIDED:
			Brush_MakeSided (8);
			break;
		case ID_BRUSH_9SIDED:
			Brush_MakeSided (9);
			break;
		case ID_BRUSH_ARBITRARYSIDED:
			DoSides ();
			break;

//
// select menu
//
		case ID_BRUSH_FLIPX:
			Select_FlipAxis (0);
			break;
		case ID_BRUSH_FLIPY:
			Select_FlipAxis (1);
			break;
		case ID_BRUSH_FLIPZ:
			Select_FlipAxis (2);
			break;
		case ID_BRUSH_ROTATEX:
			Select_RotateAxis (0, 90);
			break;
		case ID_BRUSH_ROTATEY:
			Select_RotateAxis (1, 90);
			break;
		case ID_BRUSH_ROTATEZ:
			Select_RotateAxis (2, 90);
			break;

		case ID_SELECTION_ARBITRARYROTATION:
			DoRotate ();
			break;

		case ID_SELECTION_UNGROUPENTITY:
			Select_Ungroup ();
			break;

		case ID_SELECTION_CONNECT:
			ConnectEntities ();
			break;

		case ID_SELECTION_DRAGVERTECIES:
			if (g_qeglobals.d_select_mode == sel_vertex)
			{
				g_qeglobals.d_select_mode = sel_brush;
				Sys_UpdateWindows (W_ALL);
			}
			else
			{
				SetupVertexSelection ();
				if (g_qeglobals.d_numpoints)
					g_qeglobals.d_select_mode = sel_vertex;
			}
			break;
		case ID_SELECTION_DRAGEDGES:
			if (g_qeglobals.d_select_mode == sel_edge)
			{
				g_qeglobals.d_select_mode = sel_brush;
				Sys_UpdateWindows (W_ALL);
			}
			else
			{
				SetupVertexSelection ();
				if (g_qeglobals.d_numpoints)
					g_qeglobals.d_select_mode = sel_edge;
			}
			break;

		case ID_SELECTION_SELECTPARTIALTALL:
			Select_PartialTall ();
			break;
		case ID_SELECTION_SELECTCOMPLETETALL:
			Select_CompleteTall ();
			break;
		case ID_SELECTION_SELECTTOUCHING:
			Select_Touching ();
			break;
		case ID_SELECTION_SELECTINSIDE:
			Select_Inside ();
			break;
		case ID_SELECTION_CSGSUBTRACT:
			CSG_Subtract ();
			break;
		case ID_SELECTION_MAKEHOLLOW:
			CSG_MakeHollow ();
			break;

		case ID_SELECTION_CLONE:
			Select_Clone ();
			break;
		case ID_SELECTION_DELETE:
			Select_Delete ();
			break;
		case ID_SELECTION_DESELECT:
			Select_Deselect ();
			break;

		case ID_SELECTION_MAKE_DETAIL:
			Select_MakeDetail ();
			break;
		case ID_SELECTION_MAKE_STRUCTURAL:
			Select_MakeStructural ();
			break;


//
// region menu
//
		case ID_REGION_OFF:
			Map_RegionOff ();
			break;
		case ID_REGION_SETXY:
			Map_RegionXY ();
			break;
		case ID_REGION_SETTALLBRUSH:
			Map_RegionTallBrush ();
			break;
		case ID_REGION_SETBRUSH:
			Map_RegionBrush ();
			break;
		case ID_REGION_SETSELECTION:
			Map_RegionSelectedBrushes ();
			break;

		case IDMRU+1:
		case IDMRU+2:
		case IDMRU+3:
		case IDMRU+4:
		case IDMRU+5:
		case IDMRU+6:
		case IDMRU+7:
		case IDMRU+8:
		case IDMRU+9:
			DoMru(hWnd,LOWORD(wParam));
			break;

//
// help menu
//

		case ID_HELP_ABOUT:
			DoAbout();
			break;

		default:
            return FALSE;
    }

    return TRUE;
}