C++ createWindow函数代码示例

void
CMSWindowsServerTaskBarReceiver::showStatus()
{
	// create the window
	createWindow();

	// lock self while getting status
	lock();

	// get the current status
	std::string status = getToolTip();

	// get the connect clients, if any
	const CClients& clients = getClients();

	// done getting status
	unlock();

	// update dialog
	HWND child = GetDlgItem(m_window, IDC_TASKBAR_STATUS_STATUS);
	SendMessage(child, WM_SETTEXT, 0, (LPARAM)status.c_str());
	child = GetDlgItem(m_window, IDC_TASKBAR_STATUS_CLIENTS);
	SendMessage(child, LB_RESETCONTENT, 0, 0);
	for (CClients::const_iterator index = clients.begin();
							index != clients.end(); ) {
		const char* client = index->c_str();
		if (++index == clients.end()) {
			SendMessage(child, LB_ADDSTRING, 0, (LPARAM)client);
		}
		else {
			SendMessage(child, LB_INSERTSTRING, (WPARAM)-1, (LPARAM)client);
		}
	}

	if (!IsWindowVisible(m_window)) {
		// position it by the mouse
		POINT cursorPos;
		GetCursorPos(&cursorPos);
		RECT windowRect;
		GetWindowRect(m_window, &windowRect);
		int  x = cursorPos.x;
		int  y = cursorPos.y;
		int fw = GetSystemMetrics(SM_CXDLGFRAME);
		int fh = GetSystemMetrics(SM_CYDLGFRAME);
		int ww = windowRect.right  - windowRect.left;
		int wh = windowRect.bottom - windowRect.top;
		int sw = GetSystemMetrics(SM_CXFULLSCREEN);
		int sh = GetSystemMetrics(SM_CYFULLSCREEN);
		if (fw < 1) {
			fw = 1;
		}
		if (fh < 1) {
			fh = 1;
		}
		if (x + ww - fw > sw) {
			x -= ww - fw;
		}
		else {
			x -= fw;
		}
		if (x < 0) {
			x = 0;
		}
		if (y + wh - fh > sh) {
			y -= wh - fh;
		}
		else {
			y -= fh;
		}
		if (y < 0) {
			y = 0;
		}
		SetWindowPos(m_window, HWND_TOPMOST, x, y, ww, wh,
							SWP_SHOWWINDOW);
	}
}

