• Status: Solved
  • Priority: Medium
  • Security: Public
  • Views: 2995
  • Last Modified:

Toggle fullscreen / windowed

Hi!

Im working on a small program which only function is to toggle between fullscreen and windowed, no painting no nothing...
I've been looking all over for anything that could give me an hint on whats wrong with it but without success so here comes the complete code!

Hope anyone got some answer!

------------------------------------------------------
I can make a fullscreen window or a windowed one alone but i cant switch between them...
-------------------------------------------------------
//////////////////////////////////////////////////////////////////////////////////////////////////
// Initialize a window with the standard controls //
//////////////////////////////////////////////////////////////////////////////////////////////////

#include <windows.h>
#include <windowsx.h>
#include <stdio.h>

//////////////////////////////////////////////////////////////////////////////////////////////////

#define WIN32_LEAN_AND_MEAN
#define MENU      "Menu"
#define CLASS      "Class"
#define NAME      "Name"
#define KEY_DOWN(vk_code)      ((GetAsyncKeyState(vk_code) & 0x8000) ? 1 : 0)
#define KEY_UP(vk_code)            ((GetAsyncKeyState(vk_code) & 0x8000) ? 0 : 1)

//////////////////////////////////////////////////////////////////////////////////////////////////

bool      Initialize(HINSTANCE hinstance,int ncmdshow);
bool      WinFullscreen(HINSTANCE hinstance,int cmdshow);
bool      WinWindowed(HINSTANCE hinstance,int ncmdshow,DWORD dwWidth,DWORD dwHeight);
bool      LogEnable();
bool      Log(char* szLogText, ...);
bool      Error(HWND hwnd,char szText[]);
void      GameMain(void);

//////////////////////////////////////////////////////////////////////////////////////////////////
HINSTANCE                        hinstance;
HINSTANCE                        g_hinstance;
int                                    ncmdshow;
HWND                              hwnd                  = NULL;
HDC                                    hdc                        = NULL;
DWORD                              StartTime            = NULL;
bool                              bInitializing      = FALSE;
bool                              bFullScreen            = FALSE;

//////////////////////////////////////////////////////////////////////////////////////////////////
// WinMain
// INT
//////////////////////////////////////////////////////////////////////////////////////////////////
int WINAPI WinMain(HINSTANCE hinstance,HINSTANCE hprevinstance,LPSTR lpcmdline,int ncmdshow)
{
      lpcmdline            = lpcmdline;
      hprevinstance      = hprevinstance;
      MSG      msg;

      if(!LogEnable())
      {
            Error(hwnd,"Could not create logfile!");
      }

// Initialize window //
      Log("Initializing window");
      if(!Initialize(hinstance, ncmdshow))
      {
            DestroyWindow(hwnd);
            Log("Initializing->FAILED\n");
            return FALSE;
      }
      else
      {
            Log("Initializing->PASSED\n");
      }
      ShowWindow(hwnd, SW_SHOW);
      g_hinstance = hinstance;

// Enter the main event loop //
      while(1)
      {
            if(PeekMessage(&msg,NULL,0,0,PM_REMOVE))
            {
                  if(msg.message == WM_QUIT)
                        break;
// Translate any accelerator key //
                  TranslateMessage(&msg);
// Send the message to window proc //
                  DispatchMessage(&msg);
            }

// Start timer to lock OR measure the framerate //
            StartTime = GetTickCount();

// The main loop //
            GameMain();

// Lock to 30FPS - 33msec per frame //
            while((GetTickCount() - StartTime) < 33);
      }
// Return to sweet old windows //
      return(msg.wParam);
}


