Esempio n. 1
0
void
TitlebarImpl::draw()
{
  CL_Display::push_translate(parent->get_screen_x(), parent->get_screen_y());

  // FIXME: Hack should be done via has_mouse_over(), but that doesn't include child components
  if (parent->get_parent()->get_position().is_inside(CL_Point(CL_Mouse::get_x(),
                                                              CL_Mouse::get_y())))
    //parent->get_parent()->has_mouse_over())
  {
    CL_Display::fill_rect(CL_Rect(CL_Point(0, 0),
                                  CL_Size(parent->get_width()-1, parent->get_height())),
                          CL_Color(250, 250, 250));
  }
  else
  {
    CL_Display::fill_rect(CL_Rect(CL_Point(0, 0),
                                  CL_Size(parent->get_width()-1, parent->get_height())),
                          CL_Color(240, 240, 240));
  }

  Fonts::verdana11.draw(4, 0, title);

  CL_Display::pop_modelview();
}
Esempio n. 2
0
void 
Radar::draw(CL_GraphicContext& gc)
{
  FloatVector2d end(0.0f, 64.0f);

  end = end.rotate(angle);

  end += pos;

  background.draw(int(pos.x), int(pos.y), &gc);
  
  GameObjManager* objs = GameWorld::current()->get_game_obj_manager();
  for (GameObjManager::iterator i = objs->begin(); i != objs->end(); ++i)
    {
      (*i)->draw_radar(*this);
    }

  GameWorld::current()->get_buildingmap()->draw_radar(*this);

  CL_Display::draw_line(int(pos.x), int(pos.y - 5),
                        int(pos.x), int(pos.y + 5),
                        CL_Color(0, 255, 0));

  CL_Display::draw_line(int(pos.x - 5), int(pos.y),
                        int(pos.x + 5), int(pos.y),
                        CL_Color(0, 255, 0));
}
Esempio n. 3
0
void
TileMapPaintToolImpl::draw()
{
  TilemapLayer tilemap = TilemapLayer::current();

  if (tilemap.is_null())
    return;

  switch(mode)
  {
    case TileMapPaintToolImpl::SELECTING:
      if (CL_Keyboard::get_keycode(CL_KEY_LSHIFT))
        selection.draw(CL_Color(255,  128, 128, 100));
      else 
        selection.draw();
      break;
      
    default:
      int tile_size = tilemap.get_tileset().get_tile_size();

      // Draw the brush:
      for(int y = 0; y < brush.get_height(); ++y)
        for(int x = 0; x < brush.get_width(); ++x)
        {
          Tile* tile = tilemap.get_tileset().create(brush.at(x, y));
                
          if (tile)
          {
            CL_Sprite sprite = tile->get_sprite();
            sprite.set_alpha(0.5f);
            sprite.draw((current_tile.x + x) * tile_size, 
                        (current_tile.y + y) * tile_size);

            CL_Display::fill_rect(CL_Rect(CL_Point((current_tile.x + x) * tile_size, 
                                                   (current_tile.y + y) * tile_size),
                                          CL_Size(tile_size, tile_size)),
                                  CL_Color(255, 255, 255, 100));
          }
          else if (brush.is_opaque())
          {
            CL_Display::fill_rect(CL_Rect(CL_Point((current_tile.x + x) * tile_size, 
                                                   (current_tile.y + y) * tile_size),
                                          CL_Size(tile_size, tile_size)),
                                  CL_Color(255, 255, 255, 100));
          }
          else
          {
            CL_Display::fill_rect(CL_Rect(CL_Point((current_tile.x + x) * tile_size, 
                                                   (current_tile.y + y) * tile_size),
                                          CL_Size(tile_size, tile_size)),
                                  CL_Color(255, 255, 255, 50));
          }
        }
      break;
  }
}
Esempio n. 4
0
void PlayNode::Draw(CL_Rect area)
{
	CL_Display::fill_rect(area, CL_Gradient(CL_Color(0,0,54), CL_Color(54,0,100), CL_Color(100, 50, 0), CL_Color(100, 0, 55)));
	
	mapRect = CL_Rect(area.left + 300, area.top + 100, area.right - 100, area.bottom - 100);
	mapNode->Draw(mapRect);

	inventoryRect = CL_Rect(area.left + 50, area.top + 100, area.left + 250, area.bottom - 100);
	inventoryNode->Draw(inventoryRect);
}
void CL_TreeItem_Silver::on_paint()
{
	CL_Rect rect = item->get_screen_rect();
	
	int height = rect.get_height();
	int font_height = font->get_height(item->get_text(0));
	
	if(item->has_mouse_over())
		CL_Display::fill_rect(rect, CL_Color(232, 236, 241));
	if(item->get_node()->is_selected())
		CL_Display::fill_rect(rect, CL_Color(184, 195, 209, 150));

	CL_TreeView *treeview = item->get_node()->get_treeview();
	int columns = treeview->get_column_count();
	if(columns == 0)
		columns = 1;

	// Draw columns
	for(int x = 0, i = 0; i < columns; ++i)
	{
		int dx = 0;
		if(i == 0)
		{
			dx += item->get_text_margin();

			CL_Surface *icon = item->get_icon();
			if(icon)
			{
				icon->draw(
					rect.left + x + 1,
					rect.top + (height - icon->get_height()) / 2);
				dx += icon->get_width();
			}
		}

		CL_Component *comp = item->get_component(i);
		if(comp)
		{
			comp->set_position(CL_Rect(x + dx + 4, 0, x + dx + 4 + treeview->get_column_width(i), height));
			comp->paint();
		}
		else
		{
			font->draw(
				rect.left + x + dx + 4,
				rect.top + (height - font_height) / 2,
				item->get_text(i));
		}

		x += treeview->get_column_width(i);
		if(i == 0)
			x -= item->get_node()->get_placement_offset();
	}
}
Esempio n. 6
0
EditorMap::EditorMap(bool create) :
  impl()
{
  if (create)
  {
    impl.reset(new EditorMapImpl());
    impl->background_color = CL_Color(100, 80, 100);
    impl->foreground_color = CL_Color(255, 80, 255);
    impl->modified = false;
    impl->serial = 0;
    impl->has_bounding_rect = false;
    impl->bounding_rect = CL_Rect(0,0,0,0);
  }
}
void
CollisionManager::draw(View& view)
{
    for(Shapes::iterator i = shapes.begin(); i != shapes.end(); ++i)
    {
        switch (i->type)
        {
        case SHAPE_CIRCLE:
            view.get_sc().color().draw_circle(i->circle.x, i->circle.y, i->circle.radius,
                                              CL_Color(255, 0, 0));
            break;
        case SHAPE_RECT:
        {
            CL_Color color(255, 0, 0);
            Math::Quad quad = rect2quad(i->rect);
            view.get_sc().color().draw_line(quad.a.x, quad.a.y, quad.b.x, quad.b.y, color);
            view.get_sc().color().draw_line(quad.b.x, quad.b.y, quad.c.x, quad.c.y, color);
            view.get_sc().color().draw_line(quad.c.x, quad.c.y, quad.d.x, quad.d.y, color);
            view.get_sc().color().draw_line(quad.d.x, quad.d.y, quad.a.x, quad.a.y, color);
        }
        break;
        default:
            std::cout << "CollisionManager: unhandled type: " << i->type << std::endl;
        }
    }
}
Esempio n. 8
0
void
Slider::draw()
{
  CL_Display::push_modelview();
  CL_Display::add_translate(get_screen_x(), get_screen_y());
    
  CL_Display::fill_rect(CL_Rect(CL_Point(0, get_height()/2 - 2),
                                CL_Size(get_width(), 5)),
                        CL_Color(255, 255, 255, 255));

  CL_Display::fill_rect(CL_Rect(CL_Point(int(-2 + (value/(end-start)) * get_width()), 0),
                                CL_Size(5, get_height())),
                        CL_Color(0, 0, 0, 255));

  CL_Display::pop_modelview();    
}
Esempio n. 9
0
/** Builds the dialog screen.
*/
void
CADialog::buildScreen() {
    // Menu Backgroud:
    //
    if( !modal ) CA_RES->menu_bg->draw( CL_Rect(0,0, CA_APP->width,CA_APP->height) );

    int ew = CA_RES->gui_edge2->get_width();
    int eh = CA_RES->gui_edge2->get_height();
    int bw = CA_RES->gui_border2->get_width();
    int bh = CA_RES->gui_border1->get_height();

    CL_Display::fill_rect( CL_Rect(left+bw, top+bh, right-bw, bottom-bh), CL_Color(0, 0, 0, 64) );

    // Edges:
    //
    CA_RES->gui_edge1->draw( left, top );
    CA_RES->gui_edge2->draw( right-ew, top );
    CA_RES->gui_edge3->draw( left, bottom-eh );
    CA_RES->gui_edge4->draw( right-ew, bottom-eh );

    // Borders:
    //
    CA_RES->gui_border1->draw( CL_Rect(left+ew, top, left+ew+width-2*ew, top+bh) );
    CA_RES->gui_border2->draw( CL_Rect(right-bw, top+eh, right-bw+bw, top+eh+height-2*eh) );
    CA_RES->gui_border3->draw( CL_Rect(left+ew, bottom-bh, left+ew+width-2*ew, bottom-bh+bh) );
    CA_RES->gui_border4->draw( CL_Rect(left, top+eh, left+bw, top+eh+height-2*eh) );
}
Esempio n. 10
0
void
Radar::draw_blip(const FloatVector2d& arg_pos, int size,
                 float red, float green, float blue)
{
  // Callculate the distance between 'pos' and the vehicle that holds
  // the radar
  FloatVector2d diff = arg_pos;

  diff -= player->get_current_unit()->get_pos();
  diff *= 1/30.0f;

  float alpha =(diff.get_length() / 64.0);
  alpha *= alpha * alpha;
  alpha = 1.0f - alpha;

  if (diff.get_length() < 64.0)
    {
      //diff = diff.rotate(-vehicle->get_angle () + (3.14159/2), FloatVector2d (0, 0, 1.0));
      
      CL_Display::fill_rect(CL_Rect(int(pos.x + diff.x) - size, int(pos.y + diff.y) - size,
                                    int(pos.x + diff.x) + size, int(pos.y + diff.y) + size),
                            CL_Color(int(255*red),
                                     int(255*green),
                                     int(255*blue), 
                                     int(255*alpha)));
    }
}
void CL_TreeView_Silver::on_paint_header()
{
	// Header
	if(treeview->is_header_visible())
	{
		CL_Rect rect = header_area->get_screen_rect();

		// Header background
		CL_Display::fill_rect(
			CL_Rect(
				rect.left + 1,
				rect.top + 1,
				rect.left + rect.get_width() - 1,
				rect.top + rect.get_height() - 4),
			CL_Gradient(
				CL_Color(245, 246, 247), CL_Color(245, 246, 247), CL_Color(235, 238, 241), CL_Color(235, 238, 241)));

		CL_Display::fill_rect(
			CL_Rect(
				rect.left + 1,
				rect.top + rect.get_height() - 4,
				rect.left + rect.get_width() - 1,
				rect.top + rect.get_height()),
			CL_Gradient(
				CL_Color(235, 238, 241), CL_Color(235, 238, 241), CL_Color(186, 187, 188), CL_Color(186, 187, 188)));

		// Draw columns
		int x = 0;
		int columns = treeview->get_column_count();
		for(int i = 0; i < columns; ++i)
		{
			font->draw(
				rect.left + x + 6,
				rect.top + 4, treeview->get_column_name(i));
				
			x += treeview->get_column_width(i);
			
			CL_Display::draw_line(
				rect.left + x,
				rect.top + 1,
				rect.left + x,
				rect.top + rect.get_height(),
				CL_Color(128, 142, 159));
			CL_Display::draw_line(
				rect.left + x + 1,
				rect.top + 1,
				rect.left + x + 1,
				rect.top + rect.get_height(),
				CL_Color::white);
		}
	}
}
void
MenuItem::draw(int x, int y)
{
  CL_Display::fill_rect(CL_Rect(x, y, x + 150, y + Fonts::font.get_height() + 2),
                        CL_Color(85,85,0, 230));
  Fonts::font.set_alignment(origin_top_left);
  Fonts::font.draw(x + 10, y + 1, label);
}
Esempio n. 13
0
void L_Particle::draw(CL_GraphicContext &gc, int x_shift, int y_shift)
{

	surface->set_scale(current_size,current_size);
	surface->set_angle(CL_Angle(current_radian, cl_radians));
	surface->set_color( CL_Color(current_color.r,current_color.g,current_color.b,current_color.a) );
	surface->draw(gc, x_pos+x_shift, y_pos+y_shift);
}
Esempio n. 14
0
CL_Color
Tile::calc_color()
{
  CL_PixelBuffer buffer = get_pixelbuffer();
  buffer.lock();
  unsigned char* buf = static_cast<unsigned char*>(buffer.get_data());
  int len = buffer.get_height() * buffer.get_width();

  int red   = 0;
  int green = 0;
  int blue  = 0;
  int alpha = 0;
  
  switch (buffer.get_format().get_depth())
  {
    case 8:
    {
      CL_Palette palette = buffer.get_palette();
      for(int i = 0; i < len; ++i)
      {
        red   += palette.colors[buf[i]].get_red();
        green += palette.colors[buf[i]].get_green();
        blue  += palette.colors[buf[i]].get_blue();
        alpha += 255;
      }
    }
    break;
    case 24:
      for(int i = 0; i < len; ++i)
      {
        red   += buf[3*i + 0];
        green += buf[3*i + 1];
        blue  += buf[3*i + 2];
        alpha += 255;
      }
      break;
    case 32:
      for(int i = 0; i < len; ++i)
      {
        int a = buf[4*i + 0];
        alpha += a;
        red   += buf[4*i + 3]*a/255;;
        green += buf[4*i + 2]*a/255;;
        blue  += buf[4*i + 1]*a/255;;
      }
      break;
  }

  buffer.unlock();

  return CL_Color(static_cast<int>(red   / len),
                  static_cast<int>(green / len),
                  static_cast<int>(blue  / len),
                  static_cast<int>(alpha / len));
}
void 
StartScreen::draw ()
{
  if (logo_mode == S_STARTLOGO)
    {
      if (display_time <= 2.0f)
	logo.set_alpha ((display_time/2.0f));
      else
	logo.set_alpha (1.0f);
  
      //FIXME:Display2 CL_Display::clear_display ();    
      
      logo.draw (CL_Display::get_width ()/2,
		 CL_Display::get_height ()/2,
		 display->get_gc ());
    }
  else if (logo_mode == S_FADETOGAME)
    {
      if (display_time <= 1.5f)
	{
	  logo.set_alpha (1.0f - (display_time/1.5f));
	  logo.draw (CL_Display::get_width ()/2,
		     CL_Display::get_height ()/2,
		     display->get_gc ());
	}
      else
	logo_mode = S_GAME;
    }
  else if (logo_mode == S_GAME)
    {
      // do nothing
    }
  else if (logo_mode == S_ENDLOGO)
    {
      if (display_time <= 1.5f)
	  endlogo.set_alpha ((display_time/1.5f));
      else
	  endlogo.set_alpha (1.0f);

      endlogo.draw (CL_Display::get_width ()/2,
		    CL_Display::get_height ()/2);
    }
  else if (logo_mode == S_FADETOBLACK)
    {
      endlogo.set_alpha (1.0f);
      endlogo.draw (CL_Display::get_width ()/2,
		    CL_Display::get_height ()/2);

      CL_Display::fill_rect (CL_Rect(0, 0, CL_Display::get_width (), CL_Display::get_height ()),
			     CL_Color(0, 0, 0, int(255.0f * display_time/2.0f)));
      if (display_time >= 2.0f)
	logo_mode = S_QUIT;
    }
}
Esempio n. 16
0
void
OnionSkinLayer::update()
{
  impl->canvas->get_gc()->clear(CL_Color(0, 0, 0, 0));
  for (std::vector<EditorMap>::size_type i = 0; i < impl->editormaps.size(); ++i)
  {
    impl->canvas2->get_gc()->clear(CL_Color(0, 0, 0, 0));
    impl->canvas2->get_gc()->push_modelview();
    impl->canvas2->get_gc()->add_scale(1.0f/SCALE, 1.0f/SCALE);

    impl->editormaps[i].draw(EditorMapComponent::current()->get_gc_state(), impl->canvas2->get_gc());

    impl->canvas2->get_gc()->pop_modelview();

    impl->canvas2->sync_surface();

    impl->surface2.set_color(impl->color[i]);
    impl->surface2.draw(0, 0, impl->canvas->get_gc());
    impl->canvas->sync_surface();
  }
}
Esempio n. 17
0
void
TileEditor::draw()
{
  CL_Display::push_translate(get_screen_x(), get_screen_x());

  //no_tile.draw(0, 0);
  CL_Display::fill_rect(CL_Rect(0, 0, 32, 32), CL_Color(155, 0, 155));

  if (tile)
  {
    tile->get_sprite().draw(0, 0);
    CL_Display::flush();
    for(int tile_y = 0; tile_y < 8; ++tile_y)
      for(int tile_x = 0; tile_x < 8; ++tile_x)
      {
        if (tile->get_col(tile_x, tile_y))
        {
          CL_Display::fill_rect(CL_Rect(tile_x*16, tile_y*16,
                                        tile_x*16 + 16, tile_y*16 + 16),
                                CL_Color(255, 0, 0, 128));
        }
      }
    CL_Display::flush();
    if (has_mouse_over())
    {
      CL_Display::fill_rect(CL_Rect(CL_Point(int(mouse_pos.x)/16 * 16, 
                                             int(mouse_pos.y)/16 * 16),
                                    CL_Size(16, 16)),
                            CL_Color(255, 255, 255, 128));
    }
  }
  else
  {
  }

  CL_Display::pop_modelview();
}
Esempio n. 18
0
OnionSkinLayer::OnionSkinLayer(int width, int height) :
  impl(new OnionSkinLayerImpl())
{
  impl->surface  = CL_Surface(CL_PixelBuffer(width/SCALE, height/SCALE, width*4/SCALE, CL_PixelFormat::rgba8888));
  impl->surface2 = CL_Surface(CL_PixelBuffer(width/SCALE, height/SCALE, width*4/SCALE, CL_PixelFormat::rgba8888));

