示例#1
0
void CMainWindow::on_actionShow_Grid_triggered(bool checked)
{
    m_rw3->ToggleGrid(checked);
    UpdateView();
}
示例#2
0
void CQueueView::OnSize(UINT nType, int cx, int cy) 
{
	CreateBackBuffer(cx, cy);	// order matters, else bars are erratic
	UpdateView();
	CScrollView::OnSize(nType, cx, cy);
}
void WorkspaceBrowserF::OnRefreshTree(wxCommandEvent& event)
{
	UpdateView();
}
示例#4
0
void __fastcall TfrmEditLightAnim::ebSaveClick(TObject *Sender)
{
	ebSave->Enabled				 = false;
	LALib.Save					();
    UpdateView					();
}
示例#5
0
void __fastcall TfrmEditLightAnim::OnModified()
{
	ebSave->Enabled = true;
    UpdateView();
}
示例#6
0
int InitWindowAndLoop(int argc, char** argv)
{
    char* ClassName = "BOOTEDWIN";
    WNDCLASSEX ClassStruct;
    memset(&ClassStruct, 0, sizeof(ClassStruct));
    ClassStruct.cbSize = sizeof(ClassStruct);
    ClassStruct.style = CS_OWNDC;
    ClassStruct.lpfnWndProc = WndProc;
    ClassStruct.hInstance = WinSys_hInstance;
    ClassStruct.lpszClassName = ClassName;
    RegisterClassEx(&ClassStruct);
    HWND hWnd = CreateWindow(ClassName,
                             "BootEd Window.",
                             WS_TILEDWINDOW,
                             CW_USEDEFAULT,
                             CW_USEDEFAULT,
                             1024,
                             768,
                             NULL,
                             NULL,
                             WinSys_hInstance,
                             NULL);

    ShowWindow(hWnd, SW_SHOW);

    HDC dc = GetDC(hWnd);

    PIXELFORMATDESCRIPTOR pfd;
    memset(&pfd, 0, sizeof(pfd));
    pfd.nSize = sizeof(pfd);
    pfd.nVersion = 1;
    pfd.dwFlags = PFD_DOUBLEBUFFER | PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW;
    pfd.iPixelType = PFD_TYPE_RGBA;
    pfd.cColorBits = 32;
    pfd.cDepthBits = 32;
    pfd.iLayerType = PFD_MAIN_PLANE;

    int pixel_format = ChoosePixelFormat(dc, &pfd);
    if(pixel_format == 0)
        return 1;

    if(!SetPixelFormat(dc, pixel_format, &pfd))
        return 1;

    HGLRC glRc = wglCreateContext(dc);
    wglMakeCurrent(dc, glRc);

    void InitGLExt();
    InitGLExt();

    WinSys_View = InitView();
    ResizeView(WinSys_View, WinSys_Width, WinSys_Height);

    // This message loop is meant to consume all system resources, needs
    // to be changed for apps that are meant to idle, I.E. editors.
    bool continue_loop = true;
    while(continue_loop)
    {
        MSG msg;
        while(PeekMessage(&msg, NULL, 0, 0, 0))
        {
            if(!GetMessage(&msg, NULL, 0, 0))
                continue_loop = false;

            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
        UpdateView(WinSys_View);
        SwapBuffers(dc);
    }

    FinishView(WinSys_View);
    wglMakeCurrent(NULL, NULL);
    wglDeleteContext(glRc);

    return 0;
}
示例#7
0
XSilChessWindow::XSilChessWindow(XtAppContext app, Widget toplevel,
                                 Visual * vsl, int vsldepth, Colormap cmap)
{
	char tmp[512];
	Arg al[10];
	int i;
	XmString xms;

	// Initialize member variables
	App=app;
	TopLevel=toplevel;
	Disp=XtDisplay(TopLevel);
	Vsl=vsl;
	VslDepth=vsldepth;
	CMap=cmap;
	DlgVsl=DefaultVisual(Disp,XScreenNumberOfScreen(XtScreen(TopLevel)));
	DlgVslDepth=DefaultDepth(Disp,XScreenNumberOfScreen(XtScreen(TopLevel)));
	DlgCMap=DefaultColormap(Disp,XScreenNumberOfScreen(XtScreen(TopLevel)));
	PixelSize=(VslDepth<=8 ? 1 : (VslDepth<=16 ? 2 : 4));
	RedMask=Vsl->red_mask;
	GreenMask=Vsl->green_mask;
	BlueMask=Vsl->blue_mask;
	SelX=SelY-1;
	IsSearching=false;
	AbortSearching=false;
	NeedPainting=false;
	IsPainting=false;
	HintWanted=false;
	HintValid=false;

	// Create main window
	MainWin=XtVaCreateManagedWidget(
		"mainWin",xmMainWindowWidgetClass,TopLevel,
		(char*)NULL
	);

	// Create main menu bar
	MainMenu=XmCreateMenuBar(MainWin,(char*)"mainMenu",NULL,0);
	XtManageChild(MainMenu);

	// Create menu item: file
	XtSetArg(al[0],XmNvisual,Vsl);
	XtSetArg(al[1],XmNdepth,VslDepth);
	XtSetArg(al[2],XmNcolormap,CMap);
	FileMenu=XmCreatePulldownMenu(MainMenu,(char*)"fileMenu",al,3);
	BFile=XtVaCreateManagedWidget(
		"file",xmCascadeButtonWidgetClass,MainMenu,
		XmNsubMenuId,FileMenu,
		(char*)NULL
	);

	// Create menu item: file/load
	BFileLoad=XtVaCreateManagedWidget(
		"load",xmPushButtonWidgetClass,FileMenu,
		(char*)NULL
	);
	XtAddCallback(BFileLoad,XmNactivateCallback,HandleCallback,this);

	// Create menu item: file/save
	BFileSave=XtVaCreateManagedWidget(
		"save",xmPushButtonWidgetClass,FileMenu,
		(char*)NULL
	);
	XtAddCallback(BFileSave,XmNactivateCallback,HandleCallback,this);

	// Create menu item: file/exit
	XtVaCreateManagedWidget(
		"separator",xmSeparatorWidgetClass,FileMenu,
		(char*)NULL
	);
	BFileExit=XtVaCreateManagedWidget(
		"exit",xmPushButtonWidgetClass,FileMenu,
		(char*)NULL
	);
	XtAddCallback(BFileExit,XmNactivateCallback,HandleCallback,this);

	// Create menu item: game
	XtSetArg(al[0],XmNvisual,Vsl);
	XtSetArg(al[1],XmNdepth,VslDepth);
	XtSetArg(al[2],XmNcolormap,CMap);
	GameMenu=XmCreatePulldownMenu(MainMenu,(char*)"gameMenu",al,3);
	BGame=XtVaCreateManagedWidget(
		"game",xmCascadeButtonWidgetClass,MainMenu,
		XmNsubMenuId,GameMenu,
		(char*)NULL
	);

	// Create menu item: game/new
	BGameNew=XtVaCreateManagedWidget(
		"new",xmPushButtonWidgetClass,GameMenu,
		(char*)NULL
	);
	XtAddCallback(BGameNew,XmNactivateCallback,HandleCallback,this);

	// Create menu item: game/flip
	BGameFlip=XtVaCreateManagedWidget(
		"flip",xmPushButtonWidgetClass,GameMenu,
		(char*)NULL
	);
	XtAddCallback(BGameFlip,XmNactivateCallback,HandleCallback,this);

	// Create menu item: game/undo
	BGameUndo=XtVaCreateManagedWidget(
		"undo",xmPushButtonWidgetClass,GameMenu,
		(char*)NULL
	);
	XtAddCallback(BGameUndo,XmNactivateCallback,HandleCallback,this);

	// Create menu item: game/list
	BGameList=XtVaCreateManagedWidget(
		"list",xmPushButtonWidgetClass,GameMenu,
		(char*)NULL
	);
	XtAddCallback(BGameList,XmNactivateCallback,HandleCallback,this);

	// Create menu item: computer
	XtSetArg(al[0],XmNvisual,Vsl);
	XtSetArg(al[1],XmNdepth,VslDepth);
	XtSetArg(al[2],XmNcolormap,CMap);
	CompMenu=XmCreatePulldownMenu(MainMenu,(char*)"compMenu",al,3);
	BComp=XtVaCreateManagedWidget(
		"comp",xmCascadeButtonWidgetClass,MainMenu,
		XmNsubMenuId,CompMenu,
		(char*)NULL
	);

	// Create menu item: computer/hint
	BCompHint=XtVaCreateManagedWidget(
		"hint",xmPushButtonWidgetClass,CompMenu,
		(char*)NULL
	);
	XtAddCallback(BCompHint,XmNactivateCallback,HandleCallback,this);

	// Create menu item: computer/depth
	XtSetArg(al[0],XmNvisual,Vsl);
	XtSetArg(al[1],XmNdepth,VslDepth);
	XtSetArg(al[2],XmNcolormap,CMap);
	XtSetArg(al[3],XmNradioBehavior,True);
	DepthMenu=XmCreatePulldownMenu(CompMenu,(char*)"depthMenu",al,4);
	BCompDepth=XtVaCreateManagedWidget(
		"depth",xmCascadeButtonWidgetClass,CompMenu,
		XmNsubMenuId,DepthMenu,
		(char*)NULL
	);

	// Create menu items: computer/depth/1...
	for (i=0; i<=SilChessMachine::MAX_SEARCH_DEPTH; i++) {
		sprintf(tmp,"%d",i);
		BDepth[i]=XtVaCreateManagedWidget(
			tmp,xmToggleButtonWidgetClass,DepthMenu,
			(char*)NULL
		);
		XtAddCallback(BDepth[i],XmNvalueChangedCallback,HandleCallback,this);
	}

	// Create menu item: help
	XtSetArg(al[0],XmNvisual,Vsl);
	XtSetArg(al[1],XmNdepth,VslDepth);
	XtSetArg(al[2],XmNcolormap,CMap);
	HelpMenu=XmCreatePulldownMenu(MainMenu,(char*)"helpMenu",al,3);
	BHelp=XtVaCreateManagedWidget(
		"help",xmCascadeButtonWidgetClass,MainMenu,
		XmNsubMenuId,HelpMenu,
		(char*)NULL
	);
	XtVaSetValues(MainMenu,XmNmenuHelpWidget,BHelp,(char*)NULL);

	// Create menu item: help/about
	BHelpAbout=XtVaCreateManagedWidget(
		"about",xmPushButtonWidgetClass,HelpMenu,
		(char*)NULL
	);
	XtAddCallback(BHelpAbout,XmNactivateCallback,HandleCallback,this);

	// Create a parent for status bar and view
	MainForm=XtVaCreateManagedWidget(
		"mainForm",xmFormWidgetClass,MainWin,
		(char*)NULL
	);

	// Create status line
	StatusFrame=XtVaCreateManagedWidget(
		"statusFrame",xmFrameWidgetClass,MainForm,
		XmNleftAttachment,XmATTACH_FORM,
		XmNrightAttachment,XmATTACH_FORM,
		XmNtopAttachment,XmATTACH_FORM,
		(char*)NULL
	);
	StatusLabel=XtVaCreateManagedWidget(
		"statusLabel",xmLabelWidgetClass,StatusFrame,
		XmNalignment, XmALIGNMENT_BEGINNING,
		(char*)NULL
	);

	// Create the chess board view
	ViewFrame=XtVaCreateManagedWidget(
		"viewFrame",xmFrameWidgetClass,MainForm,
		XmNtopAttachment,XmATTACH_WIDGET,
		XmNtopWidget,StatusFrame,
		XmNleftAttachment,XmATTACH_FORM,
		XmNrightAttachment,XmATTACH_FORM,
		XmNbottomAttachment,XmATTACH_FORM,
		(char*)NULL
	);
	ViewArea=XtVaCreateManagedWidget(
		"viewArea",xmDrawingAreaWidgetClass,ViewFrame,
		XmNtopAttachment,XmATTACH_FORM,
		XmNleftAttachment,XmATTACH_FORM,
		XmNrightAttachment,XmATTACH_FORM,
		XmNbottomAttachment,XmATTACH_FORM,
		(char*)NULL
	);
	XtAddCallback(ViewArea,XmNexposeCallback,HandleCallback,this);
	XtAddCallback(ViewArea,XmNresizeCallback,HandleCallback,this);
	XtAddEventHandler(
		ViewArea,ButtonPressMask|ButtonMotionMask|ButtonReleaseMask|
		StructureNotifyMask,False,HandleEvent,this
	);
	XtVaGetValues(ViewArea,XmNwidth,&ViewWidth,(char*)NULL);
	XtVaGetValues(ViewArea,XmNheight,&ViewHeight,(char*)NULL);
	ViewWin=0;
	ViewGC=NULL;

	// Create dialog: load game
	XtSetArg(al[0],XmNvisual,DlgVsl);
	XtSetArg(al[1],XmNdepth,DlgVslDepth);
	XtSetArg(al[2],XmNcolormap,DlgCMap);
	XtSetArg(al[3],XmNautoUnmanage,True);
	LoadDialog=XmCreateFileSelectionDialog(TopLevel,(char*)"loadDialog",al,4);
	XtAddCallback(LoadDialog,XmNokCallback,HandleCallback,this);
	XtUnmanageChild(XmFileSelectionBoxGetChild(LoadDialog,XmDIALOG_HELP_BUTTON));

	// Create dialog: save game
	XtSetArg(al[0],XmNvisual,DlgVsl);
	XtSetArg(al[1],XmNdepth,DlgVslDepth);
	XtSetArg(al[2],XmNcolormap,DlgCMap);
	XtSetArg(al[3],XmNautoUnmanage, True);
	SaveDialog=XmCreateFileSelectionDialog(TopLevel,(char*)"saveDialog",al,4);
	XtAddCallback(SaveDialog,XmNokCallback,HandleCallback,this);
	XtUnmanageChild(XmFileSelectionBoxGetChild(SaveDialog,XmDIALOG_HELP_BUTTON));

	// Create dialog: file exists, overwrite?
	XtSetArg(al[0],XmNvisual,DlgVsl);
	XtSetArg(al[1],XmNdepth,DlgVslDepth);
	XtSetArg(al[2],XmNcolormap,DlgCMap);
	XtSetArg(al[3],XmNautoUnmanage, True);
	OverwriteDialog=XmCreateWarningDialog(TopLevel,(char*)"overwriteDialog",al,4);
	XtUnmanageChild(XmMessageBoxGetChild(OverwriteDialog,XmDIALOG_HELP_BUTTON));
	XtAddCallback(OverwriteDialog,XmNokCallback,HandleCallback,this);

	// Create dialog: error message
	XtSetArg(al[0],XmNvisual,DlgVsl);
	XtSetArg(al[1],XmNdepth,DlgVslDepth);
	XtSetArg(al[2],XmNcolormap,DlgCMap);
	XtSetArg(al[3],XmNautoUnmanage, True);
	ErrorBox=XmCreateWarningDialog(TopLevel,(char*)"errorBox",al,4);
	XtUnmanageChild(XmMessageBoxGetChild(ErrorBox,XmDIALOG_CANCEL_BUTTON));
	XtUnmanageChild(XmMessageBoxGetChild(ErrorBox,XmDIALOG_HELP_BUTTON));

	// Create dialog: list of moves
	ListDialogPopup=XtVaCreateWidget(
		"listDialog_popup",xmDialogShellWidgetClass,TopLevel,
		XmNvisual,DlgVsl,
		XmNdepth,DlgVslDepth,
		XmNcolormap,DlgCMap,
		(char*)NULL
	);
	ListDialog=XtVaCreateWidget(
		"listDialog",xmFormWidgetClass,ListDialogPopup,
		(char*)NULL
	);
	LDClose=XtVaCreateManagedWidget(
		"close",xmPushButtonWidgetClass,ListDialog,
		XmNleftAttachment,XmATTACH_FORM,
		XmNrightAttachment,XmATTACH_FORM,
		XmNbottomAttachment,XmATTACH_FORM,
		(char*)NULL
	);
	XtAddCallback(LDClose,XmNactivateCallback,HandleCallback,this);
	LDScroll=XtVaCreateManagedWidget(
		"scroll",xmScrolledWindowWidgetClass,ListDialog,
		XmNscrollingPolicy,XmAUTOMATIC,
		XmNscrollBarDisplayPolicy,XmAS_NEEDED,
		XmNleftAttachment,XmATTACH_FORM,
		XmNrightAttachment,XmATTACH_FORM,
		XmNtopAttachment,XmATTACH_FORM,
		XmNbottomAttachment,XmATTACH_WIDGET,
		XmNbottomWidget,LDClose,
		(char*)NULL
	);
	LDList=XtVaCreateManagedWidget(
		"list",xmLabelGadgetClass,LDScroll,
		XmNalignment,XmALIGNMENT_BEGINNING,
		(char*)NULL
	);

	// Create dialog: about
	xms=XmStringCreateLtoR((char*)AboutText,XmFONTLIST_DEFAULT_TAG);
	XtSetArg(al[0],XmNvisual,DlgVsl);
	XtSetArg(al[1],XmNdepth,DlgVslDepth);
	XtSetArg(al[2],XmNcolormap,DlgCMap);
	XtSetArg(al[3],XmNautoUnmanage,True);
	XtSetArg(al[4],XmNmessageString,xms);
	XtSetArg(al[5],XmNmessageAlignment,XmALIGNMENT_CENTER);
	AboutDialog=XmCreateMessageDialog(TopLevel,(char*)"aboutDialog",al,6);
	XmStringFree(xms);
	XtUnmanageChild(XmMessageBoxGetChild(AboutDialog,XmDIALOG_CANCEL_BUTTON));
	XtUnmanageChild(XmMessageBoxGetChild(AboutDialog,XmDIALOG_HELP_BUTTON));

	// Set main window areas
	XmMainWindowSetAreas(MainWin,MainMenu,NULL,NULL,NULL,MainForm);

	// Create chess machine
	Machine = new SilChessMachine();

	// Setup ray tracer
	RT.SetViewSize(ViewWidth,ViewHeight);
	RT.SetWorld(Machine);

	// Update all
	UpdateStatusBar();
	UpdateMovesList();
	UpdateView();
	UpdateDepthMenu();
}
示例#8
0
//@cmember Send a WM_PAINT to the window
void tomEdit::TxViewChange(BOOL fUpdate) 
{
    UpdateView(NULL) ;
}
示例#9
0
void Plotter::Render()
{
    // Animate scroll / zooming
    UpdateView();

#ifndef HAVE_GLES
    glPushAttrib(GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT | GL_LINE_BIT);
#endif

    glClearColor(colour_bg.r, colour_bg.g, colour_bg.b, colour_bg.a);
    ActivateScissorAndClear();

    // Try to create smooth lines
    glDisable(GL_MULTISAMPLE);
    glLineWidth(1.5);
    glEnable(GL_LINE_SMOOTH);
    glHint( GL_LINE_SMOOTH_HINT, GL_NICEST );
    glEnable (GL_BLEND);
    glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glDisable(GL_LIGHTING);
    glDisable( GL_DEPTH_TEST );

    const float w = rview.x.Size();
    const float h = rview.y.Size();
    const float ox = -rview.x.Mid();
    const float oy = -rview.y.Mid();
    const float sx = 2.0f / w;
    const float sy = 2.0f / h;

    //////////////////////////////////////////////////////////////////////////
    // Draw ticks
    prog_lines.SaveBind();
    prog_lines.SetUniform("u_scale",  sx, sy);
    prog_lines.SetUniform("u_offset", ox, oy);
    prog_lines.SetUniform("u_color",  colour_tk );

    const float min_space = 80.0;
    int ta[2] = {1,1};
    while(v.w * ta[0] *tick[0].val / w < min_space) ta[0] *=2;
    while(v.h * ta[1] *tick[1].val / h < min_space) ta[1] *=2;

    const float tdelta[2] = {
        tick[0].val * ta[0],
        tick[1].val * ta[1]
    };

    const int tx[2] = {
        (int)ceil(rview.x.min / tdelta[0]),
        (int)ceil(rview.x.max / tdelta[0])
    };

    const int ty[2] = {
        (int)ceil(rview.y.min / tdelta[1]),
        (int)ceil(rview.y.max / tdelta[1])
    };

    for( int i=tx[0]; i<tx[1]; ++i ) {
        glDrawLine((i)*tdelta[0], rview.y.min,   (i)*tdelta[0], rview.y.max);
    }

    for( int i=ty[0]; i<ty[1]; ++i ) {
        glDrawLine(rview.x.min, (i)*tdelta[1],  rview.x.max, (i)*tdelta[1]);
    }
    prog_lines.Unbind();

    //////////////////////////////////////////////////////////////////////////
    // Draw axis

    prog_lines.SaveBind();
    prog_lines.SetUniform("u_color",  colour_ax );
    glDrawLine(0, rview.y.min,  0, rview.y.max );
    glDrawLine(rview.x.min,0,   rview.x.max,0  );
    prog_lines.Unbind();

    //////////////////////////////////////////////////////////////////////////
    // Draw Implicits

    for(size_t i=0; i < plotimplicits.size(); ++i) {
        PlotImplicit& im = plotimplicits[i];
        im.prog.SaveBind();

        im.prog.SetUniform("u_scale",  sx, sy);
        im.prog.SetUniform("u_offset", ox, oy);

        glDrawRect(rview.x.min,rview.y.min,rview.x.max,rview.y.max);

        im.prog.Unbind();
    }

    //////////////////////////////////////////////////////////////////////////
    // Draw series

    static size_t id_size = 0;
    static float* id_array = 0;

    for(size_t i=0; i < plotseries.size(); ++i)
    {
        PlotSeries& ps = plotseries[i];
        GlSlProgram& prog = ps.prog;
        ps.used = false;

        prog.SaveBind();
        prog.SetUniform("u_scale",  sx, sy);
        prog.SetUniform("u_offset", ox, oy);
        prog.SetUniform("u_color", ps.colour );

        // TODO: Try to skip drawing of blocks which aren't in view.
        const DataLogBlock* block = ps.log ? ps.log->FirstBlock() : default_log->FirstBlock();
        while(block) {
            if(ps.contains_id ) {
                if(id_size < block->Samples() ) {
                    // Create index array that we can bind
                    delete[] id_array;
                    id_size = block->MaxSamples();
                    id_array = new float[id_size];
                    for(size_t k=0; k < id_size; ++k) {
                        id_array[k] = (float)k;
                    }
                }
                prog.SetUniform("u_id_offset",  (float)block->StartId() );
            }

            // Enable appropriate attributes
            bool shouldRender = true;
            for(size_t i=0; i< ps.attribs.size(); ++i) {
                if(0 <= ps.attribs[i].plot_id && ps.attribs[i].plot_id < (int)block->Dimensions() ) {
                    glVertexAttribPointer(ps.attribs[i].location, 1, GL_FLOAT, GL_FALSE, (GLsizei)(block->Dimensions()*sizeof(float)), block->DimData(ps.attribs[i].plot_id) );
                    glEnableVertexAttribArray(ps.attribs[i].location);
                }else if( ps.attribs[i].plot_id == -1 ){
                    glVertexAttribPointer(ps.attribs[i].location, 1, GL_FLOAT, GL_FALSE, 0, id_array );
                    glEnableVertexAttribArray(ps.attribs[i].location);
                }else{
                    // bad id: don't render
                    shouldRender = false;
                    break;
                }
            }

            if(shouldRender) {
                // Draw geometry
                glDrawArrays(ps.drawing_mode, 0, (GLsizei)block->Samples());
                ps.used = true;
            }

            // Disable enabled attributes
            for(size_t i=0; i< ps.attribs.size(); ++i) {
                glDisableVertexAttribArray(ps.attribs[i].location);
            }

            block = block->NextBlock();
        }
        prog.Unbind();
    }

    prog_lines.SaveBind();

    //////////////////////////////////////////////////////////////////////////
    // Draw markers
    glLineWidth(2.5f);

    for( size_t i=0; i < plotmarkers.size(); ++i) {
        const Marker& m = plotmarkers[i];

        XYRangef draw_range = m.range;
        draw_range.Clamp(rview);

        prog_lines.SetUniform("u_color",  m.colour );
        if(draw_range.x.Size() == 0.0  || draw_range.y.Size() == 0.0) {
            // Horizontal or Vertical line
            glDrawLine(draw_range.x.min, draw_range.y.min,  draw_range.x.max, draw_range.y.max );
        }else{
            // Region
            glDrawRect(draw_range.x.min, draw_range.y.min,  draw_range.x.max, draw_range.y.max );
        }
    }

    //////////////////////////////////////////////////////////////////////////
    // Draw hover / selection
    glLineWidth(1.5f);

    // hover over
    prog_lines.SetUniform("u_color",  colour_ax.WithAlpha(0.3f) );
    glDrawLine(hover[0], rview.y.min,  hover[0], rview.y.max );
    glDrawLine(rview.x.min, hover[1],  rview.x.max, hover[1] );

    // range
    prog_lines.SetUniform("u_color",  colour_ax.WithAlpha(0.5) );
    glDrawLine(selection.x.min, rview.y.min,  selection.x.min, rview.y.max );
    glDrawLine(selection.x.max, rview.y.min,  selection.x.max, rview.y.max );
    glDrawLine(rview.x.min, selection.y.min,  rview.x.max, selection.y.min );
    glDrawLine(rview.x.min, selection.y.max,  rview.x.max, selection.y.max );
    glDrawRect(selection.x.min, selection.y.min,  selection.x.max, selection.y.max);

    prog_lines.Unbind();

    prog_text.SaveBind();

    //////////////////////////////////////////////////////////////////////////
    // Draw Key

    prog_text.SetUniform("u_scale",  2.0f / v.w, 2.0f / v.h);

    int keyid = 0;
    for(size_t i=0; i < plotseries.size(); ++i)
    {
        PlotSeries& ps = plotseries[i];
        if(ps.used) {
            prog_text.SetUniform("u_color", ps.colour );
            prog_text.SetUniform("u_offset",
                v.w-5-ps.title.Width() -(v.w/2.0f),
                v.h-15*(++keyid) -(v.h/2.0f)
            );
            ps.title.DrawGlSl();
        }
    }

    //////////////////////////////////////////////////////////////////////////
    // Draw axis text

    prog_text.SetUniform("u_scale",  2.0f / v.w, 2.0f / v.h);
    prog_text.SetUniform("u_color", colour_ax );

    for( int i=tx[0]; i<tx[1]; ++i ) {
        std::ostringstream oss;
        oss << i*tdelta[0]*tick[0].factor << tick[0].symbol;
        GlText txt = GlFont::I().Text(oss.str().c_str());
        float sx = v.w*((i)*tdelta[0]-rview.x.Mid())/w - txt.Width()/2.0f;
        prog_text.SetUniform("u_offset", sx, 15 -v.h/2.0f );
        txt.DrawGlSl();
    }

    for( int i=ty[0]; i<ty[1]; ++i ) {
        std::ostringstream oss;
        oss << i*tdelta[1]*tick[1].factor << tick[1].symbol;
        GlText txt = GlFont::I().Text(oss.str().c_str());
        float sy = v.h*((i)*tdelta[1]-rview.y.Mid())/h - txt.Height()/2.0f;
        prog_text.SetUniform("u_offset", 15 -v.w/2.0f, sy );
        txt.DrawGlSl();
    }

    prog_text.Unbind();


    glLineWidth(1.0f);

#ifndef HAVE_GLES
    glPopAttrib();
#endif

}
示例#10
0
void ezQtFileserveActivityModel::UpdateViewSlot()
{
  m_bTimerRunning = false;

  UpdateView();
}
示例#11
0
//@cmember InvalidateRect
void tomEdit::TxInvalidateRect(LPCRECT prc, BOOL fMode) 
{
    UpdateView(prc) ;
}
示例#12
0
/**
 *  get scrollbar notification
 */
void iwAddons::Msg_ScrollChange(const unsigned /*ctrl_id*/, const unsigned short /*position*/)
{
    auto* optiongroup = GetCtrl<ctrlOptionGroup>(5);
    UpdateView(optiongroup->GetSelection());
}
示例#13
0
/**
 *  get scrollbar notification
 *
 *  @author FloSoft
 */
void iwAddons::Msg_ScrollChange(const unsigned int ctrl_id, const unsigned short position)
{
    ctrlOptionGroup* optiongroup = GetCtrl<ctrlOptionGroup>(5);
    UpdateView(optiongroup->GetSelection());
}
示例#14
0
void CMainWindow::on_actionToggle_Lighting_triggered(bool checked)
{
    m_rw3->ToggleLighting(checked);
    UpdateView();
}
示例#15
0
void BaseCamera::SetWorld(const Matrix4& world)
{
    m_world = world;
    m_position = m_world.GetTranslation();
    UpdateView();
}
示例#16
0
void GLCamera::Strafe(float delta) 
{
	m_position += delta * m_right;

	UpdateView();
}
示例#17
0
void GInstructionView::SetInstruction( G_old_Instruction* pInstruction )
{
	m_pInstruction = pInstruction;
	UpdateView();
}
示例#18
0
void SectionViewWidget::OnResetYScale()
{
	m_ScaleY = 1.0;

	UpdateView();
}
示例#19
0
/**
 * _ConstructGUI()
 *
 * Creates the GUI for the View. MUST be called AFTER the View is attached to
 *	the Window, or will crash and/or create strange behaviour
 *
 * @param none
 * @return void
 */
void
MarginView::_ConstructGUI()
{
	fPage = new PageView();
	fPage->SetViewColor(ViewColor());

	fPageSize = new BStringView("pageSize", "?x?");

	BString str;
	// Create text fields

	// top
	str << fMargins.top/fUnitValue;
	fTop = new BTextControl("top", "Top:", str.String(), NULL);

	fTop->SetModificationMessage(new BMessage(TOP_MARGIN_CHANGED));
	fTop->SetTarget(this);
	_AllowOnlyNumbers(fTop, kNumCount);

	//left
    str = "";
	str << fMargins.left/fUnitValue;
	fLeft = new BTextControl("left", "Left:", str.String(), NULL);

	fLeft->SetModificationMessage(new BMessage(LEFT_MARGIN_CHANGED));
	fLeft->SetTarget(this);
	_AllowOnlyNumbers(fLeft, kNumCount);

	//bottom
    str = "";
	str << fMargins.bottom/fUnitValue;
	fBottom = new BTextControl("bottom", "Bottom:", str.String(), NULL);

	fBottom->SetModificationMessage(new BMessage(BOTTOM_MARGIN_CHANGED));
	fBottom->SetTarget(this);
	_AllowOnlyNumbers(fBottom, kNumCount);

	//right
    str = "";
	str << fMargins.right/fUnitValue;
	fRight = new BTextControl("right", "Right:", str.String(), NULL);

	fRight->SetModificationMessage(new BMessage(RIGHT_MARGIN_CHANGED));
	fRight->SetTarget(this);
	_AllowOnlyNumbers(fRight, kNumCount);

	// Create Units popup

	BPopUpMenu *menu = new BPopUpMenu("units");
	BMenuField *units = new BMenuField("units", "Units:", menu);

	BMenuItem *item;
	// Construct menu items
	for (int32 i = 0; kUnitNames[i] != NULL; i++) {
		BMessage *msg = new BMessage(MARGIN_UNIT_CHANGED);
		msg->AddInt32("marginUnit", kUnitMsg[i]);
		menu->AddItem(item = new BMenuItem(kUnitNames[i], msg));
		item->SetTarget(this);
		if (fMarginUnit == kUnitMsg[i])
			item->SetMarked(true);
	}

	BGridView* settings = new BGridView();
	BGridLayout* settingsLayout = settings->GridLayout();
	settingsLayout->AddItem(fTop->CreateLabelLayoutItem(), 0, 0);
	settingsLayout->AddItem(fTop->CreateTextViewLayoutItem(), 1, 0);
	settingsLayout->AddItem(fLeft->CreateLabelLayoutItem(), 0, 1);
	settingsLayout->AddItem(fLeft->CreateTextViewLayoutItem(), 1, 1);
	settingsLayout->AddItem(fBottom->CreateLabelLayoutItem(), 0, 2);
	settingsLayout->AddItem(fBottom->CreateTextViewLayoutItem(), 1, 2);
	settingsLayout->AddItem(fRight->CreateLabelLayoutItem(), 0, 3);
	settingsLayout->AddItem(fRight->CreateTextViewLayoutItem(), 1, 3);
	settingsLayout->AddItem(units->CreateLabelLayoutItem(), 0, 4);
	settingsLayout->AddItem(units->CreateMenuBarLayoutItem(), 1, 4);
	settingsLayout->SetSpacing(0, 0);

	BGroupView* groupView = new BGroupView(B_HORIZONTAL, 10);
	BGroupLayout* groupLayout = groupView->GroupLayout();
	groupLayout->AddView(BGroupLayoutBuilder(B_VERTICAL, 0)
		.Add(fPage)
		.Add(fPageSize)
		.SetInsets(0, 0, 0, 0)
		.TopView()
	);
	groupLayout->AddView(settings);
	groupLayout->SetInsets(5, 5, 5, 5);

	AddChild(groupView);

	UpdateView(MARGIN_CHANGED);
}
示例#20
0
void SectionViewWidget::mousePressEvent(QMouseEvent *event)
{
	if(!m_pSailSection) return;
	SailDlg *pSailDlg = (SailDlg*)m_pSailDlg;
	QPoint point = event->pos();
	CVector Real = MousetoReal(point);
//	Real.z = m_pSailSection->m_Position.z;

	// get a reference for mouse movements
	m_PointDown.rx() = point.x();
	m_PointDown.ry() = point.y();

	if(m_bZoomIn && rect().contains(point))
	{
		m_ZoomRect.setTopLeft(point);
		m_ZoomRect.setBottomRight(point);
	}
	else if(!m_bZoomIn && (event->buttons() & Qt::LeftButton))
	{
		if (event->modifiers() & Qt::ShiftModifier)
		{
			//shift --> inserts a point
			OnInsertCtrlPt();
		}
		else if (event->modifiers() & Qt::ControlModifier)
		{
			//Ctrl --> removes the point
			OnRemoveCtrlPt();
		}
		else if(m_pSailSection && m_pSail->IsNURBSSail())
		{
			//Selects the point
			m_pSailSection->m_iSelect = m_pSailSection->IsPoint(Real, m_Scale/m_RefScale);
			pSailDlg->m_pctrlPointTable->selectRow(m_pSailSection->m_iSelect);

			NURBSSail *pNSail = (NURBSSail*)m_pSail;
			if(pNSail->m_bAlignedLE)
			{
				if(m_pSailSection==pNSail->m_oaSection[1] && m_pSailSection->m_iSelect==0)
					m_pSailSection->m_iSelect = -1;
			}

			if (m_pSailSection->m_iSelect>=0)
			{
//					TakePicture();
			}

			if(m_pSailSection->m_iSelect ==-10)
			{
				setCursor(m_hcMove);
				m_bTrans = true;
			}
		}
		else
		{
			setCursor(m_hcMove);
			m_bTrans = true;
		}
	}
	UpdateView();
}
示例#21
0
void XSilChessWindow::HandleCallbackOrEvent(Widget widget,
                                            XmAnyCallbackStruct * cbs,
                                            XEvent * event)
{
	XGCValues gcval;
	const char * file_name;
	XmString xms;
	char tmp[512];
	int i;

	if (widget==BFileLoad) {
		XtUnmanageChild(LoadDialog);
		XmFileSelectionDoSearch(LoadDialog,NULL);
		XtManageChild(LoadDialog);
	}
	else if (widget==BFileSave) {
		XtUnmanageChild(SaveDialog);
		XmFileSelectionDoSearch(SaveDialog,NULL);
		XtManageChild(SaveDialog);
	}
	else if (widget==BFileExit) {
		exit(0);
	}
	else if (widget==BGameNew) {
		AbortSearching=true;
		HintWanted=false;
		HintValid=false;
		Machine->StartNewGame();
		RT.SetWorld(Machine);
		UpdateStatusBar();
		UpdateMovesList();
		UpdateView();
	}
	else if (widget==BGameFlip) {
		AbortSearching=true;
		HintWanted=false;
		HintValid=false;
		Machine->SetHumanWhite(!Machine->IsHumanWhite());
		RT.SetWorld(Machine);
		UpdateStatusBar();
		UpdateView();
	}
	else if (widget==BGameUndo) {
		AbortSearching=true;
		HintWanted=false;
		HintValid=false;
		Machine->UndoMove();
		if (!Machine->IsHumanOn()) Machine->UndoMove();
		RT.SetWorld(Machine);
		UpdateStatusBar();
		UpdateMovesList();
		UpdateView();
	}
	else if (widget==BGameList) {
		XtUnmanageChild(ListDialog);
		XtManageChild(ListDialog);
	}
	else if (widget==LoadDialog) {
		AbortSearching=true;
		HintWanted=false;
		HintValid=false;
		file_name=XmTextGetString(
			XmFileSelectionBoxGetChild(widget,XmDIALOG_TEXT)
		);
		if (!Machine->Load(file_name)) {
			XtUnmanageChild(ErrorBox);
			sprintf(tmp,"Failed to load '%s'",file_name);
			xms=XmStringCreateSimple(tmp);
			XtVaSetValues(ErrorBox,XmNmessageString,xms,(char*)NULL);
			XmStringFree(xms);
			XtManageChild(ErrorBox);
		}
		RT.SetWorld(Machine);
		UpdateStatusBar();
		UpdateMovesList();
		UpdateView();
		UpdateDepthMenu();
	}
	else if (widget==SaveDialog) {
		file_name=XmTextGetString(
			XmFileSelectionBoxGetChild(widget,XmDIALOG_TEXT)
		);
		if (access(file_name,F_OK)!=-1) {
			XtUnmanageChild(OverwriteDialog);
			sprintf(tmp,"OK to overwrite '%s'?",file_name);
			xms=XmStringCreateSimple(tmp);
			XtVaSetValues(OverwriteDialog,XmNmessageString,xms,(char*)NULL);
			XmStringFree(xms);
			XtManageChild(OverwriteDialog);
			strcpy(OverwriteFile,file_name);
		}
		else if (!Machine->Save(file_name)) {
			XtUnmanageChild(ErrorBox);
			sprintf(tmp,"Failed to save '%s'",file_name);
			xms=XmStringCreateSimple(tmp);
			XtVaSetValues(ErrorBox,XmNmessageString,xms,(char*)NULL);
			XmStringFree(xms);
			XtManageChild(ErrorBox);
		}
	}
	else if (widget==OverwriteDialog) {
		file_name=OverwriteFile;
		if (!Machine->Save(file_name)) {
			XtUnmanageChild(ErrorBox);
			sprintf(tmp,"Failed to save '%s'",file_name);
			xms=XmStringCreateSimple(tmp);
			XtVaSetValues(ErrorBox,XmNmessageString,xms,(char*)NULL);
			XmStringFree(xms);
			XtManageChild(ErrorBox);
		}
	}
	else if (widget==ViewArea) {
		if (cbs!=NULL && cbs->reason==XmCR_EXPOSE &&
		    cbs->event && cbs->event->xexpose.count==0) {
			UpdateView();
		}
		else if (cbs!=NULL && cbs->reason==XmCR_RESIZE) {
			XtVaGetValues(ViewArea,XmNwidth,&ViewWidth,(char*)NULL);
			XtVaGetValues(ViewArea,XmNheight,&ViewHeight,(char*)NULL);
			RT.SetViewSize(ViewWidth,ViewHeight);
			UpdateView();
		}
		else if (event!=NULL && event->type==ButtonPress) {
			MousePress(event->xbutton.x,event->xbutton.y);
		}
		else if (event!=NULL && event->type==MapNotify && !ViewWin) {
			ViewWin=XtWindow(ViewArea);
			ViewGC=XtGetGC(ViewArea,0,&gcval);
		}
	}
	else if (widget==BCompHint) {
		AbortSearching=true;
		HintWanted=true;
		HintValid=false;
		UpdateStatusBar();
	}
	else if (widget==BHelpAbout) {
		XtUnmanageChild(AboutDialog);
		XtManageChild(AboutDialog);
	}
	else if (widget==LDClose) {
		XtUnmanageChild(ListDialog);
	}
	else {
		for (i=0; i<=SilChessMachine::MAX_SEARCH_DEPTH; i++) {
			if (widget==BDepth[i] && cbs!=NULL) {
				if (((XmToggleButtonCallbackStruct*)cbs)->set) {
					AbortSearching=true;
					Machine->SetSearchDepth(i);
					UpdateStatusBar();
				}
			}
		}
	}
	do {
		DoPainting();
		DoSearching();
	} while(NeedPainting && !IsPainting && ViewWin);
}
示例#22
0
void SectionViewWidget::mouseMoveEvent(QMouseEvent *event)
{
	if(!m_pSailSection) return;
	if(!hasFocus()) setFocus();
	QPoint point = event->pos();
	m_MousePos = MousetoReal(point);
//	m_MousePos.z = m_pSailSection->m_Position.z;
	QRect CltRect = rect();

//	bool bCtrl = (event->modifiers() & Qt::ControlModifier) ;

	if(m_bZoomIn && (event->buttons() & Qt::LeftButton))
	{
		// we're zooming in using the rectangle method
		m_ZoomRect.setBottomRight(point);
		UpdateView();
		return;
	}
	else if(CltRect.contains(point) && (event->buttons() & Qt::LeftButton) && m_bTrans)
	{
		//translate
		m_ptOffset.rx() += point.x() - m_PointDown.x();
		m_ptOffset.ry() += point.y() - m_PointDown.y();
		m_ViewportTrans.rx() += point.x() - m_PointDown.x();
		m_ViewportTrans.ry() += point.y() - m_PointDown.y();

		m_PointDown.rx() = point.x();
		m_PointDown.ry() = point.y();
//		m_MousePos = Real;

		UpdateView();
		return;
	}

	if (event->buttons() & Qt::LeftButton && !m_bZoomIn)
	{
		// user is dragging the point
		if(CltRect.contains(point)  && m_pSail->IsNURBSSail())
		{
			int n = m_pSailSection->m_iSelect;

			if (n>=0 && n<m_pSailSection->m_CtrlPoint.size())
			{
//				if(n==1) m_MousePos.x = 0.0;// we can't move point 1 for vertical slope
				m_pSailSection->m_CtrlPoint[n].x = m_MousePos.x;
				m_pSailSection->m_CtrlPoint[n].y = qMax(m_MousePos.y, 0.0);
				m_pSailSection->m_CtrlPoint[n].z = m_MousePos.z;

				NURBSSail *pNSail = (NURBSSail*)m_pSail;
				if(pNSail->m_bAlignedLE && n==0)
				{
					// keep middle point aligned
					pNSail->m_oaSection[1]->m_CtrlPoint[0].x  = (pNSail->m_oaSection[0]->m_CtrlPoint[0].x + pNSail->m_oaSection[2]->m_CtrlPoint[0].x)/2.0;
					pNSail->m_oaSection[1]->m_CtrlPoint[0].y  = (pNSail->m_oaSection[0]->m_CtrlPoint[0].y + pNSail->m_oaSection[2]->m_CtrlPoint[0].y)/2.0;
				}

				Spline::s_bChanged = true;
			}
		}
	}
	else if ((event->buttons() & Qt::MidButton))
	{
		// user is zooming with mouse button down rather than with wheel
		if(CltRect.contains(point))
		{
			double scale = m_Scale;

			if(!m_bZoomYOnly)
			{
				if (m_bXDown)
				{
					if(point.y()-m_PointDown.y()>0)
					{
						m_Scale  *= 1.02;
						m_ScaleY /= 1.02;
					}
					else
					{
						m_Scale  /= 1.02;
						m_ScaleY *= 1.02;
					}
				}
				else if (m_bYDown)
				{
					if(point.y()-m_PointDown.y()>0) m_ScaleY *= 1.02;
					else                            m_ScaleY /= 1.02;
				}
				else
				{
					if(point.y()-m_PointDown.y()>0) m_Scale *= 1.02;
					else		                    m_Scale /= 1.02;
				}
			}
			else
			{
				if(point.y()-m_PointDown.y()>0) m_ScaleY *= 1.02;
				else                            m_ScaleY /= 1.02;
			}

			m_PointDown = point;

			int a = (int)((CltRect.right()+CltRect.left())/2);
			m_ptOffset.rx() = a + (int)((m_ptOffset.x()-a)*m_Scale/scale);
		}
	}
	else if(!m_bZoomIn)
	{
		//not zooming, check if mouse passes over control point and highlight
		int n = m_pSailSection->IsPoint(m_MousePos, m_Scale/m_RefScale);
		if (n>=0 && n<m_pSailSection->m_CtrlPoint.size())
		{
			m_pSailSection->m_iHighlight = n;
		}
		else if(m_pSailSection->m_iHighlight>=0)
		{
			m_pSailSection->m_iHighlight = -10;
		}
	}
	UpdateView();
}
示例#23
0
void __fastcall TfrmEditLightAnim::ebDeleteKeyClick(TObject *Sender)
{
	m_CurrentItem->DeleteKey(sePointer->Value);
    UpdateView();
    OnModified();
}
示例#24
0
void SectionViewWidget::mouseReleaseEvent(QMouseEvent *event)
{
	m_bTrans = false;
	QPoint point = event->pos();
	QRect CltRect = rect();
	if(m_bZoomIn && CltRect.contains(point))
	{
		m_ZoomRect.setBottomRight(point);
		QRect ZRect = m_ZoomRect.normalized();

		if(!ZRect.isEmpty())
		{
			m_ZoomRect = ZRect;

			double ZoomFactor = qMin((double)CltRect.width()  / (double)m_ZoomRect.width() ,
									 (double)CltRect.height() / (double)m_ZoomRect.height());

			double newScale = qMin(ZoomFactor*m_Scale, 32.0*m_RefScale);

			ZoomFactor = qMin(ZoomFactor, newScale/m_Scale);

			m_Scale = ZoomFactor*m_Scale;
			int a = (int)((CltRect.right() + CltRect.left())/2);
			int b = (int)((CltRect.top()   + CltRect.bottom())/2);

			int aZoom = (int)((m_ZoomRect.right() + m_ZoomRect.left())/2);
			int bZoom = (int)((m_ZoomRect.top()   + m_ZoomRect.bottom())/2);

			//translate view
			m_ptOffset.rx() += (a - aZoom);
			m_ptOffset.ry() += (b - bZoom);
			//scale view
			m_ptOffset.rx() = (int)(ZoomFactor * (m_ptOffset.x()-a)+a);
			m_ptOffset.ry() = (int)(ZoomFactor * (m_ptOffset.y()-b)+b);

//			m_ZoomRect.setBottomRight(m_ZoomRect.topLeft());
			m_ZoomRect.setRight(m_ZoomRect.left()-1);
		}
		else
		{
			m_ZoomRect.setBottomRight(m_ZoomRect.topLeft());
			ReleaseZoom();
		}
	}
	else if(m_bZoomIn && !CltRect.contains(point))
	{
		ReleaseZoom();
	}
	else
	{
		//The user has finished dragging something
		if (m_pSailSection->m_iSelect>=0) TakePicture();

		SailDlg *pSailDlg = (SailDlg*)m_pSailDlg;
		pSailDlg->FillPointTable();
		m_pSail->SplineSurface();
		pSailDlg->UpdateSailView();
	}

	setCursor(m_hcCross);

	UpdateView();
}
示例#25
0
	void cCamera::UpdateCamera()
	{
		UpdateView();
		UpdateProjection();
	}
示例#26
0
void SectionViewWidget::OnCurrentSectionOnly()
{
	s_bCurrentOnly = !s_bCurrentOnly;
	m_pCurrentOnly->setChecked(s_bCurrentOnly);
	UpdateView();
}
void CTranVideoTitleBar::OnPaint()
{
    CPaintDC dc(this); // device context for painting
	CVideoPane* pVideoPane = dynamic_cast<CVideoPane*>(m_pVideoPane);
	CHECK_POINTER_VOID(pVideoPane);
    CRect rect;
	pVideoPane->GetClientRect(&rect);

	const long ICON_WIDTH = 23;
	long lWidth = ICON_WIDTH;
	long lRight = rect.right;
	m_StaticDevName.MoveWindow(1,1,lRight - 70, 22);
	m_StaticDevName.ShowWindow(SW_SHOW);

    m_btnOFF.MoveWindow(lRight - lWidth, 1, 22, 22);
    m_btnOFF.ShowWindow(SW_SHOW);
	lWidth += ICON_WIDTH;
    m_btnInf.MoveWindow(lRight - lWidth, 1, 22, 22);
    m_btnInf.ShowWindow(SW_SHOW);

	if(TVWALL_STATUS_START==m_ulTVWallStatus)
	{
		lWidth += ICON_WIDTH;
		m_btnTVWallHandling.MoveWindow(lRight - lWidth, 3, 16, 16);
		m_btnTVWallHandling.ShowWindow(SW_SHOW);
		m_btnTVWallOK.ShowWindow(SW_HIDE);
		m_btnTVWallVideoBroken.ShowWindow(SW_HIDE);
        m_btnTvWallReconnect.ShowWindow(SW_HIDE);
	}
    if(TVWALL_STATUS_DEC_DISCONN==m_ulTVWallStatus)
    {
        lWidth += ICON_WIDTH;
        m_btnTvWallReconnect.MoveWindow(lRight - lWidth, 3, 16, 16);
        m_btnTvWallReconnect.ShowWindow(SW_SHOW);
        m_btnTVWallOK.ShowWindow(SW_HIDE);
        m_btnTVWallVideoBroken.ShowWindow(SW_HIDE);
    }
	else if(TVWALL_STATUS_PLAY==m_ulTVWallStatus)
	{
		lWidth += ICON_WIDTH;
		m_btnTVWallOK.MoveWindow(lRight - lWidth, 3, 16, 16);
		m_btnTVWallOK.ShowWindow(SW_SHOW);
		m_btnTVWallHandling.ShowWindow(SW_HIDE);
		m_btnTVWallVideoBroken.ShowWindow(SW_HIDE);
        m_btnTvWallReconnect.ShowWindow(SW_HIDE);
	}
	else if(TVWALL_STATUS_VIDEO_BROKEN==m_ulTVWallStatus)
	{
		lWidth += ICON_WIDTH;
		m_btnTVWallVideoBroken.MoveWindow(lRight - lWidth, 3, 16, 16);
		m_btnTVWallVideoBroken.ShowWindow(SW_SHOW);
		m_btnTVWallOK.ShowWindow(SW_HIDE);
		m_btnTVWallHandling.ShowWindow(SW_HIDE);
	}
	else
	{
		m_btnTVWallOK.ShowWindow(SW_HIDE);
		m_btnTVWallHandling.ShowWindow(SW_HIDE);
		m_btnTVWallVideoBroken.ShowWindow(SW_HIDE);
        m_btnTvWallReconnect.ShowWindow(SW_HIDE);
	}

	if (1 == m_ulTurnCruiseStatus)
	{
		lWidth += ICON_WIDTH;
		m_btnTurnCruiseStatus.MoveWindow(lRight - lWidth, 3, 16, 16);
		m_btnTurnCruiseStatus.ShowWindow(SW_SHOW);
	}
	else
	{
		m_btnTurnCruiseStatus.ShowWindow(SW_HIDE);
	}

	if (1 == m_ulSingleFrameStatus)
	{
		lWidth += ICON_WIDTH;
		m_btnSingleFrameStatus.MoveWindow(lRight - lWidth, 3, 16, 16);
		m_btnSingleFrameStatus.ShowWindow(SW_SHOW);
	}
	else
	{
		m_btnSingleFrameStatus.ShowWindow(SW_HIDE);
	}

	if (1 == m_ulAlarmStatus)
	{
		lWidth += ICON_WIDTH;
		m_btnAlarmStatus.MoveWindow(lRight - lWidth, 3, 16, 16);
		m_btnAlarmStatus.ShowWindow(SW_SHOW);
	}
	else
	{
		m_btnAlarmStatus.ShowWindow(SW_HIDE);
	}

	if (1 == m_ulRecordStatus)
	{
		lWidth += ICON_WIDTH;
		m_btnRecordStatus.MoveWindow(lRight - lWidth, 3, 16, 16);
		m_btnRecordStatus.ShowWindow(SW_SHOW);
	}
	else
	{
		m_btnRecordStatus.ShowWindow(SW_HIDE);
	}

	if (1 == m_ulCruiseTrackStatus)
	{
		lWidth += ICON_WIDTH;
		m_btnCruiseTrackStatus.MoveWindow(lRight - lWidth, 3, 16, 16);
		m_btnCruiseTrackStatus.ShowWindow(SW_SHOW);
	}
	else
	{
		m_btnCruiseTrackStatus.ShowWindow(SW_HIDE);
	}

	if (-1 == m_ulWatermarkStutus)
	{
		m_btnWaterMakr.ShowWindow(SW_HIDE);
	}
	else
	{
		lWidth += ICON_WIDTH;
		m_btnWaterMakr.MoveWindow(lRight - lWidth, 3, 16, 16);
		m_btnWaterMakr.ShowWindow(SW_SHOW);
	}
	
    UpdateView();
}
示例#28
0
void BaseCamera::SetPosition(const Vector3& pos)
{
    m_position = pos;
    m_world.SetTranslation(m_position);
    UpdateView();
}
void WorkspaceBrowserF::OnViewScope(wxCommandEvent& event)
{
    m_BrowserOptions.displayFilter = (BrowserDisplayFilter)event.GetSelection();
    UpdateView();
}
示例#30
0
void ThreeDWidget::slotFloorCalibrationSuccess()
{
	emit signalFloorCalibrationSuccess();
	UpdateView();
}