ilikecats/stk-code_catmod
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactoring, renaming and cleaning-up

Browse Source
This commit is contained in:
konstin 2014-05-30 20:26:44 +02:00
parent feeab733e4
commit 02677b38c2
6 changed files with 164 additions and 153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/race/grand_prix_data.cpp
View File

@ -52,7 +52,7 @@ GrandPrixData::GrandPrixData(const unsigned int number_of_tracks,
{ {
m_filename = "Random GP - Not loaded from a file!"; m_filename = "Random GP - Not loaded from a file!";
m_id = "random"; m_id = "random";
m_name = L"Random"; m_name = L"Random Grand Prix";
m_editable = false; m_editable = false;
m_tracks.reserve(number_of_tracks); m_tracks.reserve(number_of_tracks);

156
src/states_screens/dialogs/gp_info_dialog.cpp
View File

@ -39,57 +39,60 @@
#include <IGUIEnvironment.h> #include <IGUIEnvironment.h>
#include <IGUIStaticText.h> #include <IGUIStaticText.h>
using namespace irr::gui; using irr::gui::IGUIStaticText;
using namespace irr::video; using GUIEngine::PROP_ID;
using namespace irr::core;
using namespace GUIEngine;
// ---------------------------------------------------------------------------- typedef GUIEngine::LabelWidget Label;
GPInfoDialog::GPInfoDialog(const std::string& gp_ident) : GPInfoDialog::GPInfoDialog(const std::string& gp_ident) :
ModalDialog(PERCENT_WIDTH, PERCENT_HEIGHT) ModalDialog(PERCENT_WIDTH, PERCENT_HEIGHT)
{ {
doInit(); doInit();
m_curr_time = 0.0f; m_curr_time = 0.0f;
m_gp_ident = gp_ident;
m_gp = grand_prix_manager->getGrandPrix(gp_ident); m_gp = grand_prix_manager->getGrandPrix(gp_ident);
assert (m_gp != NULL); m_gp->checkConsistency();
// ---- GP Name m_under_title = m_area.getHeight()/7;
core::rect< s32 > area_top(0, 0, m_area.getWidth(), m_area.getHeight()/7); m_over_body = m_area.getHeight()/7;
IGUIStaticText* title = GUIEngine::getGUIEnv()->addStaticText( translations->fribidize(m_gp->getName()), m_lower_bound = m_area.getHeight()*6/7;
area_top, false, true, // border, word wrap
m_irrlicht_window);
title->setTabStop(false);
title->setTextAlignment(EGUIA_CENTER, EGUIA_CENTER);
displayTracks(m_area.getHeight()/7, m_area.getHeight()*6/7); addTitle();
InitAfterDrawingTheHeader(m_area.getHeight()/7, m_area.getHeight()*6/7, gp_ident); addTracks();
addScreenshot();
addButtons();
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
GPInfoDialog::~GPInfoDialog() GPInfoDialog::~GPInfoDialog()
{ {
// Place focus back on selected GP, in case the dialog was cancelled and we're back to GUIEngine::Screen* curr_screen = GUIEngine::getCurrentScreen();
// the track selection screen after
Screen* curr_screen = GUIEngine::getCurrentScreen();
if (curr_screen->getName() == "tracks.stkgui") if (curr_screen->getName() == "tracks.stkgui")
{ static_cast<TracksScreen*>(curr_screen)->setFocusOnGP(m_gp->getId());
((TracksScreen*)curr_screen)->setFocusOnGP(m_gp_ident);
}
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
void GPInfoDialog::displayTracks(const int upper_bound,
const int lower_bound) void GPInfoDialog::addTitle()
{
core::rect< s32 > area_top(0, 0, m_area.getWidth(), m_under_title);
IGUIStaticText* title = GUIEngine::getGUIEnv()->addStaticText(
translations->fribidize(m_gp->getName()),
area_top, false, true, // border, word wrap
m_irrlicht_window);
title->setTabStop(false);
title->setTextAlignment(irr::gui::EGUIA_CENTER, irr::gui::EGUIA_CENTER);
}
// ----------------------------------------------------------------------------
void GPInfoDialog::addTracks()
{ {
const std::vector<std::string> tracks = m_gp->getTrackNames(); const std::vector<std::string> tracks = m_gp->getTrackNames();
const unsigned int track_amount = tracks.size(); const unsigned int track_amount = tracks.size();
int height_of_one_line = std::min((lower_bound - upper_bound)/(track_amount+1), int height_of_one_line = std::min((m_lower_bound - m_over_body)/(track_amount+1),
(unsigned int)(GUIEngine::getFontHeight()*1.5f)); (unsigned int)(GUIEngine::getFontHeight()*1.5f));
// Count the number of label already existing labels representing a track // Count the number of label already existing labels representing a track
@ -111,9 +114,9 @@ void GPInfoDialog::displayTracks(const int upper_bound,
while (m_widgets.get(widgets_iter)->m_properties[PROP_ID] != "Track label") while (m_widgets.get(widgets_iter)->m_properties[PROP_ID] != "Track label")
widgets_iter++; widgets_iter++;
LabelWidget* widget = dynamic_cast<LabelWidget*>(m_widgets.get(widgets_iter)); Label* widget = dynamic_cast<Label*>(m_widgets.get(widgets_iter));
widget->setText(translations->fribidize(track->getName()), false); widget->setText(translations->fribidize(track->getName()), false);
widget->move(20, upper_bound + height_of_one_line*(i+1), widget->move(20, m_over_body + height_of_one_line*(i+1),
m_area.getWidth()/2 - 20, height_of_one_line); m_area.getWidth()/2 - 20, height_of_one_line);
widgets_iter++; widgets_iter++;
@ -128,14 +131,14 @@ void GPInfoDialog::displayTracks(const int upper_bound,
Track* track = track_manager->getTrack(tracks[i]); Track* track = track_manager->getTrack(tracks[i]);
assert(track != NULL); assert(track != NULL);
LabelWidget* widget = new LabelWidget(); Label* widget = new Label();
widget->m_properties[PROP_ID] = "Track label"; widget->m_properties[PROP_ID] = "Track label";
widget->setText(translations->fribidize(track->getName()), false); widget->setText(translations->fribidize(track->getName()), false);
widget->setParent(m_irrlicht_window); widget->setParent(m_irrlicht_window);
m_widgets.push_back(widget); m_widgets.push_back(widget);
widget->add(); widget->add();
widget->move(20, upper_bound + height_of_one_line*(i+1), widget->move(20, m_over_body + height_of_one_line*(i+1),
m_area.getWidth()/2 - 20, height_of_one_line); m_area.getWidth()/2 - 20, height_of_one_line);
} }
} }
@ -156,26 +159,22 @@ void GPInfoDialog::displayTracks(const int upper_bound,
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
void GPInfoDialog::InitAfterDrawingTheHeader(const int upper_bound, void GPInfoDialog::addScreenshot()
const int lower_bound,
const std::string& gp_ident)
{ {
const std::vector<std::string> tracks = m_gp->getTrackNames(); m_screenshot_widget = new GUIEngine::IconButtonWidget(
GUIEngine::IconButtonWidget::SCALE_MODE_KEEP_CUSTOM_ASPECT_RATIO,
// ---- Track screenshot false, false, GUIEngine::IconButtonWidget::ICON_PATH_TYPE_ABSOLUTE);
m_screenshot_widget = new IconButtonWidget(IconButtonWidget::SCALE_MODE_KEEP_CUSTOM_ASPECT_RATIO,
false /* tab stop */, false /* focusable */,
IconButtonWidget::ICON_PATH_TYPE_ABSOLUTE /* Track gives us absolute paths */);
// images are saved squared, but must be stretched to 4:3 // images are saved squared, but must be stretched to 4:3
m_screenshot_widget->setCustomAspectRatio(4.0f / 3.0f); m_screenshot_widget->setCustomAspectRatio(4.0f / 3.0f);
m_screenshot_widget->m_x = m_area.getWidth()/2-20; m_screenshot_widget->m_x = m_area.getWidth()/2-20;
m_screenshot_widget->m_y = upper_bound + 10; m_screenshot_widget->m_y = m_over_body + 10;
// Scale the picture to the biggest possible size without an overflow // Scale the picture to the biggest possible size without an overflow
if (lower_bound - upper_bound - 20 < m_area.getWidth()/2*3/4) if (m_lower_bound - m_over_body - 20 < m_area.getWidth()/2*3/4)
{ {
m_screenshot_widget->m_w = (lower_bound - upper_bound - 30)*4/3; m_screenshot_widget->m_w = (m_lower_bound - m_over_body - 30)*4/3;
m_screenshot_widget->m_h = lower_bound - upper_bound - 30; m_screenshot_widget->m_h = m_lower_bound - m_over_body - 30;
} }
else else
{ {
@ -183,48 +182,41 @@ void GPInfoDialog::InitAfterDrawingTheHeader(const int upper_bound,
m_screenshot_widget->m_h = m_area.getWidth()*3/8; // *(3/4)*(1/2) m_screenshot_widget->m_h = m_area.getWidth()*3/8; // *(3/4)*(1/2)
} }
Track* track = (tracks.size() == 0 ? NULL : track_manager->getTrack(tracks[0])); Track* track = track_manager->getTrack(m_gp->getTrackNames()[0]);
m_screenshot_widget->m_properties[GUIEngine::PROP_ICON] = (track->getScreenshotFile().c_str());
m_screenshot_widget->m_properties[PROP_ICON] = (track != NULL ?
track->getScreenshotFile().c_str() :
file_manager->getAsset(FileManager::GUI,"main_help.png"));
m_screenshot_widget->setParent(m_irrlicht_window); m_screenshot_widget->setParent(m_irrlicht_window);
m_screenshot_widget->add(); m_screenshot_widget->add();
m_widgets.push_back(m_screenshot_widget); m_widgets.push_back(m_screenshot_widget);
}
// ----------------------------------------------------------------------------
void GPInfoDialog::addButtons()
{
// ---- Start button // ---- Start button
ButtonWidget* okBtn = new ButtonWidget(); GUIEngine::ButtonWidget* okBtn = new GUIEngine::ButtonWidget();
ButtonWidget* continueBtn = new ButtonWidget(); GUIEngine::ButtonWidget* continueBtn = new GUIEngine::ButtonWidget();
SavedGrandPrix* saved_gp = SavedGrandPrix::getSavedGP( StateManager::get() SavedGrandPrix* saved_gp = SavedGrandPrix::getSavedGP( StateManager::get()
->getActivePlayerProfile(0) ->getActivePlayerProfile(0)
->getUniqueID(), ->getUniqueID(),
gp_ident, m_gp->getId(),
race_manager->getDifficulty(), race_manager->getDifficulty(),
race_manager->getNumberOfKarts(), race_manager->getNumberOfKarts(),
race_manager->getNumLocalPlayers()); race_manager->getNumLocalPlayers());
if (tracks.size() == 0)
{
okBtn->m_properties[PROP_ID] = "cannot_start";
okBtn->setText(_("Sorry, no tracks available"));
}
else
{
okBtn->m_properties[PROP_ID] = "start"; okBtn->m_properties[PROP_ID] = "start";
okBtn->setText(_("Start Grand Prix")); okBtn->setText(_("Start Grand Prix"));
continueBtn->m_properties[PROP_ID] = "continue"; continueBtn->m_properties[PROP_ID] = "continue";
continueBtn->setText(_("Continue")); continueBtn->setText(_("Continue"));
}
if (saved_gp) if (saved_gp)
{ {
continueBtn->m_x = m_area.getWidth()/2 + 110; continueBtn->m_x = m_area.getWidth()/2 + 110;
continueBtn->m_y = lower_bound; continueBtn->m_y = m_lower_bound;
continueBtn->m_w = 200; continueBtn->m_w = 200;
continueBtn->m_h = m_area.getHeight() - lower_bound - 15; continueBtn->m_h = m_area.getHeight() - m_lower_bound - 15;
continueBtn->setParent(m_irrlicht_window); continueBtn->setParent(m_irrlicht_window);
m_widgets.push_back(continueBtn); m_widgets.push_back(continueBtn);
continueBtn->add(); continueBtn->add();
@ -238,9 +230,9 @@ void GPInfoDialog::InitAfterDrawingTheHeader(const int upper_bound,
okBtn->m_x = m_area.getWidth()/2 - 200; okBtn->m_x = m_area.getWidth()/2 - 200;
} }
okBtn->m_y = lower_bound; okBtn->m_y = m_lower_bound;
okBtn->m_w = 400; okBtn->m_w = 400;
okBtn->m_h = m_area.getHeight() - lower_bound - 15; okBtn->m_h = m_area.getHeight() - m_lower_bound - 15;
okBtn->setParent(m_irrlicht_window); okBtn->setParent(m_irrlicht_window);
m_widgets.push_back(okBtn); m_widgets.push_back(okBtn);
okBtn->add(); okBtn->add();
@ -250,36 +242,30 @@ void GPInfoDialog::InitAfterDrawingTheHeader(const int upper_bound,
okBtn->setFocusForPlayer( PLAYER_ID_GAME_MASTER ); okBtn->setFocusForPlayer( PLAYER_ID_GAME_MASTER );
} }
// ----------------------------------------------------------------------------
void GPInfoDialog::onEnterPressedInternal() void GPInfoDialog::onEnterPressedInternal()
{ {
std::string gp_id = m_gp->getId();
ModalDialog::dismiss(); ModalDialog::dismiss();
// Disable accidentally unlocking of a challenge // Disable accidentally unlocking of a challenge
PlayerManager::getCurrentPlayer()->setCurrentChallenge(""); PlayerManager::getCurrentPlayer()->setCurrentChallenge("");
race_manager->startGP(m_gp, false, false); race_manager->startGP(grand_prix_manager->getGrandPrix(gp_id), false, false);
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
GUIEngine::EventPropagation GPInfoDialog::processEvent(const std::string& eventSource) GUIEngine::EventPropagation GPInfoDialog::processEvent(const std::string& eventSource)
{ {
if (eventSource == "start") if (eventSource == "start" || eventSource == "continue")
{
ModalDialog::dismiss();
race_manager->startGP(m_gp, false, false);
return GUIEngine::EVENT_BLOCK;
}
if (eventSource == "continue")
{ {
// Save GP identifier, since dismiss will delete this object. // Save GP identifier, since dismiss will delete this object.
std::string gp_id = m_gp_ident; std::string gp_id = m_gp->getId();
ModalDialog::dismiss(); ModalDialog::dismiss();
race_manager->startGP(grand_prix_manager->getGrandPrix(gp_id), false, true); race_manager->startGP(grand_prix_manager->getGrandPrix(gp_id), false,
(eventSource == "continue"));
return GUIEngine::EVENT_BLOCK; return GUIEngine::EVENT_BLOCK;
} }
else if (eventSource == "cannot_start")
{
sfx_manager->quickSound( "anvil" );
}
return GUIEngine::EVENT_LET; return GUIEngine::EVENT_LET;
} }
@ -288,12 +274,12 @@ GUIEngine::EventPropagation GPInfoDialog::processEvent(const std::string& eventS
void GPInfoDialog::onUpdate(float dt) void GPInfoDialog::onUpdate(float dt)
{ {
const int frameBefore = (int)(m_curr_time / 1.5f); if (dt == 0)
return; // if nothing changed, return right now
m_curr_time += dt; m_curr_time += dt;
int frameAfter = (int)(m_curr_time / 1.5f); int frameAfter = (int)(m_curr_time / 1.5f);
if (frameAfter == frameBefore) return; // if nothing changed, return right now
const std::vector<std::string> tracks = m_gp->getTrackNames(); const std::vector<std::string> tracks = m_gp->getTrackNames();
if (frameAfter >= (int)tracks.size()) if (frameAfter >= (int)tracks.size())
{ {
@ -301,11 +287,9 @@ void GPInfoDialog::onUpdate(float dt)
m_curr_time = 0; m_curr_time = 0;
} }
Track* track = (tracks.size() == 0 ? NULL : Track* track = track_manager->getTrack(tracks[frameAfter]);
track_manager->getTrack(tracks[frameAfter])); std::string file = track->getScreenshotFile();
std::string fn = track ? track->getScreenshotFile() typedef GUIEngine::IconButtonWidget Icon;
: file_manager->getAsset(FileManager::GUI, "main_help.png"); m_screenshot_widget->setImage(file.c_str(), Icon::ICON_PATH_TYPE_ABSOLUTE);
m_screenshot_widget->setImage(fn.c_str(), IconButtonWidget::ICON_PATH_TYPE_ABSOLUTE);
} }
// ----------------------------------------------------------------------------

42
src/states_screens/dialogs/gp_info_dialog.hpp
View File

@ -33,33 +33,41 @@ namespace GUIEngine
*/ */
class GPInfoDialog : public GUIEngine::ModalDialog class GPInfoDialog : public GUIEngine::ModalDialog
{ {
protected: // Necessary for randomGPInfoDialog protected: // Necessary for RandomGPInfoDialog
std::string m_gp_ident;
GUIEngine::IconButtonWidget* m_screenshot_widget; GUIEngine::IconButtonWidget* m_screenshot_widget;
float m_curr_time; float m_curr_time;
GrandPrixData* m_gp; GrandPrixData* m_gp;
/** height of the separator over the body */
int m_over_body;
/** height of the separator under the titlebar, which is equal to
* m_over_body in a normal GPInfoDialo and lower in RandomGPInfoDialog. */
int m_under_title;
/** height of the seperator over the buttons */
int m_lower_bound;
void addTitle();
/** \brief display all the tracks according to the current gp
* For a normal gp info dialog, it just creates a label for every track.
* But with a random gp info dialog, it tries to reuse as many
* labels as possible by just changing their text. */
void addTracks();
void addScreenshot();
/** display a ok-button and eventually a continue-button */
void addButtons();
/** only used for track_screen.cpp */
GPInfoDialog() : ModalDialog(PERCENT_WIDTH, PERCENT_HEIGHT) {}
public: public:
static const float PERCENT_WIDTH = 0.8f; static const float PERCENT_WIDTH = 0.8f;
static const float PERCENT_HEIGHT = 0.7f; static const float PERCENT_HEIGHT = 0.7f;
/**
* Creates a modal dialog with given percentage of screen width and height
* atm only used in track_screen.cpp
*/
GPInfoDialog() : ModalDialog(PERCENT_WIDTH, PERCENT_HEIGHT) {}
GPInfoDialog(const std::string& gpIdent); GPInfoDialog(const std::string& gpIdent);
/** Places the focus back on the selected GP, in the case that the dialog
* was cancelled and we're returning to the track selection screen */
virtual ~GPInfoDialog(); virtual ~GPInfoDialog();
void InitAfterDrawingTheHeader(const int y1, const int y2,
const std::string& gp_ident);
/** \brief display all the tracks according to the current gp
* For a normal gp info dialog, it just creates a label for every track.
* With its name. But in a random gp info dialog, it tries to reuse as many
* labels as possible by just changing their text. If there are less than
* need, some are added, if there are to many, some are deleted. */
void displayTracks(const int y1, const int y2);
void onEnterPressedInternal(); void onEnterPressedInternal();
GUIEngine::EventPropagation processEvent(const std::string& eventSource); GUIEngine::EventPropagation processEvent(const std::string& eventSource);

84
src/states_screens/dialogs/random_gp_dialog.cpp
View File

@ -17,20 +17,21 @@
#include "guiengine/engine.hpp" #include "guiengine/engine.hpp"
#include "guiengine/widgets/spinner_widget.hpp" #include "guiengine/widgets/spinner_widget.hpp"
#include "guiengine/widget.hpp"
#include "race/grand_prix_manager.hpp" #include "race/grand_prix_manager.hpp"
#include "race/race_manager.hpp"
#include "states_screens/dialogs/random_gp_dialog.hpp" #include "states_screens/dialogs/random_gp_dialog.hpp"
#include "tracks/track_manager.hpp" #include "tracks/track_manager.hpp"
#include <IGUIEnvironment.h> #include <IGUIEnvironment.h>
#include <IGUIStaticText.h> #include <IGUIStaticText.h>
using namespace irr::gui; using irr::core::stringc;
using namespace irr::video; using irr::core::stringw;
using namespace irr::core; using irr::gui::IGUIStaticText;
using namespace GUIEngine;
randomGPInfoDialog::randomGPInfoDialog() typedef GUIEngine::SpinnerWidget Spinner;
RandomGPInfoDialog::RandomGPInfoDialog()
{ {
// Defaults - loading selection from last time frrom a file would be better // Defaults - loading selection from last time frrom a file would be better
m_number_of_tracks = 2; m_number_of_tracks = 2;
@ -40,27 +41,30 @@ randomGPInfoDialog::randomGPInfoDialog()
doInit(); doInit();
m_curr_time = 0.0f; m_curr_time = 0.0f;
int y1 = m_area.getHeight()/7; m_under_title = m_area.getHeight()/7;
m_over_body = m_area.getHeight()/7 + SPINNER_HEIGHT + 10; // 10px space
m_lower_bound = m_area.getHeight()*6/7;
m_gp_ident = "random";
m_gp = new GrandPrixData(m_number_of_tracks, m_trackgroup, m_use_reverse); m_gp = new GrandPrixData(m_number_of_tracks, m_trackgroup, m_use_reverse);
// ---- GP Name addTitle();
core::rect< s32 > area_top(0, 0, m_area.getWidth(), y1); addSpinners();
IGUIStaticText* title = GUIEngine::getGUIEnv()->addStaticText(translations->fribidize("Random Grand Prix"), addTracks();
area_top, false, true, // border, word wrap addScreenshot();
m_irrlicht_window); addButtons();
title->setTabStop(false); }
title->setTextAlignment(EGUIA_CENTER, EGUIA_CENTER);
// ---- Spinners // ----------------------------------------------------------------------------
void RandomGPInfoDialog::addSpinners()
{
// Trackgroup chooser // Trackgroup chooser
GUIEngine::SpinnerWidget* spinner = new GUIEngine::SpinnerWidget(false); Spinner* spinner = new Spinner(false);
spinner->m_properties[PROP_ID] = "Trackgroup"; spinner->m_properties[GUIEngine::PROP_ID] = "Trackgroup";
spinner->setParent(m_irrlicht_window); spinner->setParent(m_irrlicht_window);
m_widgets.push_back(spinner); m_widgets.push_back(spinner);
spinner->add(); spinner->add();
spinner->move(10, m_area.getHeight()/7, 300, 40); spinner->move(10, m_under_title, 300, SPINNER_HEIGHT);
// Fill it with with all the track group names // Fill it with with all the track group names
spinner->addLabel("all"); spinner->addLabel("all");
const std::vector<std::string>& groups = track_manager->getAllTrackGroups(); const std::vector<std::string>& groups = track_manager->getAllTrackGroups();
@ -68,35 +72,41 @@ randomGPInfoDialog::randomGPInfoDialog()
spinner->addLabel(stringw(groups[i].c_str())); spinner->addLabel(stringw(groups[i].c_str()));
// Number of laps chooser // Number of laps chooser
spinner = new GUIEngine::SpinnerWidget(false); spinner = new Spinner(false);
spinner->setValue(m_number_of_tracks); spinner->setValue(m_number_of_tracks);
spinner->setMin(1); spinner->setMin(1);
spinner->setMax(track_manager->getNumberOfTracks()); // default is "all" spinner->setMax(track_manager->getNumberOfTracks()); // default is "all"
spinner->setParent(m_irrlicht_window); spinner->setParent(m_irrlicht_window);
spinner->m_properties[PROP_ID] = "Number of tracks"; spinner->m_properties[GUIEngine::PROP_ID] = "Number of tracks";
m_widgets.push_back(spinner); m_widgets.push_back(spinner);
spinner->add(); spinner->add();
spinner->move(310, m_area.getHeight()/7, 200, 40); spinner->move(310, m_under_title, 200, SPINNER_HEIGHT);
displayTracks(m_area.getHeight()/7 + 50, m_area.getHeight()*6/7);
InitAfterDrawingTheHeader(m_area.getHeight()/7 + 50,
m_area.getHeight()*6/7,
"random");
} }
GUIEngine::EventPropagation randomGPInfoDialog::processEvent( // ----------------------------------------------------------------------------
GUIEngine::EventPropagation RandomGPInfoDialog::processEvent(
const std::string& eventSource) const std::string& eventSource)
{ {
if (eventSource == "Number of tracks") if (eventSource == "start")
{ {
m_number_of_tracks = getWidget<GUIEngine::SpinnerWidget>("Number of tracks")->getValue(); // Save the gp since dismiss deletes it otherwise
GrandPrixData buff = *m_gp;
ModalDialog::dismiss();
race_manager->startGP(&buff, false, false);
return GUIEngine::EVENT_BLOCK;
}
else if (eventSource == "Number of tracks")
{
// The old gp can be reused because there's only track deletion/adding
m_number_of_tracks = getWidget<Spinner>("Number of tracks")->getValue();
m_gp->changeTrackNumber(m_number_of_tracks, m_trackgroup, m_use_reverse); m_gp->changeTrackNumber(m_number_of_tracks, m_trackgroup, m_use_reverse);
displayTracks(m_area.getHeight()/7, m_area.getHeight()*6/7); addTracks();
} }
else if (eventSource == "Trackgroup") else if (eventSource == "Trackgroup")
{ {
GUIEngine::SpinnerWidget* t = getWidget<GUIEngine::SpinnerWidget>("Trackgroup"); Spinner* t = getWidget<Spinner>("Trackgroup");
GUIEngine::SpinnerWidget* s = getWidget<GUIEngine::SpinnerWidget>("Number of tracks"); Spinner* s = getWidget<Spinner>("Number of tracks");
m_trackgroup = stringc(t->getStringValue()).c_str(); m_trackgroup = stringc(t->getStringValue()).c_str();
@ -115,15 +125,17 @@ GUIEngine::EventPropagation randomGPInfoDialog::processEvent(
updateGP(); updateGP();
} }
return GPInfoDialog::processEvent(eventSource); return GUIEngine::EVENT_LET;
} }
void randomGPInfoDialog::updateGP() // ----------------------------------------------------------------------------
void RandomGPInfoDialog::updateGP()
{ {
if (m_gp != NULL) if (m_gp != NULL)
delete m_gp; delete m_gp;
m_gp = new GrandPrixData(m_number_of_tracks, m_trackgroup, m_use_reverse); m_gp = new GrandPrixData(m_number_of_tracks, m_trackgroup, m_use_reverse);
displayTracks(m_area.getHeight()/7, m_area.getHeight()*6/7); addTracks();
} }

14
src/states_screens/dialogs/random_gp_dialog.hpp
View File

@ -18,12 +18,11 @@
#ifndef HEADER_RANDOM_GP_INFO_DIALOG_HPP #ifndef HEADER_RANDOM_GP_INFO_DIALOG_HPP
#define HEADER_RANDOM_GP_INFO_DIALOG_HPP #define HEADER_RANDOM_GP_INFO_DIALOG_HPP
#include "guiengine/widgets/spinner_widget.hpp"
#include "states_screens/dialogs/gp_info_dialog.hpp" #include "states_screens/dialogs/gp_info_dialog.hpp"
#include <string> #include <string>
class randomGPInfoDialog : public GPInfoDialog class RandomGPInfoDialog : public GPInfoDialog
{ {
private: private:
unsigned int m_number_of_tracks; unsigned int m_number_of_tracks;
@ -31,10 +30,17 @@ private:
bool m_use_reverse; bool m_use_reverse;
public: public:
randomGPInfoDialog(); static const int SPINNER_HEIGHT = 40;
~randomGPInfoDialog() { delete m_gp; }
RandomGPInfoDialog();
~RandomGPInfoDialog() { delete m_gp; }
/** Adds a SpinnerWidgets to choose the track groups and one to choose the
* number of tracks */
void addSpinners();
GUIEngine::EventPropagation processEvent(const std::string& eventSource); GUIEngine::EventPropagation processEvent(const std::string& eventSource);
/** Constructs a new gp from the members */
void updateGP(); void updateGP();
}; };

11
src/states_screens/tracks_screen.cpp
View File

@ -119,10 +119,10 @@ void TracksScreen::eventCallback(Widget* widget, const std::string& name,
} }
else else
{ {
if (selection != "Random") if (selection == "Random Grand Prix")
new GPInfoDialog(selection); new RandomGPInfoDialog();
else else
new randomGPInfoDialog(); new GPInfoDialog(selection);
} }
} }
else if (name == "trackgroups") else if (name == "trackgroups")
@ -214,10 +214,11 @@ void TracksScreen::init()
} }
} }
// Random GP - not finished yet // Random GP
std::vector<std::string> screenshots; std::vector<std::string> screenshots;
screenshots.push_back("gui/main_help.png"); screenshots.push_back("gui/main_help.png");
gps_widget->addAnimatedItem(translations->fribidize("Random"), "Random", gps_widget->addAnimatedItem(translations->fribidize("Random Grand Prix"),
"Random Grand Prix",
screenshots, 1.5f, 0, screenshots, 1.5f, 0,
IconButtonWidget::ICON_PATH_TYPE_ABSOLUTE); IconButtonWidget::ICON_PATH_TYPE_ABSOLUTE);