//////////////////////////////////////////////////////////////////////////////////////////////////
// WinProc
// Windows callback function
//////////////////////////////////////////////////////////////////////////////////////////////////
long FAR PASCAL WindowProc(HWND hwnd,UINT message,WPARAM wParam,LPARAM lParam)
{
      HDC                        hdc;
      PAINTSTRUCT            ps;

// Lets take a look at our keyboard //
      switch(message)
      {
      case WM_CREATE:
            return(0);
            break;

      case WM_PAINT:
            hdc = BeginPaint(hwnd,&ps);
            EndPaint(hwnd,&ps);
            break;

      case WM_KEYDOWN:
            switch(wParam)
            {
            case VK_ESCAPE:
                  PostMessage(hwnd,WM_CLOSE,0,0);
                  break;
            }
            break;

            case WM_SYSKEYUP:
                  switch(wParam)
                  {
// Handle ALT + ENTER, Toggle windowed and fullscreen mode //
                  case VK_RETURN:
                        // We are up to something, PAUSE everything else! //
                        bInitializing = TRUE;

                        bFullScreen = !bFullScreen;
                        Log("Change screen mode");
                        // If we have a window, destroy it! //
                        if(hwnd)
                        {
                              DestroyWindow(hwnd);
                        }
                        if(!Initialize(g_hinstance,ncmdshow))
                        {
                              DestroyWindow(hwnd);
                              Log("Init new window->FAILED\n");
                              return FALSE;                              
                        }
                        else
                        {
                              Log("Init new window->PASSED\n");
                              ShowWindow(hwnd, SW_SHOW);
                        }
                        // OK, we are done! //
                        bInitializing = FALSE;
                        break;
                  }
                  break;

      case WM_CLOSE:
            if(MessageBox(hwnd,"Are you sure you want to quit?","Notice",MB_YESNO | MB_ICONQUESTION) == IDNO)
                  return(0);

      case WM_DESTROY:
            if(!bInitializing)
            {
                  PostQuitMessage(0);
                  return(0);
            }
            break;

      default:break;
      }

// All other message //
      return(DefWindowProc(hwnd,message,wParam,lParam));
}


//////////////////////////////////////////////////////////////////////////////////////////////////
// Initialize()
// This function creates either a fullscreen or a window
// BOOL
//////////////////////////////////////////////////////////////////////////////////////////////////
bool Initialize(HINSTANCE hinstance, int ncmdshow)
{
      if(bFullScreen)
// Create a fullscreen window if thats what we want //
      {
            
            if(!WinFullscreen(hinstance,ncmdshow))
            {
                  Log("  Set to FULLSCREEN->FAILED");
                  return FALSE;
            }
            else
            {
                  Log("  Set to FULLSCREEN->PASSED");
            }
      }
      else
// Else create a window //
      {
            if(!WinWindowed(hinstance,ncmdshow,100,100))
            {
                  Log("  Set to WINDOWED->FAILED");
                  return FALSE;
            }
            else
            {
                  Log("  Set to WINDOWED->PASSED");
            }
      }
/*
// Start up initializing //
      if(!InitStart())
      {
            Log("InitStart->FAILED");
            return FALSE;
      }
      else
      {
            Log("InitStart->PASSED");
      }
*/
      return TRUE;
}

//////////////////////////////////////////////////////////////////////////////////////////////////
// Init Window FULLSCREEN
// BOOL
//////////////////////////////////////////////////////////////////////////////////////////////////
bool WinFullscreen(HINSTANCE hinstance, int ncmdshow)
{
      WNDCLASSEX            winclass;      // Holds the windows class info //

// Fill in the windows class info structure //
      winclass.cbSize                  = sizeof(WNDCLASSEX);
      winclass.style                  = CS_HREDRAW | CS_VREDRAW;
      winclass.lpfnWndProc      = WindowProc;
      winclass.cbClsExtra            = 0;
      winclass.cbWndExtra            = 0;
      winclass.hInstance            = hinstance;
      winclass.hIcon                  = LoadIcon(NULL, IDI_WINLOGO);
      winclass.hIconSm            = LoadIcon(NULL, IDI_WINLOGO);
      winclass.hCursor            = LoadCursor(NULL, IDC_ARROW);
      winclass.hbrBackground      = (HBRUSH)GetStockObject(GRAY_BRUSH);
      winclass.lpszMenuName      = MENU;
      winclass.lpszClassName      = CLASS;

// Register the windows class //
      if(!RegisterClassEx(&winclass))
      {
            Log("  Register windows class:FULLSCREEN->FAILED");
            return FALSE;
      }

// Create the fullscreen window //
      hwnd = CreateWindowEx(
                  WS_EX_TOPMOST,
                  CLASS,                                                // The class name //
                  NAME,                                                // The title //
                  WS_POPUP,
                  0,0,                                                // x, y //
                  GetSystemMetrics(SM_CXSCREEN),            // For Fullscreen: GetSystemMetrics(SM_CXSCREEN)
                  GetSystemMetrics(SM_CYSCREEN),            // For Fullscreen: GetSystemMetrics(SM_CYSCREEN)
                  NULL,                                                // Parent //
                  NULL,                                                // Menu //
                  hinstance,
                  NULL);

      if(!hwnd)
      {
            Log("  Create window:FULLSCREEN->FAILED");
            return FALSE;
      }

      return TRUE;
}