  try
  {
    impl->canvas = new CL_Canvas(impl->surface);
    impl->canvas->get_gc()->clear(CL_Color(0, 0, 0, 0));
    impl->canvas->get_gc()->flush();
    impl->canvas->sync_surface();

    impl->canvas2 = new CL_Canvas(impl->surface2);
    impl->canvas2->get_gc()->clear(CL_Color(0, 0, 0, 0));
    impl->canvas2->get_gc()->flush();
    impl->canvas2->sync_surface();
  }
  catch(CL_Error& err)
  {
    std::cout << "CL_Error: " << err.message << std::endl;
    throw err;
  }
}
Esempio n. 19
0
CL_ColorHSVi::operator CL_Color()
{
	int hue = cl_min(359,cl_max(0,h));
	int saturation = cl_min(255,cl_max(0,s));	
	int value = cl_min(255,cl_max(0,v));
	if (saturation == 0)
	{
		return CL_Color(value, value, value, a);
	}

	int section = (int)(hue / 60);
	int f = ((hue*256) / 60) - (section*256);
	int p = (value * (255 - saturation))/255;
	int q = (value * (255 - ((saturation * f) /256) ))/255;
	int t = (value * (255 - ((saturation * (256 - f)) / 256) ))/255;
	if (section == 1)
	{
		return CL_Color(q, value, p, a);
	}
	if (section == 2)
	{
		return CL_Color(p, value, t, a);
	}
	if (section == 3)
	{
		return CL_Color(p, q, value, a);
	}
	if (section == 4)
	{
		return CL_Color(t, p, value, a);
	}
	if (section == 5)
	{
		return CL_Color(value, p, q, a);
	}
	return CL_Color(value, t, p, a);
}
Esempio n. 20
0
CGameMenu::CGameMenu(CGame* _game)
{
	pointer=new CL_Sprite("menu/pointer",_game->GetResman());
	title=new CL_Sprite("menu/title",_game->GetResman());
	darktitle=new CL_Sprite("menu/darktitle",_game->GetResman());
	devby=new CL_Sprite("menu/devby",_game->GetResman());
	copyright=new CL_Sprite("intro/copyright", _game->GetResman());

	fnt_about=CMisc::fnt_about;
	about_str=new string;
	*about_str=CL_String::load("about", _game->GetResman());

	context_main.sprites[0].spr=darktitle;
	context_main.sprites[0].pos=CL_Point(150,0);
	context_main.sprites[1].spr=devby;
	context_main.sprites[1].pos=CL_Point(20,510);

	context_about.sprites[0].spr=copyright;
	context_about.sprites[0].pos=CL_Point(200,0);
	copyright->set_color(CL_Color(101,101,101));

	context_current=&context_main;

	curhandler=&CGameMenu::MenuMain;

	game=_game;
	MainMenu=new GCL_Menu(game->GetResman(),CMisc::fnt_menu);

	//btn_game=MainMenu->AddButton(SCR_W/2,150,true,"menu/game",SCR_W/4,10);
	btn_game_server=MainMenu->AddButton(SCR_W/2,70,true,"menu/createserver",SCR_W/6,10);
	btn_game_client=MainMenu->AddButton(SCR_W/2,150,true,"menu/connectserver",SCR_W/6,10);

	btn_options=MainMenu->AddButton(SCR_W/2,230,true,"menu/options",SCR_W/4,10);
	btn_help=MainMenu->AddButton(SCR_W/2,310,true,"menu/help",SCR_W/4,10);
	btn_about=MainMenu->AddButton(SCR_W/2,390,true,"menu/about",SCR_W/4,10);
	btn_bglist=MainMenu->AddButton(SCR_W/2,470,true,"menu/bglist",SCR_W/4,10);
	btn_exit=MainMenu->AddButton(SCR_W/2,550,true,"menu/exit",SCR_W/4,10);

	CL_SoundBuffer theme("menu/menu_theme", game->GetResman());
	menu_theme=new CL_SoundBuffer_Session; 
	*menu_theme=theme.play();

	page_main=0;

	/*page_game=MainMenu->AddPage();
	btn_game_back=MainMenu->AddButton(50,500,false,"menu/back",10,10);
	btn_game_server=MainMenu->AddButton(SCR_W/2,200,true,"menu/createserver",SCR_W/6,10);
	btn_game_client=MainMenu->AddButton(SCR_W/2,300,true,"menu/connectserver",SCR_W/6,10);*/

	page_gametype=MainMenu->AddPage();
	btn_gametype_back=MainMenu->AddButton(50,500,false,"menu/back",10,10);
	btn_gametype_deathmatch=MainMenu->AddButton(100,50,false,"menu/deathmatch");
	MainMenu->SetBtnCheck(btn_gametype_deathmatch,true);
	MainMenu->MakeRadio(btn_gametype_deathmatch,GCL_Button::GCL_BUTTON_RADIO);
	btn_gametype_teamdeathmatch=MainMenu->AddButton(100,120,false,"menu/teamdeathmatch");
	MainMenu->MakeRadio(btn_gametype_teamdeathmatch,GCL_Button::GCL_BUTTON_RADIO);
	btn_gametype_next=MainMenu->AddButton(600,500,false,"menu/next",10,10);
	
	page_gameparams=MainMenu->AddPage();
	team1=team4=BGA_TEAM_RED;
	team2=team3=BGA_TEAM_BLUE;

	btn_gameparams_back=MainMenu->AddButton(50,500,false,"menu/back",10,10);
	btn_gameparams_next=MainMenu->AddButton(600,500,false,"menu/next",10,10);

	ebx_gameparams_name1=MainMenu->AddEditBox(50,300,"Игрок 1");
	MainMenu->SetBtnParam(ebx_gameparams_name1,GCL_EDITBOX_MAXLEN,"15");
	MainMenu->SetBtnValue(ebx_gameparams_name1,"Игрок 1");
	btn_gameparams_cmd1=MainMenu->AddButton(20,307,false,"menu/switchteam");
	MainMenu->MakeRadio(btn_gameparams_cmd1,GCL_Button::GCL_BUTTON_CHECKBOX);
	MainMenu->SetBtnCheck(btn_gameparams_cmd1,team1-1);

	ebx_gameparams_name2=MainMenu->AddEditBox(450,300,"Игрок 2");
	MainMenu->SetBtnParam(ebx_gameparams_name2,GCL_EDITBOX_MAXLEN,"15");
	MainMenu->SetBtnValue(ebx_gameparams_name2,"Игрок 2");
	btn_gameparams_cmd2=MainMenu->AddButton(420,307,false,"menu/switchteam");
	MainMenu->MakeRadio(btn_gameparams_cmd2,GCL_Button::GCL_BUTTON_CHECKBOX);
	MainMenu->SetBtnCheck(btn_gameparams_cmd2,team2-1);

	ebx_gameparams_name3=MainMenu->AddEditBox(50,350,"Игрок 3");
	MainMenu->SetBtnParam(ebx_gameparams_name3,GCL_EDITBOX_MAXLEN,"15");
	MainMenu->SetBtnValue(ebx_gameparams_name3,"Игрок 3");
	btn_gameparams_cmd3=MainMenu->AddButton(20,357,false,"menu/switchteam");
	MainMenu->MakeRadio(btn_gameparams_cmd3,GCL_Button::GCL_BUTTON_CHECKBOX);
	MainMenu->SetBtnCheck(btn_gameparams_cmd3,team3-1);

	ebx_gameparams_name4=MainMenu->AddEditBox(450,350,"Игрок 4");
	MainMenu->SetBtnParam(ebx_gameparams_name4,GCL_EDITBOX_MAXLEN,"15");
	MainMenu->SetBtnValue(ebx_gameparams_name4,"Игрок 4");
	btn_gameparams_cmd4=MainMenu->AddButton(420,357,false,"menu/switchteam");
	MainMenu->MakeRadio(btn_gameparams_cmd4,GCL_Button::GCL_BUTTON_CHECKBOX);
	MainMenu->SetBtnCheck(btn_gameparams_cmd4,team4-1);

	ebx_gameparams_localgamers=MainMenu->AddEditBox(20,250,"Локальные игроки");
	MainMenu->SetBtnParam(ebx_gameparams_localgamers,GCL_EDITBOX_MAXLEN,"1");
	MainMenu->SetBtnParam(ebx_gameparams_localgamers,GCL_EDITBOX_ONLYNUM,"true");
	MainMenu->SetBtnValue(ebx_gameparams_localgamers ,"2");

	ebx_gameparams_fraglimit=MainMenu->AddEditBox(20,400,"Лимит фрагов");
	MainMenu->SetBtnParam(ebx_gameparams_fraglimit,GCL_EDITBOX_MAXLEN,"3");
	MainMenu->SetBtnParam(ebx_gameparams_fraglimit,GCL_EDITBOX_ONLYNUM,"true");
	MainMenu->SetBtnValue(ebx_gameparams_fraglimit,"20");

	ebx_gameparams_timelimit=MainMenu->AddEditBox(420,400,"Лимит времени");
	MainMenu->SetBtnParam(ebx_gameparams_timelimit,GCL_EDITBOX_MAXLEN,"3");
	MainMenu->SetBtnParam(ebx_gameparams_timelimit,GCL_EDITBOX_ONLYNUM,"true");
	MainMenu->SetBtnValue(ebx_gameparams_timelimit,"0");


	game_type=BGA_GAME_DEATHMATCH;


	page_about=MainMenu->AddPage();
	btn_about_back=MainMenu->AddButton(400,565,true,"menu/back",SCR_W/4,10);

	MainMenu->ChangePage(page_main);
}
Esempio n. 21
0
	void setRacketColor(const CL_Color _racketColor) { racketColor = CL_Color(_racketColor.get_red(), _racketColor.get_green(), _racketColor.get_blue()); }