int main(int argc, char *argv[])
{
	if(argc >= 2)
	{
		if(strcmp(argv[1],"-h") == 0 || strcmp(argv[1],"--help") == 0)
		{
			printf("\nConway\n");
			printf("Copyright 2015 Harley Wiltzer\n\n");
			printf("conway:\t\tOpen conway with a random color\n");
			printf("conway 1:\tOpen conway blue theme\n");
			printf("conway 2:\tOpen conway red theme\n");
			printf("conway 3:\tOpen conway green theme\n");
			printf("conway 4:\tOpen conway yellow theme\n");
			printf("conway 5:\tOpen conway light blue theme\n");
			printf("conway 6:\tOpen conway orange theme\n");
			printf("conway 7:\tOpen conway white theme\n");
			printf("\n");
			printf("While running conway...\n");
			printf("=======================\n");
			printf("q:\t\tClose conway\n");
			printf("space:\t\tActivate/Kill cell\n");
			printf("enter:\t\tStart ticking\n");
			printf("h:\t\tMove cursor left\n");
			printf("j:\t\tMove cursor down\n");
			printf("k:\t\tMove cursor up\n");
			printf("l:\t\tMove cursor right\n");
			printf("d:\t\tClear all cells\n");
			printf("=:\t\tIncrease the amount of ticks by 10\n");
			printf("-:\t\tDecrease the amount of ticks by 10\n");
			printf("+:\t\tIncrease the amount of ticks by 1\n");
			printf("_:\t\tDecrease the amount of ticks by 1\n");
			return 0;
		}
	}
	int i, c;
	
	initCurses();
	showSplash();
	totalTicks = 0;	
	refresh();
	getch();

	win = createWindow(WIN_WIDTH,rows,0,cols - WIN_WIDTH - 1);
	cols = cols - WIN_WIDTH - 1;
	xs = rows;
	ys = cols / 2;
	area = rows * cols;
	game = createWindow(cols - 1,rows,0,0);
	ticks = DEFAULT_TICKS;
	
	int cells[area / 2];
	for(i = 0; i < area/2; i++)
	{
		cells[i] = 0;
	}

	x = y = row = col = 0;
	if(has_colors() == 0) wprintw(game,"NO COLORS\n");

	if(argc < 2)
	{
		srand(time(NULL));
		color = rand()%7 + 1;
	}
	else
	{
		if(atoi(argv[1]) > 7 || atoi(argv[1]) < 1)
		{
			srand(time(NULL));
			color = rand()%7 + 1;
		}
		else 
		{
			color = atoi(argv[1]);
		}
	}

	x = ys/2;
	y = xs/2;
	wmove(game,y, x * 2);
	x = 2;
	y = 2;
	wrefresh(game);
	updateWin(cells,area/2);
	wmove(game,y,x * 2);

	x = ys/2;
	y = xs/2;

	wmove(game,y,x * 2);

	while((ch = getch()) != 'q')
	{
		wclear(game);
		wclear(win);
		int r, c;
		
		render(cells,area/2);	
		wmove(game,y, x * 2);

//.........这里部分代码省略.........

myGazeHaptic::myGazeHaptic(QWidget *parent)
	: QMainWindow(parent)
{
	ui.setupUi(this);
	createWindow();
}

/*
=====================
	initSystem
=====================
*/
BOOL initSystem() {

	//get game directory path (Ex: D:\Games\Netrix)
	//
	GetCurrentDirectory( MAX_PATH, k_system.szStartDir );

	N_InitTrace();

	//init Win32 system
	//
	initWin32();

	//System
	//
	k_system.pLeftGame	= NULL;
	k_system.pRightGame	= NULL;
	k_system.gameType	= GNO;
	k_system.pause		= FALSE;
	k_system.flags		= 0;
	k_system.dwAccumTime	= 0;
	k_system.dwTime		= 0;
	
	//Maps
	//
	k_system.cMaps	= 0;
	k_system.pMaps	= NULL;
	k_system.idMap	= -1;
	
	//Bots
	//
	k_system.cBots	= 0;
	k_system.pBots	= NULL;
	k_system.idBotLeft	= -1;
	k_system.idBotRight	= -1;
	
	//Paths
	//
	k_system.pPaths	= NULL;
	k_system.cPaths	= 0;
	
	//HWND
	//
	k_system.hwnd		= NULL;
	k_system.hwndLeft	= NULL;
	k_system.hwndRight	= NULL;
	
	k_system.cPlayers	= 0;

	initRandom();

	cfInitTable();

	//resources
	//
	loadResources();
	
	//init bot system
	//
	botInit();

	//Skins
	//
	loadSkin( &k_system.hSkinRgnLeft, &k_system.hSkinBitmapLeft,
		&k_system.cxSkinLeft, &k_system.cySkinLeft, IDR_SKIN_LEFT );

	loadSkin( &k_system.hSkinRgnRight, &k_system.hSkinBitmapRight,
		&k_system.cxSkinRight, &k_system.cySkinRight, IDR_SKIN_RIGHT );

	createWindow();
	
	//GUI
	//
	populateGUI();

	if( !initGraphics( NEUTRAL ) )
		return FALSE;

	if( !initGraphics( LEFTGAME ) )
		return FALSE;

	updateWindow( CGF_DRAWLEFT );
	
	//winmm
	timeBeginPeriod( 1 );
	
	return TRUE;
}

Window::Window(const ConstructionData &ctorData) :
		_windowHandle(createWindow(ctorData, this)),
		_surface(_windowHandle.get()),
		_inputSource(_windowHandle.get())
{
}

bool CDDApplication::createMainWindow()
{
	// Create a main game window
	return createWindow("DiabloDream");
}

BOOL winapiwrapper::createWindow()
{

	return(createWindow("mywrapperdefclass",0,0,800,600));

}

int main(int, char**)
{
	// Timing
	unsigned int lastUpdate;
	unsigned int thisUpdate;
	unsigned int dt = 0;

	// FPS
	int frames = 0;
	int fps = 0;
	int lastFPSUpdate;

	// Pixel buffer
	PixelBuffer pixelBuffer(width, height);

	// SDL structures
	SDL_Event event;
	SDL_Window* window;
	SDL_Renderer* renderer;
	SDL_Texture* renderTexture;

	// Seed random number generator
	srand((unsigned int)time(0));

	// Initialise SDL
	SDL_Init(SDL_INIT_EVERYTHING);

	// Initilialise timing
	lastUpdate = thisUpdate = SDL_GetTicks();
	lastFPSUpdate = lastUpdate;

	// Create window
	window = createWindow(TITLE_FORMAT, width, height);

	// Create renderer
	renderer = createRenderer(window);

	// Create render texture
	renderTexture = createTexture(renderer, width, height);

	// Set window values
    //int width  = INITIAL_WIDTH;
    //int height = INITIAL_HEIGHT;

	// Create and initialise managers
	BallManager ballManager(width, height);

	// Create some balls
	ballManager.createBalls(INITIAL_BALLS);

	// Start main loop
	bool running = true;
	bool rendering_enabled = true;
    bool movement_enabled  = true;

	while (running)
	{
		const SDL_Rect screenRect = {0, 0, width, height};

		// Update timer
		thisUpdate = SDL_GetTicks();
		dt = thisUpdate - lastUpdate;

		// Handle all events
		while (SDL_PollEvent(&event))
		{
			// End when the user closes the window or presses esc
			if (event.type == SDL_QUIT ||
				(event.type == SDL_KEYDOWN && event.key.keysym.scancode == SDL_SCANCODE_ESCAPE))
			{
				running = false;
			}

			// Handle keyboard input
			if (event.type == SDL_KEYDOWN)
			{
				// Toggle rendering when player presses R
				if (event.key.keysym.sym == SDLK_r)
				{
					// Disable rendering
					rendering_enabled = !rendering_enabled;

					// Clear screen to white
                    pixelBuffer.clear(0xFFFFFFFF);

					// Update render texture
					SDL_UpdateTexture(renderTexture, &screenRect, pixelBuffer.getBuffer(), width * 4);

					// Render texture to screen
					SDL_RenderCopy(renderer, renderTexture, &screenRect, &screenRect);

					// Flip screen buffer
					SDL_RenderPresent(renderer);
				}
				// Toggle movement when player presses M
				else if (event.key.keysym.sym == SDLK_m)
				{
                    movement_enabled = !movement_enabled;
				}
				// Add 10 balls when user presses right arrow
//.........这里部分代码省略.........

JSValue JSDOMWindow::showModalDialog(ExecState* exec)
{
    String url = valueToStringWithUndefinedOrNullCheck(exec, exec->argument(0));
    JSValue dialogArgs = exec->argument(1);
    String featureArgs = valueToStringWithUndefinedOrNullCheck(exec, exec->argument(2));

    Frame* frame = impl()->frame();
    if (!frame)
        return jsUndefined();
    Frame* lexicalFrame = toLexicalFrame(exec);
    if (!lexicalFrame)
        return jsUndefined();
    Frame* dynamicFrame = toDynamicFrame(exec);
    if (!dynamicFrame)
        return jsUndefined();

    if (!DOMWindow::canShowModalDialogNow(frame) || !domWindowAllowPopUp(dynamicFrame))
        return jsUndefined();

    HashMap<String, String> features;
    DOMWindow::parseModalDialogFeatures(featureArgs, features);

    const bool trusted = false;

    // The following features from Microsoft's documentation are not implemented:
    // - default font settings
    // - width, height, left, and top specified in units other than "px"
    // - edge (sunken or raised, default is raised)
    // - dialogHide: trusted && boolFeature(features, "dialoghide"), makes dialog hide when you print
    // - help: boolFeature(features, "help", true), makes help icon appear in dialog (what does it do on Windows?)
    // - unadorned: trusted && boolFeature(features, "unadorned");

    FloatRect screenRect = screenAvailableRect(frame->view());

    WindowFeatures wargs;
    wargs.width = WindowFeatures::floatFeature(features, "dialogwidth", 100, screenRect.width(), 620); // default here came from frame size of dialog in MacIE
    wargs.widthSet = true;
    wargs.height = WindowFeatures::floatFeature(features, "dialogheight", 100, screenRect.height(), 450); // default here came from frame size of dialog in MacIE
    wargs.heightSet = true;

    wargs.x = WindowFeatures::floatFeature(features, "dialogleft", screenRect.x(), screenRect.right() - wargs.width, -1);
    wargs.xSet = wargs.x > 0;
    wargs.y = WindowFeatures::floatFeature(features, "dialogtop", screenRect.y(), screenRect.bottom() - wargs.height, -1);
    wargs.ySet = wargs.y > 0;

    if (WindowFeatures::boolFeature(features, "center", true)) {
        if (!wargs.xSet) {
            wargs.x = screenRect.x() + (screenRect.width() - wargs.width) / 2;
            wargs.xSet = true;
        }
        if (!wargs.ySet) {
            wargs.y = screenRect.y() + (screenRect.height() - wargs.height) / 2;
            wargs.ySet = true;
        }
    }

    wargs.dialog = true;
    wargs.resizable = WindowFeatures::boolFeature(features, "resizable");
    wargs.scrollbarsVisible = WindowFeatures::boolFeature(features, "scroll", true);
    wargs.statusBarVisible = WindowFeatures::boolFeature(features, "status", !trusted);
    wargs.menuBarVisible = false;
    wargs.toolBarVisible = false;
    wargs.locationBarVisible = false;
    wargs.fullscreen = false;

    Frame* dialogFrame = createWindow(exec, lexicalFrame, dynamicFrame, frame, url, "", wargs, dialogArgs);
    if (!dialogFrame)
        return jsUndefined();

    JSDOMWindow* dialogWindow = toJSDOMWindow(dialogFrame, currentWorld(exec));
    dialogFrame->page()->chrome()->runModal();

    Identifier returnValue(exec, "returnValue");
    if (dialogWindow->allowsAccessFromNoErrorMessage(exec)) {
        PropertySlot slot;
        // This is safe, we have already performed the origin security check and we are
        // not interested in any of the DOM properties of the window.
        if (dialogWindow->JSGlobalObject::getOwnPropertySlot(exec, returnValue, slot))
            return slot.getValue(exec, returnValue);
    }
    return jsUndefined();
}

//-----------------------------------------------------------------------------
// Description: Function to enable multisampling AA.
// Parameters:
// Returns:
// Notes: 
//-----------------------------------------------------------------------------
void FWWin32GLWindow::enableAA()
{
	if(mAAPixelFormat)
		return;

	// try to get extension
	PFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARB = 
		(PFNWGLCHOOSEPIXELFORMATARBPROC)wglGetProcAddress("wglChoosePixelFormatARB");

	// just return if not available
	if(!wglChoosePixelFormatARB)
		return;

	int				iPixelFormat;
	BOOL			bValid;
	unsigned int	iNumFormats;

	float			fAttributes[] =
	{
		0.f,
		0.f,
	};

	int iAttributes[] =
	{
		WGL_DRAW_TO_WINDOW_ARB,	GL_TRUE,
		WGL_SUPPORT_OPENGL_ARB,	GL_TRUE,
		WGL_ACCELERATION_ARB,	WGL_FULL_ACCELERATION_ARB,
		WGL_COLOR_BITS_ARB,		mDispInfo.mColorBits,
		WGL_ALPHA_BITS_ARB,		mDispInfo.mAlphaBits, 
		WGL_DEPTH_BITS_ARB,		mDispInfo.mDepthBits,
		WGL_STENCIL_BITS_ARB,	mDispInfo.mStencilBits,
		WGL_DOUBLE_BUFFER_ARB,	GL_TRUE,
		WGL_SAMPLE_BUFFERS_ARB,	GL_TRUE,
		WGL_SAMPLES_ARB,		4,
		0,						0,
	};

	// see if 4x multisampling is supported
	bValid = wglChoosePixelFormatARB(mHDc, iAttributes, fAttributes, 1, &iPixelFormat, &iNumFormats);

	if(bValid && iNumFormats >= 1)
	{
		// we got a valid format, so delete the current ogl context and recreate it

		mDontQuit = true;
		destroyWindow();
		mAAPixelFormat = iPixelFormat;
		createWindow();
		mDontQuit = false;
		return;
	}

	// see if 2x multisampling is supported
	iAttributes[19] = 2;
	bValid = wglChoosePixelFormatARB(mHDc, iAttributes, fAttributes, 1, &iPixelFormat, &iNumFormats);

	if(bValid && iNumFormats >= 1)
	{
		// we got a valid format, so delete the current ogl context and recreate it

		mDontQuit = true;
		destroyWindow();
		mAAPixelFormat = iPixelFormat;
		createWindow();
		mDontQuit = false;
		return;
	}

	// couldn't create AA buffer
	mDispInfo.mAntiAlias = false;
}

Renderer::Renderer() : videoInit_(false), window_(nullptr), context_(nullptr)
#ifdef OCULUSVR
    , hmd_(nullptr), renderTex_(0), depthTex_(0), framebuffer_(0)
#endif
{
    if(SDL_InitSubSystem(SDL_INIT_VIDEO) < 0)
    {
        throwSDLError();
    }

    videoInit_ = true;

#ifdef __APPLE__
    // Apple's drivers don't support the compatibility profile on GL >v2.1
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
#endif
    // 32 crashes mysteriously on my laptop
    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);

    Config& config = Core::get().config();

    int multisamples = config.getInt("Renderer.multisamples", 16);

    if(multisamples != 0)
    {
        // Enable MSAA
        SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
        SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, multisamples);
    }

    createWindow();

    context_ = SDL_GL_CreateContext(window_);

    if(context_ == nullptr)
    {
        throwSDLError();
    }

#ifdef _MSC_VER
    GLenum glewErr = glewInit();

    if(glewErr != GLEW_OK)
    {
        string err("Unable to initialize GLEW: ");
        err.append((const char*)glewGetErrorString(glewErr));
        throw runtime_error(err);
    }
#endif

    fieldOfView_ = config.getFloat("Renderer.fieldOfView", 90.0);

    string textureFiltering = config.getString("Renderer.textureFiltering", "trilinear");

    if(textureFiltering == "bilinear")
    {
        textureMinFilter_ = GL_LINEAR_MIPMAP_NEAREST;
    }
    else if(textureFiltering == "trilinear")
    {
        textureMinFilter_ = GL_LINEAR_MIPMAP_LINEAR;
    }
    else
    {
        throw runtime_error("Bad value for Renderer.textureFiltering");
    }

    textureMaxAnisotropy_ = static_cast<GLfloat>(config.getFloat("Renderer.anisotropyLevel", 0.0));

    if(textureMaxAnisotropy_ != 0.0f)
    {
#ifdef _MSC_VER
        if(!GLEW_EXT_texture_filter_anisotropic)
        {
            throw runtime_error("Anisotropic filtering not supported");
        }
#endif

        GLfloat driverMaxAnisotropy;
        glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &driverMaxAnisotropy);

        if(textureMaxAnisotropy_ < 0.0f || textureMaxAnisotropy_ > driverMaxAnisotropy)
        {
            throw runtime_error("Bad value for Renderer.maxAnisotropyLevel");
        }
    }

    renderHitGeometry_ = config.getBool("Renderer.renderHitGeometry", false);
}

EGLView::EGLView()
{
	createWindow();
	initEgl();
}

void Tutorial::initGlut()
{
  switch (_tutorialID) {
  case 1:
  case 2:
  case 3:
    _pGameCamera = nullptr;
  case 4:
  case 5:
  case 6:
  case 7:
  case 8:
  case 9:
  case 10:
  case 11:
  case 12:
  case 13:
  case 14:
    setWindowSize(WINDOW_WIDTH_1_14, WINDOW_HEIGHT_1_14);
    _pGameCamera = new Camera(WINDOW_WIDTH_1_14, WINDOW_HEIGHT_1_14);
    break;
  case 15:
    setWindowSize(WINDOW_WIDTH_15_17, WINDOW_HEIGHT_15_17);
    _pGameCamera = new Camera(WINDOW_WIDTH_15_17, WINDOW_HEIGHT_15_17);
    break;
  case 16:
    setWindowSize(WINDOW_WIDTH_16, WINDOW_HEIGHT_16);
    _pGameCamera = new Camera(WINDOW_WIDTH_16, WINDOW_HEIGHT_16);
    break;
  case 17:
  case 18:
  case 19:
  case 20:
  case 21:
  case 22:
  case 23:
    return;

  default:
    setWindowSize(WINDOW_WIDTH_1_14, WINDOW_HEIGHT_1_14);
    _pGameCamera = new Camera(WINDOW_WIDTH_1_14, WINDOW_HEIGHT_1_14);
    break;
  }

  setWindowLocation();
  createWindow(_tutorialID);


  glutDisplayFunc(renderFunction);
  glutIdleFunc(idleFunction);
  glutSpecialFunc(specialKeyboardCB);
  glutKeyboardFunc(keyboardCB);
  glutPassiveMotionFunc(passiveMouseCB);

  if (_tutorialID == 15 || _tutorialID == 17) {
    glutGameModeString("[email protected]");
    glutEnterGameMode();
  }
  else if (_tutorialID == 16) {
    glutGameModeString("[email protected]");
  }
}

bool Window_Win32::createWindow( const std::string &titlewstring )
{
 	return createWindow( m_windowPosX, m_windowPosY, m_windowWidth, m_windowHeight, titlewstring );
}

 void createRenderingTarget() {
   createWindow(glm::uvec2(1280, 800), glm::ivec2(100, 100));
 }