//////////////////////////////////////////////////////////////////////////////////////////////////
// Init Window WINDOWED
// BOOL
//////////////////////////////////////////////////////////////////////////////////////////////////
bool WinWindowed(HINSTANCE hinstance,int ncmdshow,DWORD dwWidth,DWORD dwHeight)
{
      WNDCLASSEX            winclass;      // Holds the windows class info //
      RECT                  rcWindow;      // Rectangle //

// Fill in the windows class info structure //
      winclass.cbSize                  = sizeof(WNDCLASSEX);
      winclass.style                  = CS_HREDRAW | CS_VREDRAW;
      winclass.lpfnWndProc      = WindowProc;
      winclass.cbClsExtra            = 0;
      winclass.cbWndExtra            = 0;
      winclass.hInstance            = hinstance;
      winclass.hIcon                  = LoadIcon(NULL, IDI_WINLOGO);
      winclass.hIconSm            = LoadIcon(NULL, IDI_WINLOGO);
      winclass.hCursor            = LoadCursor(NULL, IDC_ARROW);
      winclass.hbrBackground      = (HBRUSH)GetStockObject(GRAY_BRUSH);
      winclass.lpszMenuName      = MENU;
      winclass.lpszClassName      = CLASS;

// Register the windows class //
      if(!RegisterClassEx(&winclass))
      {
            Log("  Register windows class:WINDOWED->FAILED");
            return FALSE;
      }

// Create a window //
      hwnd = CreateWindowEx(
                  WS_EX_TOPMOST,//NULL,
                  CLASS,                                                            // The class name //
                  NAME,                                                            // The title //
                  WS_VISIBLE | WS_SYSMENU | WS_CAPTION | WS_MINIMIZEBOX | WS_MAXIMIZEBOX,
                  CW_USEDEFAULT,
                  SW_SHOW,
                  0,
                  0,
                  NULL,                                                            // Parent //
                  NULL,                                                            // Menu //
                  hinstance,
                  NULL);

      if(!hwnd)
      {
            Log("  Create window:WINDOWED->FAILED");
            return FALSE;
      }

// Set desired size for the client area of the window //
      SetRect(&rcWindow,0,0,dwWidth,dwHeight);

// Adjust the size so the borders etc. will fit //
      AdjustWindowRectEx(&rcWindow,
                                 GetWindowStyle(hwnd),      // Style of our main window //
                                 GetMenu(hwnd) != NULL,      // Does our window have a menu? //
                                 GetWindowExStyle(hwnd));      // Extended style of our window //

// Adjust the window to the new size //
      MoveWindow(hwnd,CW_USEDEFAULT,CW_USEDEFAULT,
                              rcWindow.right  - rcWindow.left,
                              rcWindow.bottom - rcWindow.top,
                              TRUE);
      
      return TRUE;
}


//////////////////////////////////////////////////////////////////////////////////////////////////
// GameMain
//////////////////////////////////////////////////////////////////////////////////////////////////
void GameMain(void)
{
}

------------------------------------------------------
LogFunction!
------------------------------------------------------
//////////////////////////////////////////////////////////////////////////////////////////////////
// This function is used to create a log file during setup or wherever needed!
//////////////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////////////
#include <stdarg.h>
#include <stdio.h>
#include <windows.h>
#include <windowsx.h>

//////////////////////////////////////////////////////////////////////////////////////////////////

