void TextCommandEditor::action(const ActionEvent &event)
{
const std::string &eventId = event.getId();
if (eventId == "magic")
{
mIsMagicCommand = true;
showControls(Visible_true);
}
else if (eventId == "other")
{
mIsMagicCommand = false;
showControls(Visible_false);
}
else if (eventId == "save")
{
save();
scheduleDelete();
}
else if (eventId == "cancel")
{
scheduleDelete();
}
else if (eventId == "delete")
{
deleteCommand();
scheduleDelete();
}
}
/**
* mouse move handler hides controls in next 3s
* @param event
*/
void MediaApp::mouseMoveEvent(QMouseEvent *event) {
Q_UNUSED(event);
if (isFullScreen()) {
showControls();
m_fullScreenTimer.start(3000);
}
}
PathDeformWidget::PathDeformWidget(QWidget *parent, bool smallScreen)
: QWidget(parent)
{
setWindowTitle(tr("Vector Deformation"));
m_renderer = new PathDeformRenderer(this, smallScreen);
m_renderer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
// Layouts
QHBoxLayout *mainLayout = new QHBoxLayout(this);
mainLayout->addWidget(m_renderer);
m_controls = new PathDeformControls(0, m_renderer, smallScreen);
m_controls->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Minimum);
if (!smallScreen)
mainLayout->addWidget(m_controls);
m_renderer->loadSourceFile(":res/deform/pathdeform.cpp");
m_renderer->loadDescription(":res/deform/pathdeform.html");
m_renderer->setDescriptionEnabled(false);
connect(m_renderer, SIGNAL(clicked()), this, SLOT(showControls()));
connect(m_controls, SIGNAL(okPressed()), this, SLOT(hideControls()));
connect(m_controls, SIGNAL(quitPressed()), QApplication::instance(), SLOT(quit()));
}
int main (void) {
/* center messages, etc. */
setupRects();
/* Basic setup */
startSDL();
/* load images */
loadImages();
/* blit them onto the screen */
showControls();
clearScreen(screen);
/* go 3, 2, and 1 */
countdown();
/* put the paddle and the ball in the initial position */
initiateImages();
/* call game loop here, defined in gameloop.c, handover all the filled structs */
initGameloop(&mainPaddle, &mainBall, screen);
int score = runGameloop();
printf("Score: %d\n", score);
SDL_Quit();
return 0;
}
void GcWindow::setControls(QWidget *x)
{
_controls = x;
emit controlsChanged(_controls);
if (x != NULL) {
menu->clear();
menu->addAction(tr("Chart Settings"), this, SIGNAL(showControls()));
menu->addAction(tr("Close"), this, SLOT(_closeWindow()));
}
}
/**
* function changes app's view to fullscreen
*/
void MediaApp::toggleFullScreen() {
if (isFullScreen()) {
setMouseTracking(false);
m_player->setMouseTracking(false);
m_fullScreenTimer.stop();
showControls();
showNormal();
} else {
setMouseTracking(true);
m_player->setMouseTracking(true);
hideControls();
showFullScreen();
}
}
void MyVis::mouseMoveEvent(QMouseEvent *e)
{
if ( cursorTim.isActive() )
cursorTim.stop();
setCursor( Qt::ArrowCursor );
if ( isFullScreen() )
{
if ( e->y() > height() - 70 && e->y() < height() - 5 )
showControls();
else
hideControls();
if ( isFullScreen() )
cursorTim.start( 1500 );
}
}
PathStrokeWidget::PathStrokeWidget(bool smallScreen)
{
setWindowTitle(tr("Path Stroking"));
// Widget construction and property setting
m_renderer = new PathStrokeRenderer(this, smallScreen);
m_controls = new PathStrokeControls(0, m_renderer, smallScreen);
// Layouting
QHBoxLayout *viewLayout = new QHBoxLayout(this);
viewLayout->addWidget(m_renderer);
if (!smallScreen)
viewLayout->addWidget(m_controls);
m_renderer->loadSourceFile(":res/pathstroke/pathstroke.cpp");
m_renderer->loadDescription(":res/pathstroke/pathstroke.html");
connect(m_renderer, SIGNAL(clicked()), this, SLOT(showControls()));
connect(m_controls, SIGNAL(okPressed()), this, SLOT(hideControls()));
connect(m_controls, SIGNAL(quitPressed()), QApplication::instance(), SLOT(quit()));
}
TextCommandEditor::TextCommandEditor(TextCommand *const command) :
// TRANSLATORS: command editor name
Window(_("Command Editor"), Modal_false, nullptr, "commandeditor.xml"),
ActionListener(),
mIsMagicCommand(command ?
(command->getCommandType() == TEXT_COMMAND_MAGIC) : false),
mCommand(command),
// TRANSLATORS: command editor button
mIsMagic(new RadioButton(this, _("magic"), "magic", mIsMagicCommand)),
// TRANSLATORS: command editor button
mIsOther(new RadioButton(this, _("other"), "magic", !mIsMagicCommand)),
// TRANSLATORS: command editor label
mSymbolLabel(new Label(this, _("Symbol:"))),
mSymbolTextField(new TextField(this)),
// TRANSLATORS: command editor label
mCommandLabel(new Label(this, _("Command:"))),
mCommandTextField(new TextField(this)),
// TRANSLATORS: command editor label
mCommentLabel(new Label(this, _("Comment:"))),
mCommentTextField(new TextField(this)),
mTargetTypeModel(new TargetTypeModel),
// TRANSLATORS: command editor label
mTypeLabel(new Label(this, _("Target Type:"))),
mTypeDropDown(new DropDown(this, mTargetTypeModel)),
mIconsModel(new IconsModel),
// TRANSLATORS: command editor label
mIconLabel(new Label(this, _("Icon:"))),
mIconDropDown(new DropDown(this, mIconsModel)),
// TRANSLATORS: command editor label
mManaLabel(new Label(this, _("Mana:"))),
mManaField(new IntTextField(this, 0)),
// TRANSLATORS: command editor label
mMagicLvlLabel(new Label(this, _("Magic level:"))),
mMagicLvlField(new IntTextField(this, 0)),
mMagicSchoolModel(new MagicSchoolModel),
// TRANSLATORS: command editor label
mSchoolLabel(new Label(this, _("Magic School:"))),
mSchoolDropDown(new DropDown(this, mMagicSchoolModel)),
// TRANSLATORS: command editor label
mSchoolLvlLabel(new Label(this, _("School level:"))),
mSchoolLvlField(new IntTextField(this, 0)),
// TRANSLATORS: command editor button
mCancelButton(new Button(this, _("Cancel"), "cancel", this)),
// TRANSLATORS: command editor button
mSaveButton(new Button(this, _("Save"), "save", this)),
// TRANSLATORS: command editor button
mDeleteButton(new Button(this, _("Delete"), "delete", this)),
mEnabledKeyboard(keyboard.isEnabled())
{
const int w = 350;
const int h = 370;
keyboard.setEnabled(false);
setWindowName("TextCommandEditor");
setDefaultSize(w, h, ImageRect::CENTER);
mIsMagic->setActionEventId("magic");
mIsMagic->addActionListener(this);
mIsOther->setActionEventId("other");
mIsOther->addActionListener(this);
mManaField->setRange(0, 500);
mManaField->setWidth(20);
mTypeDropDown->setActionEventId("type");
mTypeDropDown->addActionListener(this);
mIconDropDown->setActionEventId("icon");
mIconDropDown->addActionListener(this);
mIconDropDown->setSelectedString(mCommand->getIcon());
mMagicLvlField->setRange(0, 5);
mMagicLvlField->setWidth(20);
mSchoolDropDown->setActionEventId("school");
mSchoolDropDown->addActionListener(this);
mSchoolDropDown->setSelected(0);
mSchoolLvlField->setRange(0, 5);
mSchoolLvlField->setWidth(20);
mSaveButton->adjustSize();
mCancelButton->adjustSize();
mDeleteButton->adjustSize();
if (command)
{
if (command->getCommandType() == TEXT_COMMAND_MAGIC)
showControls(Visible_true);
else
showControls(Visible_false);
mSymbolTextField->setText(command->getSymbol());
mCommandTextField->setText(command->getCommand());
mCommentTextField->setText(command->getComment());
mManaField->setValue(command->getMana());
mTypeDropDown->setSelected(static_cast<int>(command->getTargetType()));
mMagicLvlField->setValue(command->getBaseLvl());
mSchoolDropDown->setSelected(static_cast<int>(command->getSchool())
- MAGIC_START_ID);
mSchoolLvlField->setValue(command->getSchoolLvl());
}
ContainerPlacer placer;
placer = getPlacer(0, 0);
placer(0, 0, mIsMagic, 1);
placer(2, 0, mIsOther, 1);
placer(0, 1, mSymbolLabel, 2).setPadding(3);
placer(2, 1, mSymbolTextField, 3).setPadding(3);
placer(0, 2, mCommandLabel, 2).setPadding(3);
placer(2, 2, mCommandTextField, 4).setPadding(3);
placer(0, 3, mCommentLabel, 2).setPadding(3);
placer(2, 3, mCommentTextField, 4).setPadding(3);
placer(0, 4, mTypeLabel, 2).setPadding(3);
placer(2, 4, mTypeDropDown, 3).setPadding(3);
placer(0, 5, mIconLabel, 2).setPadding(3);
placer(2, 5, mIconDropDown, 3).setPadding(3);
placer(0, 6, mManaLabel, 2).setPadding(3);
placer(2, 6, mManaField, 3).setPadding(3);
placer(0, 7, mMagicLvlLabel, 2).setPadding(3);
placer(2, 7, mMagicLvlField, 3).setPadding(3);
placer(0, 8, mSchoolLabel, 2).setPadding(3);
placer(2, 8, mSchoolDropDown, 3).setPadding(3);
placer(0, 9, mSchoolLvlLabel, 2).setPadding(3);
placer(2, 9, mSchoolLvlField, 3).setPadding(3);
placer(0, 10, mSaveButton, 2).setPadding(3);
placer(2, 10, mCancelButton, 2).setPadding(3);
placer(4, 10, mDeleteButton, 2).setPadding(3);
setWidth(w);
setHeight(h);
reflowLayout(w);
center();
}
Window::Window(const QString& file)
: m_pause_action(0), m_previous_state(0) {
setAcceptDrops(true);
// Create states
m_states.insert("NewGame", new NewGameState(this));
m_states.insert("OpenGame", new OpenGameState(this));
m_states.insert("Optimizing", new OptimizingState(this));
m_states.insert("Play", new PlayState(this));
m_states.insert("AutoPause", new AutoPauseState(this));
m_states.insert("Pause", new PauseState(this));
m_states.insert("Finish", new FinishState(this));
m_state = m_states.value("NewGame");
// Create widgets
m_contents = new QStackedWidget(this);
setCentralWidget(m_contents);
m_board = new Board(this);
m_contents->addWidget(m_board);
connect(m_board, &Board::started, this, &Window::gameStarted);
connect(m_board, &Board::finished, this, &Window::gameFinished);
connect(m_board, &Board::optimizingStarted, this, &Window::optimizingStarted);
connect(m_board, &Board::optimizingFinished, this, &Window::optimizingFinished);
// Create pause screen
m_pause_screen = new QLabel(tr("<p><b><big>Paused</big></b><br>Click to resume playing.</p>"), this);
m_pause_screen->setAlignment(Qt::AlignCenter);
m_pause_screen->installEventFilter(this);
m_contents->addWidget(m_pause_screen);
// Create open game screen
QLabel* open_game_screen = new QLabel(tr("<p><b><big>Please wait</big></b><br>Loading game...</p>"), this);
open_game_screen->setAlignment(Qt::AlignCenter);
m_contents->addWidget(open_game_screen);
// Create start screen
QLabel* start_screen = new QLabel(tr("Click to start a new game."), this);
start_screen->setAlignment(Qt::AlignCenter);
start_screen->installEventFilter(this);
m_contents->addWidget(start_screen);
// Create new game screen
QLabel* new_game_screen = new QLabel(tr("<p><b><big>Please wait</big></b><br>Generating a new board...</p>"), this);
new_game_screen->setAlignment(Qt::AlignCenter);
m_contents->addWidget(new_game_screen);
// Create optimizing screen
QLabel* optimizing_screen = new QLabel(tr("<p><b><big>Please wait</big></b><br>Optimizing word list...</p>"), this);
optimizing_screen->setAlignment(Qt::AlignCenter);
m_contents->addWidget(optimizing_screen);
// Create game menu
QMenu* menu = menuBar()->addMenu(tr("&Game"));
menu->addAction(tr("New &Game..."), this, SLOT(newGame()), tr("Ctrl+Shift+N"));
menu->addAction(tr("&New Roll"), this, SLOT(newRoll()), QKeySequence::New);
menu->addAction(tr("&Choose..."), this, SLOT(chooseGame()));
menu->addAction(tr("&Share..."), this, SLOT(shareGame()));
menu->addSeparator();
QAction* end_action = menu->addAction(tr("&End"), this, SLOT(endGame()));
end_action->setEnabled(false);
connect(m_board, &Board::pauseAvailable, end_action, &QAction::setEnabled);
m_pause_action = menu->addAction(tr("&Pause"));
m_pause_action->setCheckable(true);
m_pause_action->setShortcut(tr("Ctrl+P"));
m_pause_action->setEnabled(false);
connect(m_pause_action, &QAction::triggered, this, &Window::setPaused);
connect(m_board, &Board::pauseAvailable, m_pause_action, &QAction::setEnabled);
menu->addSeparator();
m_details_action = menu->addAction(tr("&Details"), this, SLOT(showDetails()));
m_details_action->setEnabled(false);
menu->addAction(tr("&High Scores"), this, SLOT(showScores()));
menu->addSeparator();
QAction* action = menu->addAction(tr("&Quit"), this, SLOT(close()), tr("Ctrl+Q"));
action->setMenuRole(QAction::QuitRole);
monitorVisibility(menu);
// Create settings menu
menu = menuBar()->addMenu(tr("&Settings"));
QMenu* submenu = menu->addMenu(tr("Show &Maximum Score"));
QAction* score_actions[3];
score_actions[0] = submenu->addAction(tr("&Never"));
score_actions[1] = submenu->addAction(tr("&End Of Game"));
score_actions[2] = submenu->addAction(tr("&Always"));
QActionGroup* group = new QActionGroup(this);
for (int i = 0; i < 3; ++i) {
score_actions[i]->setData(i);
score_actions[i]->setCheckable(true);
group->addAction(score_actions[i]);
}
connect(group, &QActionGroup::triggered, m_board, &Board::setShowMaximumScore);
QAction* missed_action = menu->addAction(tr("Show Missed &Words"));
missed_action->setCheckable(true);
connect(missed_action, &QAction::toggled, m_board, &Board::setShowMissedWords);
QAction* counts_action = menu->addAction(tr("Show Word &Counts"));
counts_action->setCheckable(true);
counts_action->setChecked(true);
connect(counts_action, &QAction::toggled, m_board, &Board::setShowWordCounts);
menu->addAction(tr("&Board Language..."), this, SLOT(showLanguage()));
menu->addSeparator();
menu->addAction(tr("Application &Language..."), this, SLOT(showLocale()));
monitorVisibility(menu);
// Create help menu
menu = menuBar()->addMenu(tr("&Help"));
menu->addAction(tr("&Controls"), this, SLOT(showControls()));
menu->addSeparator();
action = menu->addAction(tr("&About"), this, SLOT(about()));
action->setMenuRole(QAction::AboutRole);
action = menu->addAction(tr("About &Hspell"), this, SLOT(aboutHspell()));
action->setMenuRole(QAction::ApplicationSpecificRole);
action = menu->addAction(tr("About &Qt"), qApp, SLOT(aboutQt()));
action->setMenuRole(QAction::AboutQtRole);
action = menu->addAction(tr("About &SCOWL"), this, SLOT(aboutScowl()));
action->setMenuRole(QAction::ApplicationSpecificRole);
monitorVisibility(menu);
// Load settings
QSettings settings;
QAction* score_action = score_actions[qBound(0, settings.value("ShowMaximumScore", 1).toInt(), 2)];
score_action->setChecked(true);
m_board->setShowMaximumScore(score_action);
missed_action->setChecked(settings.value("ShowMissed", true).toBool());
counts_action->setChecked(settings.value("ShowWordCounts", true).toBool());
restoreGeometry(settings.value("Geometry").toByteArray());
// Start game
QString current = file;
if (settings.contains("Current/Version")) {
if (current.isEmpty() ||
QMessageBox::question(this, tr("Question"), tr("End the current game?"), QMessageBox::Yes | QMessageBox::No, QMessageBox::No) == QMessageBox::No) {
current = ":saved:";
}
}
m_state->finish();
m_contents->setCurrentIndex(3);
if (current.isEmpty()) {
newGame();
} else {
startGame(current);
}
}
int main()
{
// Initialize globals
initGlobals();
// Window
window.setSize(sf::Vector2u(window_width, window_height));
window.setPosition(sf::Vector2i(200, 200));
window.setFramerateLimit(FRAMES_PER_SECOND);
//window.setVerticalSyncEnabled(true);
window.setKeyRepeatEnabled(false);
// Camera view
sf::View windowView;
// Menu
initializeMenu();
// UI
ui.init();
// Minimap
// Minimap minimap;
// Create & Set contactlistener
BoxContactListener boxContactListener;
physicsWorld.SetContactListener(&boxContactListener);
// Build world
//gameWorld.generateWorld(physicsWorld);
// ------------------------------- MAIN LOOP -------------------------------
while(window.isOpen())
{
// ------------------------------- Input & Views -------------------------------
sf::Event event;
gameEvents.processEvents(window, event);
// Update view in case of window resize
window_width = window.getSize().x;
window_height = window.getSize().y;
windowView.setSize(window_width, window_height);
// if(minimap.updateViewThroughMinimap)
// {
// windowView.setCenter(minimap.newViewCenter.x, minimap.newViewCenter.y);
// }
if(player.hasNewFocus)
{
windowView.setCenter(player.getNewFocus().x, player.getNewFocus().y);
}
// Update normal view with inputs
windowView = updateView(windowView);
if(gameWorld.completionStarted && gameWorld.completionTimer.timeReached())
{
windowView.setCenter(window_width/2, window_height/2);
global_levelComplete = false;
}
// Clear window
window.clear(sf::Color(255, 255, 255, 255));
if(global_isMenu)
{
ui.setSize(window_width, window_height);
window.setView(ui.getView());
menu_logo_bottom->setPosition(window_width - textures["menu_logo_bottom"].getSize().x, window_height - textures["menu_logo_bottom"].getSize().y);
menu.update(gameEvents);
menu.draw(window);
// Instructions
if(show_instructions)
{
showInstructions();
if(show_instructions_controls)
{
showControls();
}
if(show_instructions_gameplay)
{
showGameplay();
}
}
}
else
{
window.setView(windowView);
// ------------------------------- Updates -------------------------------
// Player
player.update(physicsWorld, gameEvents, gameWorld);
if(!global_isPaused)
{
// Physics
physicsWorld.Step(TIME_STEP, VELOCITY_ITERATIONS, POSITION_ITERATIONS);
// World
gameWorld.update(gameEvents, physicsWorld, player);
// UI
ui.update(gameWorld, player);
}
// Calculate viewable area
int viewShiftX = window.getSize().x/2 - window.getView().getCenter().x;
int viewShiftY = window.getSize().y/2 - window.getView().getCenter().y;
int windowMinX = -100 - viewShiftX;
int windowMaxX = windowMinX + window_width + 200;
int windowMinY = -100 - viewShiftY;
int windowMaxY = windowMinY + window_height + 200;
// ------------------------------- Drawing -------------------------------
window.setView(ui.getView());
// Background
sf::Vertex rectangle[] =
{
sf::Vertex(sf::Vector2f(0.0f, 0.0f), sf::Color(0, 100, 130, 255)),
sf::Vertex(sf::Vector2f(window_width, 0.0f), sf::Color(0, 100,130, 255)),
sf::Vertex(sf::Vector2f(window_width, window_height), sf::Color(0, 200, 230, 255)),
sf::Vertex(sf::Vector2f(0.0f, window_height), sf::Color(0, 200, 230, 255))
};
window.draw(rectangle, 4, sf::Quads);
window.setView(windowView);
// World & Player
gameWorld.draw(window, b2Vec2(windowMinX, windowMinY), b2Vec2(windowMaxX, windowMaxY), false);
player.draw(window);
// HUD !!CLASS!!
ui.setSize(window_width, window_height);
window.setView(ui.getView());
if(!gameWorld.completionTimer.timeReached() && gameWorld.completionStarted)
{
sf::Text temp("You have won", font_default, 40);
int midX = window_width / 2.0f - 100;
int midY = window_height / 2.0f - 40;
temp.setPosition(midX, midY);
temp.setColor(sf::Color::White);
window.draw(temp);
}
if(global_isPaused)
{
sf::RectangleShape rect;
rect.setSize(sf::Vector2f(window_width, window_height));
rect.setPosition(0,0);
rect.setFillColor(sf::Color(100, 100, 100, 155));
window.draw(rect);
}
ui.draw(window);
// sf::RectangleShape border;
// border.setPosition(0.0f, window_height - (window_height*minimapSize + MINIMAP_BORDER_SIZE));
// border.setSize(sf::Vector2f(window_width*minimapSize + MINIMAP_BORDER_SIZE, window_height*minimapSize + MINIMAP_BORDER_SIZE));
// border.setFillColor(sf::Color(0, 0, 200, 255));
//
// window.draw(border);
//
// // ------------------------------- Minimap -------------------------------
//
// minimap.setSize(MAX_WORLD_WIDTH * BOX_SIZE, MAX_WORLD_WIDTH * BOX_SIZE, window_width, window_height);
// minimap.calcViewport(minimapSize);
// minimap.setCameraPosition(windowView.getCenter().x, windowView.getCenter().y);
// window.setView(minimap.getUpdatedView());
//
// minimap.update(gameEvents);
//
// minimap.draw(window);
// gameWorld.draw(window, b2Vec2(-10000, -20000), b2Vec2(10000, 10000), true);
// player.draw(window);
// minimap.drawCameraWindow(window);
// Default View again
window.setView(windowView);
}
// Display
window.display();
}
return 0;
}
/**
* function called to hide all controls
* and another widgets
*/
void MediaApp::hideControls() {
showControls(false);
}
// Create the full screen direct draw device for Direct3D to display with.
void BoidsWin::createFSDevice( )
{
// Hide the control panel if it is showing.
if ( showControlPanel == true )
{
showControls( false );
}
// Release the previous surfaces if any.
// The back buffer is attached to the front buffer here.
if ( frontSurface )
{
frontSurface -> Release( );
frontSurface = NULL;
}
if ( zBuffer )
{
zBuffer -> Release( );
zBuffer = NULL;
}
// Create a front surface with a single back buffer.
DDSURFACEDESC surfaceDesc;
memset( &surfaceDesc, 0, sizeof( surfaceDesc ) );
surfaceDesc.dwSize = sizeof( surfaceDesc );
surfaceDesc.dwFlags = DDSD_BACKBUFFERCOUNT | DDSD_CAPS;
surfaceDesc.dwBackBufferCount = 1;
surfaceDesc.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE |
DDSCAPS_3DDEVICE | DDSCAPS_FLIP | DDSCAPS_COMPLEX;
directDraw -> CreateSurface( &surfaceDesc, &frontSurface, 0 );
// Get an interface to the back buffer surface.
DDSCAPS capabilities;
capabilities.dwCaps = DDSCAPS_BACKBUFFER;
frontSurface -> GetAttachedSurface( &capabilities , &backSurface );
// Create a Z buffer surface and attach it to the back surface.
memset( &surfaceDesc, 0, sizeof( surfaceDesc ) );
surfaceDesc.dwSize = sizeof( DDSURFACEDESC );
surfaceDesc.dwFlags = DDSD_WIDTH | DDSD_HEIGHT |
DDSD_CAPS | DDSD_ZBUFFERBITDEPTH;
surfaceDesc.dwWidth = resolutionFS.widthPixels;
surfaceDesc.dwHeight = resolutionFS.heightPixels;
surfaceDesc.dwZBufferBitDepth = FULLSCREEN_ZBUFFER_DEPTH;
surfaceDesc.ddsCaps.dwCaps = DDSCAPS_ZBUFFER | DDSCAPS_SYSTEMMEMORY;
directDraw -> CreateSurface( &surfaceDesc, &zBuffer, 0 );
backSurface -> AddAttachedSurface( zBuffer );
// Create a D3DRM device and attach it to the back surface.
d3drm -> CreateDeviceFromSurface( 0, directDraw, backSurface, &device );
// If the scene is not constructed, set the device to -
// - default render quality and create the scene.
if ( !scene )
{
// Initial render style.
device -> SetQuality( DEFAULT_RENDER_STYLE );
createScene( ); // Set up all the simulation's graphics.
}
else
{
// The scene has already been created, -
// - just reconfigure the device and viewport.
device -> SetQuality( renderStyle ); // Restore the render style.
// Create the viewport.
d3drm -> CreateViewport( device, camera, 0, 0,
device -> GetWidth( ), device -> GetHeight( ), &viewPort );
// Set the range of vision, default is 100.
viewPort -> SetBack( D3DVALUE( VIEWPORT_BACK_DISTANCE ) );
}
}
// Change the display mode back to windowed mode from full screen mode.
void BoidsWin::windowedMode( )
{
// Stop the simulation.
bool alreadyStopped = stopped; // Make note of the start/stop state.
stop( );
// Release the relevant COM interfaces.
if ( directDraw )
{
directDraw -> SetCooperativeLevel( GetSafeHwnd( ), DDSCL_NORMAL );
directDraw -> RestoreDisplayMode( );
directDraw -> Release( );
directDraw = NULL;
frontSurface = NULL;
backSurface = NULL;
zBuffer = NULL;
}
if ( viewPort )
{
viewPort -> Release( );
viewPort = NULL;
}
if ( device )
{
device -> Release( );
device = NULL;
}
if ( clipper )
{
clipper -> Release( );
clipper = NULL;
}
// Reposition the window.
// Check if the structure has been properly filled.
if ( windowedModePos.length != 0 )
{
// If valid use the structure.
SetWindowPlacement( &windowedModePos );
}
// If not a valid structure, reposition the window using default values.
else
{
MoveWindow( CRect( WINDOW_LEFT_POSITION, WINDOW_TOP_POSITION,
WINDOW_RIGHT_POSITION, WINDOW_BOTTOM_POSITION ), true );
}
// Switch to windowed mode.
// Enable the menu and the window's normal features.
CMenu mnu;
(&mnu) -> LoadMenu( "MFCMENU" );
SetMenu( &mnu );
mnu . Detach( );
ModifyStyle( WS_POPUP, WS_OVERLAPPEDWINDOW, SWP_FRAMECHANGED );
ShowCursor( true ); // Show the mouse pointer.
createWinDevice( );
fullScreenMode = false;
// Show the control panel if it should be showing.
if ( showControlPanel )
{
showControls( true );
}
// Repaint the sliders after Direct Draw FS by just giving them the focus.
// This is so because a repaint just won't do the update sufficientley.
sliderNum.SetFocus( );
sliderSize.SetFocus( );
sliderCam.SetFocus( );
sliderCam2.SetFocus( );
// Restore the start/stop state of the simulation.
if ( !alreadyStopped )
{
start( );
}
}
Window::Window(const QStringList& files)
: m_board(0)
{
setAcceptDrops(true);
resize(640, 480);
// Add statusbar
m_slider = new ZoomSlider(this);
statusBar()->addPermanentWidget(m_slider);
m_completed = new QProgressBar(this);
m_completed->setRange(0, 100);
m_completed->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Maximum);
statusBar()->addPermanentWidget(m_completed);
statusBar()->setMinimumHeight(statusBar()->sizeHint().height());
m_slider->hide();
m_completed->hide();
// Add contents
m_board = new Board(this);
connect(m_board, &Board::completionChanged, m_completed, &QProgressBar::setValue);
connect(m_board, &Board::finished, this, &Window::gameFinished);
connect(m_board, &Board::clearMessage, statusBar(), &QStatusBar::clearMessage);
connect(m_board, &Board::showMessage, statusBar(), &QStatusBar::showMessage);
connect(m_board, &Board::zoomChanged, m_slider, &ZoomSlider::setValue);
connect(m_slider, &ZoomSlider::valueChanged, m_board, &Board::zoom);
setCentralWidget(m_board);
// Add menus
QMenu* menu;
menu = menuBar()->addMenu(tr("&Game"));
QAction* choose_action = menu->addAction(tr("&Choose..."), this, SLOT(chooseGame()));
choose_action->setShortcuts(QList<QKeySequence>() << QKeySequence::New << QKeySequence::Open);
menu->addSeparator();
QAction* retrieve_pieces_action = menu->addAction(tr("&Retrieve Pieces"), m_board, SLOT(retrievePieces()), tr("Ctrl+R"));
retrieve_pieces_action->setEnabled(false);
connect(m_board, &Board::retrievePiecesAvailable, retrieve_pieces_action, &QAction::setEnabled);
menu->addSeparator();
QAction* quit_action = menu->addAction(tr("&Quit"), this, SLOT(close()), QKeySequence::Quit);
quit_action->setMenuRole(QAction::QuitRole);
menu = menuBar()->addMenu(tr("&View"));
QAction* zoom_in_action = menu->addAction(tr("Zoom &In"), m_board, SLOT(zoomIn()), tr("+"));
zoom_in_action->setEnabled(false);
connect(m_board, &Board::zoomInAvailable, zoom_in_action, &QAction::setEnabled);
QAction* zoom_out_action = menu->addAction(tr("Zoom &Out"), m_board, SLOT(zoomOut()), tr("-"));
zoom_out_action->setEnabled(false);
connect(m_board, &Board::zoomOutAvailable, zoom_out_action, &QAction::setEnabled);
m_zoom_fit_action = menu->addAction(tr("Best &Fit"), m_board, SLOT(zoomFit()));
m_zoom_fit_action->setEnabled(false);
menu->addSeparator();
m_toggle_overview_action = menu->addAction(tr("Show O&verview"), m_board, SLOT(toggleOverview()), tr("Tab"));
m_toggle_overview_action->setCheckable(true);
m_toggle_overview_action->setEnabled(false);
connect(m_board, &Board::overviewToggled, m_toggle_overview_action, &QAction::setChecked);
menu->addSeparator();
QAction* fullscreen_action = menu->addAction(tr("F&ullscreen"));
connect(fullscreen_action, &QAction::toggled, this, &Window::setFullScreen);
fullscreen_action->setCheckable(true);
#if !defined(Q_OS_MAC)
fullscreen_action->setShortcut(tr("F11"));
#else
fullscreen_action->setShortcut(tr("Ctrl+F"));
#endif
menu = menuBar()->addMenu(tr("&Settings"));
menu->addAction(tr("&Appearance..."), this, SLOT(showAppearance()));
menu->addAction(tr("&Language..."), this, SLOT(setLocale()));
menu = menuBar()->addMenu(tr("&Help"));
menu->addAction(tr("&Controls"), this, SLOT(showControls()), QKeySequence::HelpContents);
menu->addSeparator();
QAction* about_action = menu->addAction(tr("&About"), this, SLOT(showAbout()));
about_action->setMenuRole(QAction::AboutRole);
QAction* about_qt_action = menu->addAction(tr("About &Qt"), qApp, SLOT(aboutQt()));
about_qt_action->setMenuRole(QAction::AboutQtRole);
// Restore geometry
QSettings settings;
if (settings.contains("Geometry")) {
restoreGeometry(settings.value("Geometry").toByteArray());
} else {
resize(settings.value("Size", QSize(1024, 768)).toSize());
settings.remove("Size");
}
// Start or load a game
show();
chooseGame(files);
// Create auto-save timer
QTimer* timer = new QTimer(this);
connect(timer, &QTimer::timeout, m_board, &Board::saveGame);
timer->start(300000);
}