void CL_InputBox_Silver::on_paint()
{
	bool has_focus = inputbox->is_enabled() && inputbox->has_focus();

	CL_Rectf rect = inputbox->get_screen_rect();
	int width = inputbox->get_width();

	// Outline
	if(has_focus)
	{
		// Fill
		CL_Display::fill_rect(
			CL_Rectf(rect.left + 1, rect.top + 1, rect.right - 1, rect.bottom - 1),
			CL_Color(245, 250, 255));

		// Main border
		CL_Display::draw_rect(
			rect,
			CL_Color(90, 118, 149));

		// Highlight
		CL_Display::draw_rect(
			CL_Rectf(rect.left - 1, rect.top - 1, rect.right + 1, rect.bottom + 1),
			CL_Color(206, 220, 233));
	}
	else
	{
		// Fill
		CL_Display::fill_rect(
			CL_Rectf(rect.left + 1, rect.top + 1, rect.right - 1, rect.bottom - 1),
			CL_Color::white);

		// Main border
		CL_Display::draw_rect(
			rect,
			CL_Color(128, 142, 159));
	}

	// For easy reference, put inputfield-text into local variable
	const char *text = inputbox->get_text().c_str();

	// Calculate offset for vertical centering
	int vert_center = (inputbox->get_height () - font->get_height ()) / 2;

	// Calculate scroll offset
	int character_offset = 0;
	int pixel_offset = 0;
	int text_width = (int) inputbox->in_password_mode() ? font->get_width('*')*strlen(text) : font->get_width(text);
	if (text_width > width - border_size * 2)
	{
		while (
			text_width >= width - border_size * 2 &&
			character_offset + 1 < inputbox->get_cursor_position())
		{
			int w = inputbox->in_password_mode() ? font->get_width('*') : font->get_width(text[character_offset]);
			character_offset++;
			pixel_offset += w;
			text_width -= w;
		}
	}

	// Display marked text, if any
	if(has_focus) 
	{
		if (inputbox->has_marked_text())
		{
			int start = inputbox->get_selection_start();
			int end = start + inputbox->get_selection_length();

			int mark_x1 = 0, mark_x2 = 0;

			int i;
			if (inputbox->in_password_mode())
			{
				int w = font->get_width('*');

				if (start > 0)
					mark_x1 += start*w;

				if (end > start)
					mark_x2 += (end-start)*w;
			}
			else
			{
				for(i = 0; i < start; i++)
					mark_x1 += font->get_width(text[i]);

				for(i = start; i < end; i++)
					mark_x2 += font->get_width(text[i]);
			}

			CL_Display::fill_rect(
				CL_Rect(
					inputbox->get_screen_x()+border_size + mark_x1 - 1,
					inputbox->get_screen_y() + vert_center,
					inputbox->get_screen_x()+border_size + mark_x1 + mark_x2,
					inputbox->get_screen_y() + font->get_height() + vert_center),
				CL_Color(204, 208, 232));
		}
	}

	// Display text
	if(inputbox->is_enabled() == false)
	{
		if (inputbox->in_password_mode())
			font_disabled->draw(inputbox->get_screen_x()+border_size, inputbox->get_screen_y()+vert_center, std::string(strlen(text+character_offset), '*'));
		else
			font_disabled->draw(inputbox->get_screen_x()+border_size, inputbox->get_screen_y()+vert_center, &text[character_offset]);
	}
	else
	{
		if (inputbox->in_password_mode())
			font->draw(inputbox->get_screen_x()+border_size, inputbox->get_screen_y()+vert_center, std::string(strlen(text+character_offset), '*'));
		else
			font->draw(inputbox->get_screen_x()+border_size, inputbox->get_screen_y()+vert_center, &text[character_offset]);
	}

	// Show blinking cursor
	if(has_focus) 
	{
		if (show_cursor)
		{
			int cursor_x = border_size - pixel_offset;

			if (inputbox->in_password_mode())
				cursor_x += inputbox->get_cursor_position() * font->get_width('*');
			else
				for(int i = 0; i < inputbox->get_cursor_position(); i++)
					cursor_x += font->get_width(text[i]);
			
			CL_Display::draw_line(
				inputbox->get_screen_x() + cursor_x,
				inputbox->get_screen_y() + vert_center,
				inputbox->get_screen_x() + cursor_x,
				inputbox->get_screen_y() + vert_center + font->get_height() - 1,
				CL_Color::black);
		}

		unsigned int cur_time = CL_System::get_time();
		if (cur_time >= cursor_blink_time)
		{
			cursor_blink_time = cur_time + 400;
			show_cursor = !show_cursor;
		}
	}
}
void CL_Window_Silver::on_paint()
{
	CL_Rectf rect = window->get_screen_rect();

	// Titlebar
	CL_Display::fill_rect(
		CL_Rectf(rect.left + 2, rect.top + 4, rect.right - 2, rect.top + titlebar_height - 3),
		CL_Color(206, 217, 228));

	CL_Display::draw_line(
		rect.left + 2,
		rect.top + 2,
		rect.right - 2,
		rect.top + 2,
		CL_Color(251, 253, 255));

	CL_Display::draw_line(
		rect.left + 2,
		rect.top + 3,
		rect.right - 2,
		rect.top + 3,
		CL_Color(236, 238, 240));

	CL_Display::draw_line(
		rect.left + 2,
		rect.top + titlebar_height - 3,
		rect.right - 2,
		rect.top + titlebar_height - 3,
		CL_Color(180, 202, 224));

	CL_Display::draw_line(
		rect.left + 2,
		rect.top + titlebar_height - 2,
		rect.right - 2,
		rect.top + titlebar_height - 2,
		CL_Color(144, 180, 218));

	CL_Display::draw_line(
		rect.left + 2,
		rect.top + titlebar_height - 1,
		rect.right - 2,
		rect.top + titlebar_height - 1,
		CL_Color(128, 142, 159));

	// Outer window frame
	CL_Display::draw_rect(
		rect,
		CL_Color(128, 142, 159));

	// Inner window frame
	CL_Display::draw_rect(
		CL_Rectf(rect.left + 1, rect.top + 1, rect.right - 1, rect.bottom - 1),
		CL_Color(161, 172, 185));

	// Client area
	CL_Display::fill_rect(
		CL_Rectf(rect.left + 2, rect.top + titlebar_height, rect.right - 2, rect.bottom - 2),
		CL_Gradient(
			CL_Color(255, 255, 255, 235),
			CL_Color(255, 255, 255, 235),
			CL_Color(224, 228, 232, 235),
			CL_Color(224, 228, 232, 235)));
		
	int y = (titlebar_height + 2 - font->get_height()) / 2;

	if(window->is_enabled() == false)
		font_disabled->draw(static_cast<int>(rect.left + 7),
								  static_cast<int>(rect.top + y), window->get_title());
	else
	{
		font->draw(static_cast<int>(rect.left + 7), 
					  static_cast<int>(rect.top + y), window->get_title());
		font->draw(static_cast<int>(rect.left + 8),
					  static_cast<int>(rect.top + y), window->get_title());
	}

/*	CL_Rect rect = window->get_screen_rect();

	int offx = window->get_screen_x();
	int offy = window->get_screen_y();

	int w_width = rect.get_width();
	int w_height = rect.get_height();

	// Vertical shadows
	CL_Display::draw_line(offx+w_width + 0, offy + 5, offx+w_width + 0, offy+w_height + 0, CL_Color(0, 0, 0, 64));
	CL_Display::draw_line(offx+w_width + 1, offy + 5, offx+w_width + 1, offy+w_height + 1, CL_Color(0, 0, 0, 51));
	CL_Display::draw_line(offx+w_width + 2, offy + 5, offx+w_width + 2, offy+w_height + 2, CL_Color(0, 0, 0, 38));
	CL_Display::draw_line(offx+w_width + 3, offy + 5, offx+w_width + 3, offy+w_height + 3, CL_Color(0, 0, 0, 25));
	CL_Display::draw_line(offx+w_width + 4, offy + 5, offx+w_width + 4, offy+w_height + 4, CL_Color(0, 0, 0, 13));

	// Horizontal shadows
	CL_Display::draw_line(offx + 5, offy+w_height + 0, offx+w_width + 1, offy+w_height + 0, CL_Color(0, 0, 0, 64));
	CL_Display::draw_line(offx + 5, offy+w_height + 1, offx+w_width + 2, offy+w_height + 1, CL_Color(0, 0, 0, 51));
	CL_Display::draw_line(offx + 5, offy+w_height + 2, offx+w_width + 3, offy+w_height + 2, CL_Color(0, 0, 0, 38));
	CL_Display::draw_line(offx + 5, offy+w_height + 3, offx+w_width + 4, offy+w_height + 3, CL_Color(0, 0, 0, 25));
	CL_Display::draw_line(offx + 5, offy+w_height + 4, offx+w_width + 5, offy+w_height + 4, CL_Color(0, 0, 0, 13));
*/
}
void 
GameSession::update()
{
  int delta_wait = static_cast<int>(1000/args->fps);
  float delta = delta_wait/1000.0f;;

  deltas += delta;
  ++loops;

  if (CL_Keyboard::get_keycode(CL_KEY_D))
    Guile::enter_repl();

  unsigned int last_time = CL_System::get_time ();

  // Update stuff
  if (!do_pause)
    {
      collision_mgr->clear();
      AIManager::instance()->update(delta);
      world->update(delta);
      collision_mgr->run();
      view->update(delta);
    }

  GameWorld::current()->draw(*view);
  GameWorld::current()->draw_energie(*view);
  view->get_sc().render();
  view->get_sc().light().fill_screen(CL_Color(50, 50, 100));

  if (draw_colmap)
    collision_mgr->draw(*view);

  if (!do_pause)
    DisplayManager::current()->update(delta);
      
  DisplayManager::current()->draw(*(CL_Display::get_current_window()->get_gc()));

  if (CL_Mouse::get_keycode(CL_MOUSE_MIDDLE))
    world->add(new ExplosionParticle(view->screen_to_world(FloatVector2d(CL_Mouse::get_x (),
                                                                         CL_Mouse::get_y ())),
                                     FloatVector2d(), 3.0f));

  // Comment out for variable frame rate
  int sleep_time = (last_time + delta_wait) - CL_System::get_time();
  if (sleep_time > 0)
    CL_System::sleep (sleep_time);

  // Flip front and backbuffer. This makes the changes visible:
  CL_Display::flip ();

  if (!args->video_record_directory.empty())
    {
      std::stringstream filename;
      filename << args->video_record_directory;
      filename.width(8);
      filename.fill('0');
      filename << frames;
      filename << ".ppm";
      Screenshot::write_screenshot_pnm(filename.str());
    }

  ++frames;
	    
  // Update keyboard input and handle system events:
  // Exits the loop if ClanLib requests shutdown - for instance if
  // someone closes the window.
  CL_System::keep_alive();
  clanlib_call_post_keep_alive_func();
  InputManager::update(delta);

  InputEventLst lst = InputManager::get_controller().get_events();
  for(InputEventLst::iterator i = lst.begin(); i != lst.end(); ++i)
    {
      if (i->type == BUTTON_EVENT)
        {
          if (i->button.name == MENU_BUTTON && i->button.is_down())
            {
              if (control_state == MENU_CONTROL)
                {
                  menu_hide();
                  control_state = UNIT_CONTROL;
                }
              else 
                {
                  menu_show(0);
                  control_state = MENU_CONTROL;
                }
            }
          else if (i->button.name == USE_BUTTON && i->button.is_down())
            {
              // FIXME: Unclean hack
              gh_call0(gh_lookup("join-nearest-vehicle"));
            }
        }
    }

  switch (control_state)
    {
    case MENU_CONTROL:
      if (DisplayManager::current()->get_menu())
        DisplayManager::current()->get_menu()->process_events(InputManager::get_controller().get_events());
      else
        {
          std::cout << "Error: Menu not available, fallback to unit" << std::endl;
          control_state = UNIT_CONTROL;
        }
      break;

    case UNIT_CONTROL:
      player->get_current_unit()->update_controlls(InputManager::get_controller());
      break;
      
    default: 
      std::cout << "Unknown ControlState, switching back to UNIT_CONTROL" << std::endl;
      control_state = UNIT_CONTROL;
      break;
    }

  InputManager::clear();
}
Esempio n. 25
0
// The start of the Application
int App::main(int argc, char **argv)
{
	quit = false;

	running_test = 0;

	// Initialize ClanLib base components
	CL_SetupCore setup_core;

	// Initialize the ClanLib display component
	CL_SetupDisplay setup_display;

	// Initilize the OpenGL drivers
	CL_SetupGL setup_gl;

	// Create a console window for text-output if not available
	CL_ConsoleWindow console("Console", 80, 200);
	console.redirect_stdio();

	std::cout << "Press 1-5 for different tests! (Test 3 and 5 not applicable for ClanLib 0.8)" << std::endl;			

	try
	{
		// This opens a window, including the frame size
		// If you want more control over the window, pass CL_DisplayWindowDescription to CL_DisplayWindow
		// (This is useful to create a borderless window of a specific size)
		// If you require target specific control over the window, use the derived CL_OpenGLWindowDescription
		// (This contains the multisampling options)
		CL_DisplayWindow window("ClanLib SpriteSpeed Test", 1000, 1000);

		// Connect the Window close event
		CL_Slot slot_quit = window.sig_window_close().connect(this, &App::on_window_close);

		// Connect a keyboard handler to on_key_up()
		CL_Slot slot_input_up = (window.get_ic()->get_keyboard()).sig_key_down().connect(this, &App::on_input_up);

		CL_GraphicContext *gc = window.get_gc();

		CL_ResourceManager resources("resources.xml");

		explosion1 = CL_Sprite("Explosion1", &resources);
		explosion2 = CL_Sprite("Explosion2", &resources);

		explosions_same_tex.reserve(10000);
		for(int i=0; i<10000; i++)
		{
			explosions_same_tex.push_back(CL_Sprite(explosion1));

			if(i % 2 == 0)
				explosions_diff_tex.push_back(CL_Sprite(explosion1));
			else
				explosions_diff_tex.push_back(CL_Sprite(explosion2));
		}

		// Run until someone presses escape
		while (!quit)
		{
			float delta_time = dump_fps() / 1000.0f;

			CL_Display::clear(CL_Color(0, 0, 51));

			if(running_test == 0)
				CL_System::sleep(100);
			if(running_test == 1)
				draw_equal_tex_equal_sprites(gc, 10000, delta_time);
			if(running_test == 2)
				draw_equal_tex_diff_sprites(gc, 10000, delta_time);
			if(running_test == 3)
				draw_equal_tex_diff_sprites_batch(gc, 10000, delta_time);
			if(running_test == 4)
				draw_diff_tex_diff_sprites(gc, 10000, delta_time);
			if(running_test == 5)
				draw_diff_tex_diff_sprites_batch(gc, 10000, delta_time);

			// Flip the display, showing on the screen what we have drawed since last call to flip()
			CL_Display::flip();

			// This call processes user input and other events
			CL_System::keep_alive(1);
		}

		explosions_same_tex.clear();
		explosions_diff_tex.clear();
		explosion1 = CL_Sprite();
		explosion2 = CL_Sprite();
	}
	catch(CL_Error error)
	{
		std::cout << "Exception caught : " << error.message.c_str() << std::endl;			

		// Display console close message and wait for a key
		console.display_close_message();

		return -1;
	}
	return 0;
}
Esempio n. 26
0
void
OnionSkinLayer::clear()
{
  impl->canvas->get_gc()->clear(CL_Color(0, 0, 0, 0));
  impl->canvas->sync_surface();
}
Esempio n. 27
0
// проверяет нажатую кнопку и выполняет соответствующие действия
void CGameMenu::Navigate(void)
{
	int btn=MainMenu->GetClickedButton();
	//ничего не нажато
	if (btn==-1)
		return;

	int page=MainMenu->GetCurPage();
	
	if (page==page_main)
	{
		/*if (btn==btn_game)
		{
			MainMenu->FadeOn(context_main);
			MainMenu->ChangePage(page_game);
			context_current=&context_null;
			MainMenu->FadeOff();
		}*/
		if (btn==btn_game_server)
		{
			MainMenu->FadeOn(context_main);
			MainMenu->ChangePage(page_gametype);
			context_current=&context_null;
			MainMenu->FadeOff();
		}
		if (btn==btn_about)
		{
			MainMenu->FadeOn(context_main);
			MainMenu->ChangePage(page_about);
			context_current=&context_about;
			MainMenu->FadeOff(context_about);
			y=650;r=g=b=101;ch=dif=1;
			copyright->set_color(CL_Color(101,101,101));
			curhandler=&CGameMenu::MenuAbout;
		}
		if (btn==btn_exit)
		{
			std::cout<<"Exit button clicked.\n";
			MainMenu->FadeOn(context_main);
			quit=true;
		}
	}
	if (page==page_about)
	{
		if (btn==btn_about_back)
		{
			MainMenu->FadeOn(context_about);
			MainMenu->ChangePage(page_main);

			fnt_about->set_color(101,101,101);
			copyright->set_color(101,101,101);

			context_current=&context_main;
			MainMenu->FadeOff(context_main);
			curhandler=&CGameMenu::MenuMain;
		}
	}
	/*if (page==page_game)
	{
		if (btn==btn_game_back)
		{
			MainMenu->FadeOn();
			MainMenu->ChangePage(page_main);
			context_current=&context_main;
			MainMenu->FadeOff(context_main);
		}

	}*/
	if (page==page_gametype)
	{
		if (btn==btn_gametype_back)
		{
			MainMenu->FadeOn();
			MainMenu->ChangePage(page_main);
			context_current=&context_main;
			MainMenu->FadeOff(context_main);
		}
		if (btn==btn_gametype_next)
		{
			MainMenu->FadeOn();
			MainMenu->ChangePage(page_gameparams);
			MainMenu->FadeOff();
		}
		if (btn==btn_gametype_deathmatch)
		{
			MainMenu->SetBtnCheck(btn_gametype_deathmatch,true);
			MainMenu->SetBtnCheck(btn_gametype_teamdeathmatch,false);
			game_type=BGA_GAME_DEATHMATCH;
		}
		if (btn==btn_gametype_teamdeathmatch)
		{
			MainMenu->SetBtnCheck(btn_gametype_teamdeathmatch,true);
			MainMenu->SetBtnCheck(btn_gametype_deathmatch,false);
			game_type=BGA_GAME_TEAMDEATHMATCH;
		}
	}
	if (page==page_gameparams)
	{
		if (btn==btn_gameparams_back)
		{
			MainMenu->FadeOn();
			MainMenu->ChangePage(page_gametype);
			MainMenu->FadeOff();
		}
		if (btn==btn_gameparams_next)
		{
			MainMenu->FadeOn();
			menu_theme->stop();
			int fr_lim,t_lim,loc_p;
			fr_lim=CL_String::to_int(MainMenu->GetBtnValue(ebx_gameparams_fraglimit));
			t_lim=CL_String::to_int(MainMenu->GetBtnValue(ebx_gameparams_timelimit));
			loc_p=CL_String::to_int(MainMenu->GetBtnValue(ebx_gameparams_localgamers));

			if (loc_p<1)
				loc_p=1;
			else if (loc_p>4)
				loc_p=4;

			game->SetLocalNames(MainMenu->GetBtnValue(ebx_gameparams_name1),MainMenu->GetBtnValue(ebx_gameparams_name2),
				MainMenu->GetBtnValue(ebx_gameparams_name3),MainMenu->GetBtnValue(ebx_gameparams_name4));

			game->SetLocalCommands(team1,team2,team3,team4);

			string mapname="platetown";
			LOG<<LOG.Time()<<"Запуск игры (карта - "<<mapname<<", лимит фрагов - "<<fr_lim<<", лимит времени - "<<t_lim<<" мин.)\n";

			game->SetLimits(fr_lim,t_lim);
			game->NewGame(game_type,loc_p,mapname);
			game->MainLoop();
			menu_theme->play();
			MainMenu->ChangePage(page_main);
			context_current=&context_main;
			MainMenu->FadeOff(context_main);
		}
		if (btn==ebx_gameparams_name1)
		{
			MainMenu->SetBtnCheck(ebx_gameparams_name1,true);
			MainMenu->SetBtnCheck(ebx_gameparams_name2,false);
			MainMenu->SetBtnCheck(ebx_gameparams_name3,false);
			MainMenu->SetBtnCheck(ebx_gameparams_name4,false);
			MainMenu->SetBtnCheck(ebx_gameparams_fraglimit,false);
			MainMenu->SetBtnCheck(ebx_gameparams_timelimit,false);
			MainMenu->SetBtnCheck(ebx_gameparams_localgamers,false);
		}
		if (btn==ebx_gameparams_name2)
		{
			MainMenu->SetBtnCheck(ebx_gameparams_name1,false);
			MainMenu->SetBtnCheck(ebx_gameparams_name2,true);
			MainMenu->SetBtnCheck(ebx_gameparams_name3,false);
			MainMenu->SetBtnCheck(ebx_gameparams_name4,false);
			MainMenu->SetBtnCheck(ebx_gameparams_fraglimit,false);
			MainMenu->SetBtnCheck(ebx_gameparams_timelimit,false);
			MainMenu->SetBtnCheck(ebx_gameparams_localgamers,false);
		}
		if (btn==ebx_gameparams_name3)
		{
			MainMenu->SetBtnCheck(ebx_gameparams_name1,false);
			MainMenu->SetBtnCheck(ebx_gameparams_name2,false);
			MainMenu->SetBtnCheck(ebx_gameparams_name3,true);
			MainMenu->SetBtnCheck(ebx_gameparams_name4,false);
			MainMenu->SetBtnCheck(ebx_gameparams_fraglimit,false);
			MainMenu->SetBtnCheck(ebx_gameparams_timelimit,false);
			MainMenu->SetBtnCheck(ebx_gameparams_localgamers,false);
		}
		if (btn==ebx_gameparams_name4)
		{
			MainMenu->SetBtnCheck(ebx_gameparams_name1,false);
			MainMenu->SetBtnCheck(ebx_gameparams_name2,false);
			MainMenu->SetBtnCheck(ebx_gameparams_name3,false);
			MainMenu->SetBtnCheck(ebx_gameparams_name4,true);
			MainMenu->SetBtnCheck(ebx_gameparams_fraglimit,false);
			MainMenu->SetBtnCheck(ebx_gameparams_timelimit,false);
			MainMenu->SetBtnCheck(ebx_gameparams_localgamers,false);
		}
		if (btn==ebx_gameparams_fraglimit)
		{
			MainMenu->SetBtnCheck(ebx_gameparams_name1,false);
			MainMenu->SetBtnCheck(ebx_gameparams_name2,false);
			MainMenu->SetBtnCheck(ebx_gameparams_name3,false);
			MainMenu->SetBtnCheck(ebx_gameparams_name4,false);
			MainMenu->SetBtnCheck(ebx_gameparams_fraglimit,true);
			MainMenu->SetBtnCheck(ebx_gameparams_timelimit,false);
			MainMenu->SetBtnCheck(ebx_gameparams_localgamers,false);
		}
		if (btn==ebx_gameparams_timelimit)
		{
			MainMenu->SetBtnCheck(ebx_gameparams_name1,false);
			MainMenu->SetBtnCheck(ebx_gameparams_name2,false);
			MainMenu->SetBtnCheck(ebx_gameparams_name3,false);
			MainMenu->SetBtnCheck(ebx_gameparams_name4,false);
			MainMenu->SetBtnCheck(ebx_gameparams_fraglimit,false);
			MainMenu->SetBtnCheck(ebx_gameparams_timelimit,true);
			MainMenu->SetBtnCheck(ebx_gameparams_localgamers,false);
		}
		if (btn==ebx_gameparams_localgamers)
		{
			MainMenu->SetBtnCheck(ebx_gameparams_name1,false);
			MainMenu->SetBtnCheck(ebx_gameparams_name2,false);
			MainMenu->SetBtnCheck(ebx_gameparams_name3,false);
			MainMenu->SetBtnCheck(ebx_gameparams_name4,false);
			MainMenu->SetBtnCheck(ebx_gameparams_fraglimit,false);
			MainMenu->SetBtnCheck(ebx_gameparams_timelimit,false);
			MainMenu->SetBtnCheck(ebx_gameparams_localgamers,true);
		}
		
		if (btn==btn_gameparams_cmd1)
		{
			team1=(team1==1 ? 2 : 1);
			MainMenu->SetBtnCheck(btn_gameparams_cmd1,team1-1);
		}
		if (btn==btn_gameparams_cmd2)
		{
			team2=(team2==1 ? 2 : 1);
			MainMenu->SetBtnCheck(btn_gameparams_cmd2,team2-1);
		}
		if (btn==btn_gameparams_cmd3)
		{
			team3=(team3==1 ? 2 : 1);
			MainMenu->SetBtnCheck(btn_gameparams_cmd3,team3-1);
		}
		if (btn==btn_gameparams_cmd4)
		{
			team4=(team4==1 ? 2 : 1);
			MainMenu->SetBtnCheck(btn_gameparams_cmd4,team4-1);
		}
	}
}
void CL_TreeView_Silver::on_paint_node(CL_TreeNode *node, CL_Point &point)
{
	CL_Component *component = node->get_component();
	CL_Component *client_area = treeview->get_client_area();

	int height = component->get_height();
	int mid = (height) / 2;

	// Should we draw decoration ?
	bool draw_decoration = true;
	if(node->is_root())
		draw_decoration = node->get_treeview()->is_root_decoration_visible();

	// Find what y offset we're drawing at
	point.y -= scrollbar->get_value();

	// Find what x offset we're drawing at
	int x_offset = 0;
	if(draw_decoration)
		x_offset = 12;

	int screen_x = client_area->get_screen_x();
	int screen_y = client_area->get_screen_y();
	
	// Is the node visible?
	if (point.y + height >= 0 && point.y <= client_area->get_height())
	{
		if(draw_decoration)
		{
			// Draw collapse box
			if(node->has_children())
			{
				CL_Display::draw_rect(
					CL_Rect(
						screen_x + point.x,
						screen_y + point.y + mid - 5,
						screen_x + point.x + 9,
						screen_y + point.y + mid + 4),
					CL_Color(128, 142, 159));

				CL_Display::fill_rect(
					CL_Rect(
						screen_x + point.x + 1,
						screen_y + point.y + mid - 4,
						screen_x + point.x + 8,
						screen_y + point.y + mid + 3),
					CL_Gradient(
						CL_Color::white,
						CL_Color::white,
						CL_Color(230, 235, 240),
						CL_Color(230, 235, 240)));

				CL_Display::fill_rect(
					CL_Rect(
						screen_x + point.x + 2,
						screen_y + point.y + mid - 3,
						screen_x + point.x + 7,
						screen_y + point.y + mid + 2),
					CL_Gradient(
						CL_Color(217, 222, 227),
						CL_Color(217, 222, 227),
						CL_Color::white,
						CL_Color::white));

				// Horizontal line
				CL_Display::draw_line(
					screen_x + point.x + 2.0f,
					screen_y + point.y + mid - 1.0f,
					screen_x + point.x + 7.0f,
					screen_y + point.y + mid - 1,
					CL_Color::black);

				// Vertical line
				if(node->is_collapsed())
					CL_Display::draw_line(
						screen_x + point.x + 4.0f,
						screen_y + point.y + mid - 3.0f,
						screen_x + point.x + 4.0f,
						screen_y + point.y + mid + 2.0f,
						CL_Color::black);
			}
		}

		// Size and place child component
		component->set_position(point.x + x_offset, point.y);
		node->set_placement_offset(point.x + x_offset);

		// Draw component
		component->show(true);
		component->sig_begin_paint();
		component->sig_paint()();
		component->sig_end_paint();
	}
	else
	{
		component->show(false);
	}

	// Move down for next component
	point.y += scrollbar->get_value();
	point.y += height;

	// If it has any children, adjust the x-position for the children
	if(node->is_collapsed() == false)
		point.x += 3 + x_offset;
}
void CL_TreeView_Silver::on_paint()
{
	// Outline
	CL_Rect rect = treeview->get_screen_rect();
	CL_Display::draw_rect(rect, CL_Color(128, 142, 159));
}
Esempio n. 30
0
void
Box::draw_window(const CL_Rect& rect)
{
  draw_panel(CL_Rect(rect.left+1, rect.top+1, rect.right-2, rect.bottom-2));
  CL_Display::draw_rect(rect, CL_Color(0, 0, 0));
}