bool      bLogEnabled;

//////////////////////////////////////////////////////////////////////////////////////////////////

bool Log(char* szLogText, ...)
{
// Take a look if logging is enabled //
      if(bLogEnabled)
      {
            FILE*      pFile;
            va_list pArg;

// Variable arguments lists "start" macro //
            va_start(pArg,szLogText);

// Open file and append to it //
            if((pFile = fopen("log.txt", "a"))  == NULL)
                  return FALSE;

// Write the text and add a newline //
            vfprintf(pFile, szLogText, pArg);
            putc('\n', pFile);

// Close the file //
            fclose(pFile);
      }
      return TRUE;
}

//////////////////////////////////////////////////////////////////////////////////////////////////
// Enables Log
//////////////////////////////////////////////////////////////////////////////////////////////////
bool LogEnable()
{

// EnableLog //
      bLogEnabled = TRUE;
      FILE*      pFile;

      if((pFile = fopen("log.txt", "wb")) == NULL)
            return FALSE;

// Close the file //
      fclose(pFile);
      return TRUE;
}
------------------------------------------------------
Utils
------------------------------------------------------
//////////////////////////////////////////////////////////////////////////////////////////////////
// This file contains small utils like error handling etc.
//////////////////////////////////////////////////////////////////////////////////////////////////
#include <windows.h>
#include <windowsx.h>

//////////////////////////////////////////////////////////////////////////////////////////////////
// Most imported: ERROR function
//////////////////////////////////////////////////////////////////////////////////////////////////
bool Error(HWND hwnd, char szText[])
{
      MessageBox(hwnd, szText, "System error!", MB_OK | MB_DEFBUTTON1 | MB_ICONEXCLAMATION);
      DestroyWindow(hwnd);
      return FALSE;
}


------------------------------------------------------
Sorry i had to post it all, but i couldnt find any help elsewhere!

-Robert-
0
Warichew
Asked:
Warichew
  • 3
1 Solution
 
nietodCommented:
There are no "full screen features" built into windows.  If you want a window to be the size of the full screen you just move and size it so it fills the whole screen.   You can get the dimensions of the screen in a variety of ways, but I think for your case you don't realy want the size of the screen.  What I suspect you reall you want is the size and location of the "work area" which is the portionof the screen that is not obscured byt he task bar.   To get that you use SystemParametersInfo() with an index of SPI_GETWORKAREA.   Then move the window to the desired size and location.  There are several ways to move a window, but the easiest is probably MoveWindow().
0
 
nietodCommented:
Like

RECT WrkRec;
SystemParemetersInfo(SPI_GETWORKAREA,0,&WrkRec,0);
MoveWindow(WndHnd,WrkRec.Left,WrkRec.Top,WrkRec.Right - WrkRec.Left,WrhRec.Bottom-WrkRec.Top,TRUE);
0
 
WarichewAuthor Commented:
Hmm, couldnt get it to work, its the same problem...

RegisterClassEx(&winclass)->FAILED

Strange...

Compile it and test, check the log file afterwards.
0
 
nietodCommented:
>> RegisterClassEx(&winclass)->FAILED
Whjat does that have to do with the problem?  My answer has nothing to do with registerign a class and it woudl have to be performed AFTER you register the class. so it would have no effect on this

Did you debug the code to see why RegisterClass failed?   You coudl try calling GetLastError.  the most likely causes are that you are using invalid handles, like for menus, icons etc, that you ae specifying names for resources that don't exist, or that you are registering a class name that is already used.
0
 
MoondancerCommented:
I am sorry to see that Asker has not returned to update and finalize this question.  I am, therefore, force accepting this question.  In the event the Asker returns with additional needs related to this question, please respond and continue the collaboration process.
Thank you,
Moondancer
Community Support Moderator @ Experts Exchange
0

Featured Post

Free Tool: Path Explorer

An intuitive utility to help find the CSS path to UI elements on a webpage. These paths are used frequently in a variety of front-end development and QA automation tasks.

One of a set of tools we're offering as a way of saying thank you for being a part of the community.

  • 3
Tackle projects and never again get stuck behind a technical roadblock.
Join Now