自学教程：C++ CreateContext函数代码示例

bool AndroidEGL::InitContexts(){	bool Result = true; 	PImplData->SharedContext.eglContext = CreateContext();		PImplData->RenderingContext.eglContext = CreateContext(PImplData->SharedContext.eglContext);		PImplData->SingleThreadedContext.eglContext = CreateContext();	return Result;}

/*** Creates a ThreadBlock structure from @func, and its @argument.* @stacksize is passed to CreateContext call.**/static ThreadBlock * CreateThread(void (*func) (void *),void * argument,long stackSize) {  ucontext_t * linkedContext = CreateContext(ExitRunningThread,NULL,stackSize,0,NULL);  ucontext_t * threadContext = CreateContext((void (*) (void))func,linkedContext,stackSize,1,argument);  ThreadBlock * threadBlock = (ThreadBlock *) malloc(sizeof(ThreadBlock));  threadBlock->context = threadContext;  threadBlock->status = STATUS_READY;  threadBlock->numberOfChildren = 0;  threadBlock->previous = threadBlock->next = threadBlock->parent = NULL;  threadBlock->id = uThreadContext->currentID++;  return threadBlock;}

bool ConnectToSelf(){    char host[MAX_HOST_LENGTH];    DWORD length = MAX_HOST_LENGTH;    MPD_Context *pRightContext, *pLeftContext;    host[0] = '/0';    GetComputerName(host, &length);    // Initialize the new contexts    pRightContext = CreateContext();    if (pRightContext == NULL)	return false;    strncpy(pRightContext->pszHost, host, MAX_HOST_LENGTH);    pRightContext->nCurPos = 0;    pRightContext->nState = MPD_IDLE;    pRightContext->nLLState = MPD_READING_CMD;    pRightContext->nType = MPD_RIGHT_SOCKET;    pLeftContext = CreateContext();    if (pLeftContext == NULL)    {	RemoveContext(pRightContext);	return false;    }    strncpy(pLeftContext->pszHost, host, MAX_HOST_LENGTH);    pLeftContext->nCurPos = 0;    pLeftContext->nState = MPD_IDLE;    pLeftContext->nLLState = MPD_READING_CMD;    pLeftContext->nType = MPD_LEFT_SOCKET;    MakeLoopAsync(&pLeftContext->sock, &pRightContext->sock);    if (pLeftContext->sock == INVALID_SOCKET || pRightContext->sock == INVALID_SOCKET)    {	RemoveContext(pLeftContext);	RemoveContext(pRightContext);	return false;    }    // overwrite the old left and right contexts    g_pRightContext = pRightContext;    g_pLeftContext = pLeftContext;    strncpy(g_pszRightHost, host, MAX_HOST_LENGTH);    strncpy(g_pszLeftHost, host, MAX_HOST_LENGTH);    //dbg_printf("ConnectToSelf succeeded/n");    return true;}

int main(int argc, const char *argv[]){    KonohaContext* kctx = CreateContext();    int i;    void *malloced[100];    for (i = 0; i < 100; ++i) {        malloced[i] = PLATAPI GCModule.Kmalloc(0, i, NULL);    }    for (i = 0; i < 100; ++i) {        PLATAPI GCModule.Kfree(0, malloced[i], i);    }    for (i = 0; i < 100; ++i) {        malloced[i] = PLATAPI GCModule.Kzmalloc(0, i, NULL);        int j;        char *p = (char *)malloced[i];        for (j = 0; j < i; ++j) {            assert(p[0] == 0);        }    }    for (i = 0; i < 100; ++i) {        PLATAPI GCModule.Kfree(0, malloced[i], i);    }    DeleteContext(kctx);    return 0;}

HWND OGLWindow::InitInstance(HINSTANCE hInstance, HWND hParent, bool doubleBuf, int x, int y, int w, int h){	// Create the main Window.	m_hWnd = CreateWindow( 		m_ClassName,        // name of Window class 		m_WindowTitle,       // title-bar string 		WS_BORDER | WS_CHILD/* | WS_CLIPSIBLINGS | WS_CLIPCHILDREN*/, //  		0,       // default horizontal position 		0,       // default vertical position 		1,       // default width 		1,       // default height 		hParent,         // no owner Window 		(HMENU) NULL,        // use class menu 		hInstance,           // handle to application instance 		(LPVOID) NULL);      // no Window-creation data 	if ( !CreateContext() )	{		DestroyWindow(m_hWnd);		m_hWnd = NULL;	}	m_width = w;	m_height = h;	MoveWindow(m_hWnd, x, y, w, h, FALSE);	ShowWindow(m_hWnd, SW_HIDE); 	BOOL makeCurResult = wglMakeCurrent( m_hDC, m_Context );	return m_hWnd; }

void wxGISDisplay::PanningDraw(wxCoord x, wxCoord y, wxDC* pDC){	wxCriticalSectionLocker locker(m_CritSect);	cairo_set_source_rgb(m_cr_tmp, m_BackGroudnColour.GetRed(), m_BackGroudnColour.GetGreen(), m_BackGroudnColour.GetBlue());	cairo_paint(m_cr_tmp);	double dNewX = m_dOrigin_X + double(x);	double dNewY = m_dOrigin_Y + double(y);	cairo_set_source_surface (m_cr_tmp, m_saLayerCaches[m_nLastCacheID].pCairoSurface, -dNewX, -dNewY);	cairo_paint (m_cr_tmp);	//cairo_surface_t *surface;    cairo_t *cr;	cr = CreateContext(pDC);	//surface = cairo_get_target(cr);	cairo_set_source_surface (cr, m_surface_tmp, 0, 0);	cairo_paint (cr);#ifdef __WXMSW__    //cairo_surface_destroy (surface);    cairo_destroy (cr);#endif}

LinuxGLContext::LinuxGLContext(const RenderContextDescriptor& desc, Surface& surface, LinuxGLContext* sharedContext) :    GLContext { sharedContext }{    NativeHandle nativeHandle;    surface.GetNativeHandle(&nativeHandle);    CreateContext(desc, nativeHandle, sharedContext);}

void FJavascriptEditorModule::StartupModule(){#if WITH_EDITOR		auto Isolate = NewObject<UJavascriptIsolate>();	auto Context = Isolate->CreateContext();		JavascriptContext = Context;	JavascriptContext->AddToRoot();	JavascriptContext->SetContextId(TEXT("Editor"));	Tick = NewObject<UJavascriptEditorTick>(JavascriptContext);	JavascriptContext->Expose(TEXT("Root"), Tick);	Tick->AddToRoot();	if (!IsRunningCommandlet())	{		FScopedTransaction Transaction(NSLOCTEXT("UnrealEd", "UnrealJS", "Javascript action"));		FEditorScriptExecutionGuard ScriptGuard;		Context->RunFile("editor.js");	}	bRegistered = true;		FCoreDelegates::OnPreExit.AddRaw(this, &FJavascriptEditorModule::Unregister);#endif}

bool GSWndEGL::Create(const string& title, int w, int h){	if(m_NativeWindow)		throw GSDXRecoverableError();	if(w <= 0 || h <= 0) {		w = theApp.GetConfig("ModeWidth", 640);		h = theApp.GetConfig("ModeHeight", 480);	}	m_managed = true;	// note this part must be only executed when replaying .gs debug file	m_NativeDisplay = XOpenDisplay(NULL);	OpenEGLDisplay();	m_NativeWindow = XCreateSimpleWindow(m_NativeDisplay, DefaultRootWindow(m_NativeDisplay), 0, 0, w, h, 0, 0, 0);	XMapWindow (m_NativeDisplay, m_NativeWindow);	CreateContext(3, 3);	AttachContext();	CheckContext();	PopulateGlFunction();	if (m_NativeWindow == 0)		throw GSDXRecoverableError();	return true;}

intmain(int argc, char *argv[]){   GLuint shader = 0;   ParseOptions(argc, argv);   if (!CreateContext()) {      fprintf(stderr, "%s: Failed to create compiler context/n", Prog);      exit(1);   }   if (Options.VertFile) {      shader = CompileShader(Options.VertFile, GL_VERTEX_SHADER);   }   else if (Options.FragFile) {      shader = CompileShader(Options.FragFile, GL_FRAGMENT_SHADER);   }   if (shader) {      if (Options.OutputFile) {         fclose(stdout);         /*stdout =*/ freopen(Options.OutputFile, "w", stdout);      }      if (stdout) {         PrintShaderInstructions(shader, stdout);      }      if (Options.OutputFile) {         fclose(stdout);      }   }   return 0;}

bool GSWndOGL::Create(const string& title, int w, int h){	if(m_NativeWindow)		throw GSDXRecoverableError();	if(w <= 0 || h <= 0) {		w = theApp.GetConfig("ModeWidth", 640);		h = theApp.GetConfig("ModeHeight", 480);	}	m_managed = true;	// note this part must be only executed when replaying .gs debug file	m_NativeDisplay = XOpenDisplay(NULL);	m_NativeWindow = XCreateSimpleWindow(m_NativeDisplay, DefaultRootWindow(m_NativeDisplay), 0, 0, w, h, 0, 0, 0);	XMapWindow (m_NativeDisplay, m_NativeWindow);	if (m_NativeWindow == 0)		throw GSDXRecoverableError();	CreateContext(3, 3);	AttachContext();	CheckContext();	m_swapinterval = (PFNGLXSWAPINTERVALEXTPROC)glXGetProcAddress((const GLubyte*) "glXSwapIntervalEXT");	PopulateGlFunction();	return true;}

int main (int argc, char *argv[]) {    if (InitCVIRTE (0, argv, 0) == 0)        return -1;    /* out of memory */        if (argc != 2) {        fprintf(stderr, "you must pass the path to a module to test");        return -1;    }        char *testModule = argv[1];    if (!FileExists(testModule, 0)) {        fprintf(stderr, "you must pass the path to a module to test");    }        ListType names;    SymbolParser *parser = MakeParser(testModule);    names = GetExports(parser);        context = CreateContext();    LoadTestInfo info = { .parser = parser, .executeOnContext = context->ExecuteTests };    ListApplyToEach(names, 1, LoadUserTests, &info);        DeleteParser(parser);    FreeContext(context);    return 0;}

GlxContext::GlxContext(GlxContext* shared) :myWindow    (0),myContext   (NULL),myOwnsWindow(true){    // Open a connection with the X server    myDisplay = XOpenDisplay(NULL);    // Create a dummy window (disabled and hidden)    int screen = DefaultScreen(myDisplay);    myWindow = XCreateWindow(myDisplay,                             RootWindow(myDisplay, screen),                             0, 0,                             1, 1,                             0,                             DefaultDepth(myDisplay, screen),                             InputOutput,                             DefaultVisual(myDisplay, screen),                             0, NULL);    // Create the context    CreateContext(shared, VideoMode::GetDesktopMode().BitsPerPixel, ContextSettings(0, 0, 0));    // Activate the context    SetActive(true);}

int OpenBlankerWindow( void ){	struct NewGadget	ng;	struct Gadget	*g;	UWORD		lc, tc;	UWORD		wleft = BlankerLeft, wtop = BlankerTop, ww, wh;	ComputeFont( BlankerWidth, BlankerHeight );	ww = ComputeX( BlankerWidth );	wh = ComputeY( BlankerHeight );	if (( wleft + ww + OffX + Scr->WBorRight ) > Scr->Width ) wleft = Scr->Width - ww;	if (( wtop + wh + OffY + Scr->WBorBottom ) > Scr->Height ) wtop = Scr->Height - wh;	if ( ! ( BlankerFont = OpenDiskFont( Font )))		return( 5L );	if ( ! ( g = CreateContext( &BlankerGList )))		return( 1L );	for( lc = 0, tc = 0; lc < Blanker_CNT; lc++ ) {		CopyMem((char * )&BlankerNGad[ lc ], (char * )&ng, (long)sizeof( struct NewGadget ));		ng.ng_VisualInfo = VisualInfo;		ng.ng_TextAttr   = Font;		ng.ng_LeftEdge   = OffX + ComputeX( ng.ng_LeftEdge );		ng.ng_TopEdge    = OffY + ComputeY( ng.ng_TopEdge );		ng.ng_Width      = ComputeX( ng.ng_Width );		ng.ng_Height     = ComputeY( ng.ng_Height);		BlankerGadgets[ lc ] = g = CreateGadgetA((ULONG)BlankerGTypes[ lc ], g, &ng, ( struct TagItem * )&BlankerGTags[ tc ] );		while( BlankerGTags[ tc ] ) tc += 2;		tc++;		if ( NOT g )			return( 2L );	}	if ( ! ( BlankerWnd = OpenWindowTags( NULL,				WA_Left,	wleft,				WA_Top,		wtop,				WA_Width,	ww + OffX + Scr->WBorRight,				WA_Height,	wh + OffY + Scr->WBorBottom,				WA_IDCMP,	BUTTONIDCMP|LISTVIEWIDCMP|IDCMP_MENUPICK|IDCMP_CLOSEWINDOW|IDCMP_VANILLAKEY|IDCMP_REFRESHWINDOW,				WA_Flags,	WFLG_DRAGBAR|WFLG_DEPTHGADGET|WFLG_CLOSEGADGET|WFLG_SIZEBBOTTOM|WFLG_SMART_REFRESH|WFLG_ACTIVATE|WFLG_RMBTRAP,				WA_Gadgets,	BlankerGList,				WA_Title,	BlankerWdt,				WA_ScreenTitle,	"Garshneblanker",				WA_PubScreen,	Scr,				TAG_DONE )))	return( 4L );	GT_RefreshWindow( BlankerWnd, NULL );	return( 0L );}

struct Gadget *CreateAllGadgets(piObject *o){	struct Gadget *g=NULL;	piObject *go;	struct Node_Window *nw;	piGetAttr(o,OBJ_Node,(ULONG *)&nw);	nw->nw_Gadgets=NULL;	if(nw->nw_PageGadget==0 && GUI.gui_Mode==MODE_TEST)	{		if(nw->nw_MyFlags&MYWA_BBottomSlider)		{			g=CreateContext(&nw->nw_Gadgets);			unless(nw->nw_Object[0]=NewObject(NULL, BUTTONGCLASS,//				ICA_TARGET, ICTARGET_IDCMP,				GA_RelVerify,TRUE,				GA_Image, gui_LeftImage,				GA_RelRight, 1-(IM_WIDTH(gui_LeftImage)+IM_WIDTH(gui_SizeImage)+IM_WIDTH(gui_RightImage)),				GA_RelBottom, 1-(IM_HEIGHT(gui_LeftImage)),				GA_BottomBorder,TRUE,				GA_Previous,(ULONG *)g,				(nw->nw_Flags&WFLG_GIMMEZEROZERO) ? GA_GZZGadget : TAG_IGNORE,TRUE,				GA_ID, GD_LEFTBUTTON,				TAG_DONE)) return NULL;			g=(struct Gadget *)nw->nw_Object[0];			unless(nw->nw_Object[1]=NewObject(NULL, BUTTONGCLASS,//				ICA_TARGET, ICTARGET_IDCMP,				GA_RelVerify,TRUE,				GA_Image, gui_RightImage,				GA_RelRight, 1-(IM_WIDTH(gui_RightImage)+IM_WIDTH(gui_SizeImage)),				GA_RelBottom, 1-(IM_HEIGHT(gui_RightImage)),				GA_BottomBorder,TRUE,				GA_Previous,(ULONG *)g,				(nw->nw_Flags&WFLG_GIMMEZEROZERO) ? GA_GZZGadget : TAG_IGNORE,TRUE,				GA_ID, GD_RIGHTBUTTON,				TAG_DONE)) return NULL;			g=(struct Gadget *)nw->nw_Object[1];			unless(nw->nw_Object[2]=NewObject(NULL, PROPGCLASS,//				ICA_TARGET, ICTARGET_IDCMP,				GA_RelVerify,TRUE,				PGA_Freedom, FREEHORIZ,				PGA_NewLook, TRUE,				PGA_Borderless, ((DrawInfo->dri_Flags & DRIF_NEWLOOK) && DrawInfo->dri_Depth != 1),				GA_Left, 3,				GA_RelBottom, -(IM_HEIGHT(gui_SizeImage)-3),				GA_RelWidth, -(4+IM_WIDTH(gui_LeftImage)+IM_WIDTH(gui_RightImage)+IM_WIDTH(gui_SizeImage)+1),				GA_Height, IM_HEIGHT(gui_SizeImage)-4,				GA_BottomBorder, TRUE,				GA_Previous,(ULONG *)g,				(nw->nw_Flags&WFLG_GIMMEZEROZERO) ? GA_GZZGadget : TAG_IGNORE,TRUE,				GA_ID, GD_HORIZBUTTON,				PGA_Total, 1,				PGA_Visible, 1,				TAG_DONE)) return NULL;			g=(struct Gadget *)nw->nw_Object[2];		}		else		{

zglCoreContextWin::zglCoreContextWin(const zglState& state)    : m_state(state)    , m_hDC(NULL)    , m_Context(NULL)    , m_tempContext(NULL){    CreateContext();}

void TLSContext::Initialise(){  InitialiseThreadSafety();  InitialiseOpenSSL();  CreateContext();  LoadCertificate();  SelectCiphers();  DerivedInitialise();}

int OpenBlockSelectWindow( void ){	struct NewGadget	ng;	struct Gadget	*g;	UWORD		lc, tc;	UWORD		offx = Scr->WBorLeft, offy = Scr->WBorTop + Scr->RastPort.TxHeight + 1;	if ( ! ( g = CreateContext( &BlockSelectGList ))){		CloseBlockSelectWindow();		return( 1L );	}	for( lc = 0, tc = 0; lc < BlockSelect_CNT; lc++ ) {		CopyMem((char * )&BlockSelectNGad[ lc ], (char * )&ng, (long)sizeof( struct NewGadget ));		ng.ng_VisualInfo = VisualInfo;		ng.ng_TextAttr   = &topaz8;		ng.ng_LeftEdge  += offx;		ng.ng_TopEdge   += offy;		BlockSelectGadgets[ lc ] = g = CreateGadgetA((ULONG)BlockSelectGTypes[ lc ], g, &ng, ( struct TagItem * )&BlockSelectGTags[ tc ] );		while( BlockSelectGTags[ tc ] ) tc += 2;		tc++;		if ( NOT g ){			CloseBlockSelectWindow();			return( 2L );		}	}	if ( ! ( BlockSelectWnd = OpenWindowTags( NULL,				WA_Left,	BlockSelectLeft,				WA_Top,		BlockSelectTop,				WA_Width,	BlockSelectWidth,				WA_Height,	BlockSelectHeight + offy,				WA_IDCMP,	LISTVIEWIDCMP | BUTTONIDCMP | IDCMP_NEWSIZE | IDCMP_REFRESHWINDOW | IDCMP_RAWKEY,				WA_Flags,	WFLG_SIZEGADGET|WFLG_DRAGBAR|WFLG_DEPTHGADGET|WFLG_SMART_REFRESH,				WA_Gadgets,	BlockSelectGList,				WA_Title,	BlockSelectWdt,				WA_MinWidth,	160,				WA_MinHeight,	60,				WA_MaxWidth,	720,				WA_MaxHeight,	467,				WA_AutoAdjust,	TRUE,				WA_PubScreen,Scr,				TAG_DONE )))	{		CloseBlockSelectWindow();		return( 4L );	}	GT_RefreshWindow( BlockSelectWnd, NULL );	return( 0L );}

   OGLDriver::OGLDriver(HWND hWnd, float viewportWidth, float viewportHeight, bool fullscreen)   {      m_hWnd = hWnd;      m_viewPortWidth = viewportWidth;      m_viewPortHeight = viewportHeight;      m_fullscreen = fullscreen;      CreateContext();   }

int lib_gadtools_f_CreateContext_2(emumsg_syscall_t *msg){	/* Make real syscall */	msg->arg[0]._aptr = CreateContext(		(struct Gadget **)msg->arg[0]._aptr	);	return HOOK_DONE;}

int main(int argc, const char *argv[]){    KonohaContext* konoha = CreateContext();    int i;    for (i = 0; i < 100; ++i) {        test_kString(konoha);    }    DeleteContext(konoha);    return 0;}

void ClSetup::SetupCl(int platform_index, int device_index){    platform = GetPlatformID(platform_index);    PrintPlatformInfo(platform);    device = GetDeviceID(device_index);    PrintDeviceInfo(device);    context = CreateContext();    queue = CreateCommandQueue();    bInit = true;}

//Función que se encarga de la inicialización de OpenGL.//Recibe la ventana sobre la que OpenGL hará el render.bool cGraphicManager::Init( cWindow * lpWindow ){   //Se crear el contexto de renderizado:   bool lbRet = CreateContext( lpWindow );   if ( lbRet )   {      //Se establece el estado de OpenGL:      InitializeGLState();	   }   return lbRet;}

ThreadContext* PhysicalOperator::CreateOrReuseContext(context_reuse_mode crm) {  ThreadContext* target = GetFreeContext(crm);  if (target != NULL) {    return target;  }  target = CreateContext();  target->set_locality_(GetCurrentCpuAffinity());  InitContext(target);  return target;}

int main(int argc, const char *argv[]){	int ret = 0;	KonohaContext* konoha = CreateContext();	test_gc(konoha);	DeleteContext(konoha);	assert(__Free__ == __Init__);	fprintf(stderr, "alloced_object_count = %d, freed_object_count=%d/n", __Init__, __Free__);	test_bitops();	return ret;}

static voidInstance_DidChangeView(PP_Instance instance,		       const struct PP_Rect* position,		       const struct PP_Rect* clip){  if (position->size.width == screenWidth &&      position->size.height == screenHeight)    return;  // Size didn't change, no need to update anything.  Log("change view/n");  DestroyContext(instance);  CreateContext(instance, &position->size);}

int main(int argc, char** argv){	glutInit(&argc, argv);	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA);	glutCreateWindow("GL interop");	glutIconifyWindow();	glutDisplayFunc(computeVBO);	glutIdleFunc(computeVBO);	initVBO();	CreateContext();	if(!context)	{		std::cerr << "Failed to create OpenCL context." << std::endl;		return EXIT_FAILURE;	}	CreateCommandQueue();	if(!commandQueue)	{		Cleanup();		return EXIT_FAILURE;	}	CreateProgram();	if(!program)	{		Cleanup();		return EXIT_FAILURE;	}	kernel = clCreateKernel(program, "init_vbo_kernel", NULL);	if(!kernel)	{		std::cerr << "Failed to create kernel" << std::endl;		Cleanup();		return EXIT_FAILURE;	}	if (!CreateMemObjects())	{		Cleanup();		return EXIT_FAILURE;	}	glutMainLoop();	std::cout << std::endl;	std::cout << "Executed program succesfully." << std::endl;	Cleanup();}

void wxGISDisplay::Output(cairo_surface_t *pSurface, wxDC* pDC){    cairo_t *cr = CreateContext(pDC);    if(cr == NULL)        return;	cairo_set_source_surface (cr, pSurface, 0, 0);	cairo_paint (cr);//#ifdef __WXMSW__    cairo_destroy (cr);//#endif}

bool GSWndOGL::Attach(void* handle, bool managed){	m_NativeWindow = *(Window*)handle;	m_managed = managed;	m_NativeDisplay = XOpenDisplay(NULL);	if (theApp.GetConfig("reduce_gl_requirement_for_free_driver", 0) == 1)		CreateContext(3, 0);	else		CreateContext(3, 3);	AttachContext();	CheckContext();	m_swapinterval = (PFNGLXSWAPINTERVALEXTPROC)glXGetProcAddress((const GLubyte*) "glXSwapIntervalEXT");	PopulateGlFunction();	return true;}

bool GSWndEGL::Attach(void* handle, bool managed){	m_NativeWindow = *(Window*)handle;	m_managed = managed;	m_NativeDisplay = XOpenDisplay(NULL);	OpenEGLDisplay();#ifdef ENABLE_GLES	// FIXME: update it to GLES 3.1 when  they support it	CreateContext(3, 0);#else	CreateContext(3, 3);#endif	AttachContext();	CheckContext();	PopulateGlFunction();	return true;}