void AddonsLoading::doUninstall()
{
delete m_download_request;
m_download_request = NULL;
bool error = !addons_manager->uninstall(m_addon);
if(error)
{
Log::warn("Addons", "Directory '%s' can not be removed.",
m_addon.getDataDir().c_str());
Log::warn("Addons", "Please remove this directory manually.");
core::stringw msg = StringUtils::insertValues(_("Problems removing the addon '%s'."),
core::stringw(m_addon.getName().c_str()));
getWidget<BubbleWidget>("description")->setText(msg.c_str());
}
if(error)
{
m_progress->setVisible(false);
RibbonWidget* r = getWidget<RibbonWidget>("actions");
r->setVisible(true);
IconButtonWidget *u = getWidget<IconButtonWidget> ("uninstall" );
u->setLabel(_("Try again"));
}
else
{
// The list of the addon screen needs to be updated to correctly
// display the newly (un)installed addon.
AddonsScreen::getInstance()->loadList();
dismiss();
}
} // doUninstall
// ----------------------------------------------------------------------------
//
void MainMenuScreen::init()
{
Screen::init();
m_user_id = getWidget<ButtonWidget>("user-id");
assert(m_user_id);
// reset in case we're coming back from a race
StateManager::get()->resetActivePlayers();
input_manager->getDeviceManager()->setAssignMode(NO_ASSIGN);
input_manager->getDeviceManager()->setSinglePlayer( NULL );
input_manager->setMasterPlayerOnly(false);
// Avoid incorrect behaviour in certain race circumstances:
// If a multi-player game is played with two keyboards, the 2nd
// player selects his kart last, and only the keyboard is used
// to select all other settings - then if the next time the kart
// selection screen comes up, the default device will still be
// the 2nd player. So if the first player presses 'select', it
// will instead add a second player (so basically the key
// binding for the second player become the default, so pressing
// select will add a new player). See bug 3090931
// To avoid this, we will clean the last used device, making
// the key bindings for the first player the default again.
input_manager->getDeviceManager()->clearLatestUsedDevice();
if (addons_manager->isLoading())
{
IconButtonWidget* w = getWidget<IconButtonWidget>("addons");
w->setDeactivated();
w->resetAllBadges();
w->setBadge(LOADING_BADGE);
}
m_online = getWidget<IconButtonWidget>("online");
if(!m_enable_online)
m_online->setDeactivated();
LabelWidget* w = getWidget<LabelWidget>("info_addons");
const core::stringw &news_text = NewsManager::get()->getNextNewsMessage();
w->setText(news_text, true);
w->update(0.01f);
RibbonWidget* r = getWidget<RibbonWidget>("menu_bottomrow");
// FIXME: why do I need to do this manually
((IconButtonWidget*)r->getChildren().get(0))->unfocused(PLAYER_ID_GAME_MASTER, NULL);
((IconButtonWidget*)r->getChildren().get(1))->unfocused(PLAYER_ID_GAME_MASTER, NULL);
((IconButtonWidget*)r->getChildren().get(2))->unfocused(PLAYER_ID_GAME_MASTER, NULL);
r = getWidget<RibbonWidget>("menu_toprow");
r->setFocusForPlayer(PLAYER_ID_GAME_MASTER);
DemoWorld::resetIdleTime();
#if _IRR_MATERIAL_MAX_TEXTURES_ < 8
getWidget<IconButtonWidget>("logo")->setImage("gui/logo_broken.png",
IconButtonWidget::ICON_PATH_TYPE_RELATIVE);
#endif
} // init
// ----------------------------------------------------------------------------
void MessageDialog::loadedFromFile()
{
LabelWidget* message = getWidget<LabelWidget>("title");
message->setText( m_msg, false );
RibbonWidget* ribbon = getWidget<RibbonWidget>("buttons");
ribbon->setFocusForPlayer(PLAYER_ID_GAME_MASTER);
// If the dialog is a simple 'OK' dialog, then hide the "Yes" button and
// change "Cancel" to "OK"
if (m_type == MessageDialog::MESSAGE_DIALOG_OK)
{
IconButtonWidget* yesbtn = getWidget<IconButtonWidget>("cancel");
yesbtn->setVisible(false);
IconButtonWidget* cancelbtn = getWidget<IconButtonWidget>("confirm");
cancelbtn->setText(_("OK"));
cancelbtn->setFocusForPlayer(PLAYER_ID_GAME_MASTER);
}
else if (m_type == MessageDialog::MESSAGE_DIALOG_YESNO)
{
IconButtonWidget* cancelbtn = getWidget<IconButtonWidget>("cancel");
cancelbtn->setText(_("No"));
}
else if (m_type == MessageDialog::MESSAGE_DIALOG_OK_CANCEL)
{
// In case of a OK_CANCEL dialog, change the text from 'Yes' to 'Ok'
IconButtonWidget* yesbtn = getWidget<IconButtonWidget>("confirm");
yesbtn->setText(_("OK"));
}
}
// -----------------------------------------------------------------------------
void EditGPScreen::init()
{
if (m_action.empty())
{
LabelWidget* header = getWidget<LabelWidget>("title");
assert(header != NULL);
header->setText(m_gp->getName(), true);
IconButtonWidget* button = getWidget<IconButtonWidget>("save");
assert(button != NULL);
button->setDeactivated();
loadList(0);
setModified(false);
}
else
{
EditTrackScreen* edit = EditTrackScreen::getInstance();
assert(edit != NULL);
if (edit->getResult())
{
if (m_action == "add")
{
m_gp->addTrack(edit->getTrack(), edit->getLaps(), edit->getReverse(),
m_selected);
setSelected(m_selected + 1);
}
else if (m_action == "edit")
{
m_gp->editTrack(m_selected, edit->getTrack(), edit->getLaps(),
edit->getReverse());
}
setModified(true);
}
loadList(m_selected);
m_action.clear();
}
}
// -----------------------------------------------------------------------------
void DynamicRibbonWidget::buildInternalStructure()
{
//printf("****DynamicRibbonWidget::buildInternalStructure()****\n");
// ---- Clean-up what was previously there
for (unsigned int i=0; i<m_children.size(); i++)
{
IGUIElement* elem = m_children[i].m_element;
if (elem != NULL && m_children[i].m_type == WTYPE_RIBBON)
{
elem->remove();
m_children.erase(i);
i--;
}
}
m_rows.clearWithoutDeleting(); // rows already deleted above, don't double-delete
m_left_widget->m_element->setVisible(true);
assert( m_left_widget->ok() );
assert( m_right_widget->ok() );
// ---- determine column amount
const float row_height = (float)(m_h - m_label_height)/(float)m_row_amount;
float ratio_zoom = (float)row_height / (float)(m_child_height - m_label_height);
m_col_amount = (int)roundf( m_w / ( m_child_width*ratio_zoom ) );
// ajust column amount to not add more item slots than we actually need
const int item_count = (int) m_items.size();
//Log::info("DynamicRibbonWidget", "%d items; %d cells", item_count, row_amount * m_col_amount);
if (m_row_amount*m_col_amount > item_count)
{
m_col_amount = (int)ceil((float)item_count/(float)m_row_amount);
//Log::info("DynamicRibbonWidget", "Adjusting m_col_amount to be %d", m_col_amount);
}
assert( m_left_widget->ok() );
assert( m_right_widget->ok() );
// Hide arrows when everything is visible
if (item_count <= m_row_amount*m_col_amount)
{
m_scrolling_enabled = false;
m_left_widget->m_element->setVisible(false);
m_right_widget->m_element->setVisible(false);
}
else
{
m_scrolling_enabled = true;
m_left_widget->m_element->setVisible(true);
m_right_widget->m_element->setVisible(true);
}
// ---- add rows
int added_item_count = 0;
for (int n=0; n<m_row_amount; n++)
{
RibbonWidget* ribbon;
if (m_combo)
{
ribbon = new RibbonWidget(RIBBON_COMBO);
}
else
{
ribbon = new RibbonWidget(RIBBON_TOOLBAR);
}
ribbon->setListener(this);
ribbon->m_reserved_id = m_ids[n];
ribbon->m_x = m_x + (m_scrolling_enabled ? m_arrows_w : 0);
ribbon->m_y = m_y + (int)(n*row_height);
ribbon->m_w = m_w - (m_scrolling_enabled ? m_arrows_w*2 : 0);
ribbon->m_h = (int)(row_height);
ribbon->m_type = WTYPE_RIBBON;
std::stringstream name;
name << this->m_properties[PROP_ID] << "_row" << n;
ribbon->m_properties[PROP_ID] = name.str();
ribbon->m_event_handler = this;
// calculate font size
if (m_col_amount > 0)
{
m_font->setScale(GUIEngine::getFont()->getScale() *
getFontScale((ribbon->m_w / m_col_amount) - 30));
}
// add columns
for (int i=0; i<m_col_amount; i++)
{
// stretch the *texture* within the widget (and the widget has the right aspect ratio)
// (Yeah, that's complicated, but screenshots are saved compressed horizontally so it's hard to be clean)
IconButtonWidget* icon = new IconButtonWidget(IconButtonWidget::SCALE_MODE_STRETCH, false, true);
icon->m_properties[PROP_ICON]="textures/transparence.png";
// set size to get proper ratio (as most textures are saved scaled down to 256x256)
icon->m_properties[PROP_WIDTH] = m_properties[PROP_CHILD_WIDTH];
icon->m_properties[PROP_HEIGHT] = m_properties[PROP_CHILD_HEIGHT];
icon->m_w = atoi(icon->m_properties[PROP_WIDTH].c_str());
icon->m_h = atoi(icon->m_properties[PROP_HEIGHT].c_str());
icon->setLabelFont(m_font);
// If we want each icon to have its own label, we must make it non-empty, otherwise
// it will assume there is no label and none will be created (FIXME: that's ugly)
if (m_properties[PROP_LABELS_LOCATION] == "each") icon->m_text = " ";
//Log::info("DynamicRibbonWidget", "Ribbon text = %s", m_properties[PROP_TEXT].c_str());
ribbon->m_children.push_back( icon );
added_item_count++;
// stop adding columns when we have enough items
if (added_item_count == item_count)
{
assert(!m_scrolling_enabled); // we can see all items, so scrolling must be off
break;
}
else if (added_item_count > item_count)
{
assert(false);
break;
}
}
m_children.push_back( ribbon );
m_rows.push_back( ribbon );
ribbon->add();
// stop filling rows when we have enough items
if (added_item_count == item_count)
{
assert(!m_scrolling_enabled); // we can see all items, so scrolling must be off
break;
}
}
#ifdef DEBUG
if (!m_scrolling_enabled)
{
// debug checks
int childrenCount = 0;
for (unsigned int n=0; n<m_rows.size(); n++)
{
childrenCount += m_rows[n].m_children.size();
}
assert(childrenCount == (int)m_items.size());
}
#endif
}
SelectChallengeDialog::SelectChallengeDialog(const float percentWidth,
const float percentHeight,
std::string challenge_id) :
ModalDialog(percentWidth, percentHeight)
{
loadFromFile("select_challenge.stkgui");
m_challenge_id = challenge_id;
World::getWorld()->schedulePause(WorldStatus::IN_GAME_MENU_PHASE);
switch (UserConfigParams::m_difficulty)
{
case 0:
getWidget("novice")->setFocusForPlayer(PLAYER_ID_GAME_MASTER);
break;
case 1:
getWidget("intermediate")->setFocusForPlayer(PLAYER_ID_GAME_MASTER);
break;
case 2:
getWidget("expert")->setFocusForPlayer(PLAYER_ID_GAME_MASTER);
break;
}
const ChallengeStatus* c = PlayerManager::getCurrentPlayer()
->getChallengeStatus(challenge_id);
if (c->isSolved(RaceManager::DIFFICULTY_EASY))
{
IconButtonWidget* btn = getWidget<IconButtonWidget>("novice");
btn->setImage(file_manager->getAsset(FileManager::GUI, "cup_bronze.png"),
IconButtonWidget::ICON_PATH_TYPE_ABSOLUTE);
}
if (c->isSolved(RaceManager::DIFFICULTY_MEDIUM))
{
IconButtonWidget* btn = getWidget<IconButtonWidget>("intermediate");
btn->setImage(file_manager->getAsset(FileManager::GUI,"cup_silver.png"),
IconButtonWidget::ICON_PATH_TYPE_ABSOLUTE);
}
if (c->isSolved(RaceManager::DIFFICULTY_HARD))
{
IconButtonWidget* btn = getWidget<IconButtonWidget>("expert");
btn->setImage(file_manager->getAsset(FileManager::GUI,"cup_gold.png"),
IconButtonWidget::ICON_PATH_TYPE_ABSOLUTE);
}
LabelWidget* novice_label = getWidget<LabelWidget>("novice_label");
LabelWidget* medium_label = getWidget<LabelWidget>("intermediate_label");
LabelWidget* expert_label = getWidget<LabelWidget>("difficult_label");
novice_label->setText( getLabel(RaceManager::DIFFICULTY_EASY, c->getData()), false );
medium_label->setText( getLabel(RaceManager::DIFFICULTY_MEDIUM, c->getData()), false );
expert_label->setText( getLabel(RaceManager::DIFFICULTY_HARD, c->getData()), false );
if (c->getData()->isGrandPrix())
{
const GrandPrixData* gp = grand_prix_manager->getGrandPrix(c->getData()->getGPId());
getWidget<LabelWidget>("title")->setText( gp->getName(), true );
}
else
{
const wchar_t* track_name = track_manager->getTrack(c->getData()->getTrackId())->getName();
getWidget<LabelWidget>("title")->setText( track_name, true );
}
LabelWidget* typeLbl = getWidget<LabelWidget>("race_type_val");
if (c->getData()->isGrandPrix())
typeLbl->setText(_("Grand Prix"), false );
else if (c->getData()->getEnergy(RaceManager::DIFFICULTY_EASY) > 0)
typeLbl->setText(_("Nitro challenge"), false );
else
typeLbl->setText( RaceManager::getNameOf(c->getData()->getMinorMode()), false );
}
TrackInfoDialog::TrackInfoDialog(const std::string& ribbonItem, const std::string& trackIdent,
const irr::core::stringw& trackName, ITexture* screenshot,
const float w, const float h) : ModalDialog(w, h)
{
loadFromFile("track_info_dialog.stkgui");
const bool has_laps = race_manager->modeHasLaps();
const bool has_highscores = race_manager->modeHasHighscores();
m_track_ident = trackIdent;
m_ribbon_item = ribbonItem;
getWidget<LabelWidget>("name")->setText(trackName.c_str(), false);
Track* track = track_manager->getTrack(trackIdent);
//I18N: when showing who is the author of track '%s' (place %s where the name of the author should appear)
getWidget<LabelWidget>("author")->setText( _("Track by %s", track->getDesigner().c_str()), false );
// ---- Track screenshot
Widget* screenshot_div = getWidget("screenshot_div");
IconButtonWidget* screenshotWidget = new IconButtonWidget(IconButtonWidget::SCALE_MODE_KEEP_CUSTOM_ASPECT_RATIO,
false /* tab stop */, false /* focusable */);
// images are saved squared, but must be stretched to 4:
screenshotWidget->setCustomAspectRatio(4.0f / 3.0f);
screenshotWidget->m_x = screenshot_div->m_x;
screenshotWidget->m_y = screenshot_div->m_y;
screenshotWidget->m_w = screenshot_div->m_w;
screenshotWidget->m_h = screenshot_div->m_h;
// temporary icon, will replace it just after (but it will be shown if the given icon is not found)
screenshotWidget->m_properties[PROP_ICON] = "gui/main_help.png";
screenshotWidget->setParent(m_irrlicht_window);
screenshotWidget->add();
if (screenshot != NULL)
{
screenshotWidget->setImage(screenshot);
}
m_widgets.push_back(screenshotWidget);
// ---- Lap count m_spinner
if (has_laps)
{
m_spinner = getWidget<SpinnerWidget>("lapcountspinner");
m_spinner->m_properties[PROP_ID] = "lapcountspinner";
if (UserConfigParams::m_artist_debug_mode)
{
m_spinner->setMin(0);
}
//I18N: In the track setup screen (number of laps choice, where %i is the number)
//m_spinner->setText( _("%i laps") );
m_spinner->setValue( UserConfigParams::m_num_laps );
//m_spinner->getIrrlichtElement()->setTabStop(true);
//m_spinner->getIrrlichtElement()->setTabGroup(false);
const int num_laps = m_spinner->getValue();
race_manager->setNumLaps(num_laps);
}
else
{
getWidget<SpinnerWidget>("lapcountspinner")->setVisible(false);
m_spinner = NULL;
}
// Reverse track
const bool reverse_available = track->reverseAvailable() &&
race_manager->getMinorMode() != RaceManager::MINOR_MODE_EASTER_EGG;
if (reverse_available)
{
m_checkbox = getWidget<CheckBoxWidget>("reverse");
m_checkbox->setState(race_manager->getReverseTrack());
}
else
{
getWidget<CheckBoxWidget>("reverse")->setVisible(false);
getWidget<LabelWidget>("reverse-text")->setVisible(false);
m_checkbox = NULL;
race_manager->setReverseTrack(false);
}
// ---- High Scores
if (has_highscores)
{
m_kart_icons[0] = getWidget<IconButtonWidget>("iconscore1");
m_kart_icons[1] = getWidget<IconButtonWidget>("iconscore2");
m_kart_icons[2] = getWidget<IconButtonWidget>("iconscore3");
m_highscore_entries[0] = getWidget<LabelWidget>("highscore1");
m_highscore_entries[1] = getWidget<LabelWidget>("highscore2");
m_highscore_entries[2] = getWidget<LabelWidget>("highscore3");
updateHighScores();
}
else
{
getWidget<IconButtonWidget>("iconscore1")->setVisible(false);
getWidget<IconButtonWidget>("iconscore2")->setVisible(false);
getWidget<IconButtonWidget>("iconscore3")->setVisible(false);
getWidget<LabelWidget>("highscores")->setVisible(false);
getWidget<LabelWidget>("highscore1")->setVisible(false);
getWidget<LabelWidget>("highscore2")->setVisible(false);
getWidget<LabelWidget>("highscore3")->setVisible(false);
}
getWidget<ButtonWidget>("start")->setFocusForPlayer( PLAYER_ID_GAME_MASTER );
} // TrackInfoDialog