Example #1
0
 public static Form CreateNewFormCanvas(
     int w, int h,
     InnerViewportKind internalViewportKind,
     out GraphicsViewRoot canvasViewport)
 {
     return(CreateNewFormCanvas(0, 0, w, h, internalViewportKind, out canvasViewport));
 }
Example #2
0
        static void CreateNewFormCanvas(
            Form form1,
            MyRootGraphic myRootGfx,
            InnerViewportKind internalViewportKind,
            out LayoutFarm.UI.UISurfaceViewportControl canvasViewport)
        {
            var       innerViewport        = canvasViewport = new LayoutFarm.UI.UISurfaceViewportControl();
            Rectangle screenClientAreaRect = Conv.ToRect(Screen.PrimaryScreen.WorkingArea);

            canvasViewport.InitRootGraphics(myRootGfx, myRootGfx.TopWinEventPortal, internalViewportKind);
            canvasViewport.Bounds =
                new System.Drawing.Rectangle(0, 0,
                                             screenClientAreaRect.Width,
                                             screenClientAreaRect.Height);

            ////----------------------
            //form1.Controls.Add(canvasViewport);
            ////----------------------
            MakeFormCanvas(form1, canvasViewport);
            form1.SizeChanged += (s, e) =>
            {
                if (form1.WindowState == FormWindowState.Maximized)
                {
                    Screen currentScreen = GetScreenFromX(form1.Left);
                    //make full screen ?
                    if (innerViewport != null)
                    {
                        innerViewport.Size = currentScreen.WorkingArea.Size;
                    }
                }
            };
        }
 public static Form CreateNewFormCanvas(
     int w, int h,
     InnerViewportKind internalViewportKind,
     out UISurfaceViewportControl canvasViewport)
 {
     return(CreateNewFormCanvas(0, 0, w, h, internalViewportKind, out canvasViewport));
 }
Example #4
0
        public static Form CreateNewFormCanvas(
            int xpos, int ypos,
            int w, int h,
            InnerViewportKind internalViewportKind,
            out GraphicsViewRoot canvasViewport)
        {
            //create new form with new user control
            Form form1 = new Form();

            CreateCanvasControlOnExistingControl(
                form1,
                xpos, ypos, w, h, internalViewportKind,
                out canvasViewport);

            //----------------------
            MakeFormCanvas(form1, canvasViewport);

            GraphicsViewRoot innerViewport = canvasViewport;

            form1.SizeChanged += (s, e) =>
            {
                if (form1.WindowState == FormWindowState.Maximized)
                {
                    Screen currentScreen = GetScreenFromX(form1.Left);
                    //make full screen ?
                    if (innerViewport != null)
                    {
                        var size = Screen.PrimaryScreen.WorkingArea.Size;
                        innerViewport.SetSize(size.Width, size.Height);
                    }
                }
            };
            //----------------------
            return(form1);
        }
Example #5
0
        public static void RunSpecificDemo(LayoutFarm.DemoBase demo)
        {
            //-------------------------------
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            ////-------------------------------
            //1. select view port kind

            InnerViewportKind innerViewportKind = InnerViewportKind.GdiPlus;
            var workingArea = Screen.PrimaryScreen.WorkingArea;

            var formCanvas = FormCanvasHelper.CreateNewFormCanvas(
                workingArea.Width,
                workingArea.Height,
                innerViewportKind,
                out _latestviewport);

            formCanvas.Text = "PixelFarm" + innerViewportKind;

            demo.StartDemo(new LayoutFarm.SampleViewport(_latestviewport));
            _latestviewport.TopDownRecalculateContent();
            //==================================================
            _latestviewport.PaintMe();


            //_latestviewport.PaintMe();

            //formCanvas.WindowState = FormWindowState.Maximized;
            formCanvas.Show();
            //got specfic example
            Application.Run(formCanvas);
        }
Example #6
0
        public static Form CreateNewFormCanvas(
            MyRootGraphic myRootGfx,
            InnerViewportKind internalViewportKind,
            out UISurfaceViewportControl canvasViewport)
        {
            Form      form1                = new Form();
            var       innerViewport        = canvasViewport = new UISurfaceViewportControl();
            Rectangle screenClientAreaRect = new Rectangle(0, 0, 800, 600); //Conv.ToRect(Screen.PrimaryScreen.WorkingArea);

            canvasViewport.InitRootGraphics(myRootGfx, myRootGfx.TopWinEventPortal, internalViewportKind);
            canvasViewport.Bounds =
                new Rectangle(0, 0,
                              screenClientAreaRect.Width,
                              screenClientAreaRect.Height);
            //----------------------
            form1.Controls.Add(canvasViewport);
            //----------------------
            MakeFormCanvas(form1, canvasViewport);

            //TODO: review here
            //form1.SizeChanged += (s, e) =>
            //{
            //    if (form1.WindowState == FormWindowState.Maximized)
            //    {
            //        Screen currentScreen = GetScreenFromX(form1.Left);
            //        //make full screen ?
            //        if (innerViewport != null)
            //        {
            //            innerViewport.Size = currentScreen.WorkingArea.Size;
            //        }
            //    }
            //};
            //----------------------
            return(form1);
        }
        public static Form CreateNewFormCanvas(
            int xpos, int ypos,
            int w, int h,
            InnerViewportKind internalViewportKind,
            out UISurfaceViewportControl canvasViewport)
        {
            //create new form with new user control
            Form form1 = new Form();

            CreateCanvasControlOnExistingControl(
                form1,
                xpos, ypos, w, h, internalViewportKind,
                out canvasViewport);

            //----------------------
            MakeFormCanvas(form1, canvasViewport);

            UISurfaceViewportControl innerViewport = canvasViewport;

            form1.SizeChanged += (s, e) =>
            {
                if (form1.WindowState == FormWindowState.Maximized)
                {
                    Screen currentScreen = GetScreenFromX(form1.Left);
                    //make full screen ?
                    if (innerViewport != null)
                    {
                        innerViewport.Size = currentScreen.WorkingArea.Size;
                    }
                }
            };
            //----------------------
            return(form1);
        }
Example #8
0
        static void SetUpSoftwareRendererOverGLSurface(
            LayoutFarm.AppHostConfig config,
            IGpuOpenGLSurfaceView myNativeWindow,
            PixelFarm.DrawingGL.GLPainterCore pcx,
            PixelFarm.DrawingGL.GLPainter glPainter,
            InnerViewportKind innerViewPortKind)
        {
            //TODO: review here
            //Temp:
            //

            var surfaceControl = myNativeWindow;

            surfaceControl.MakeCurrent();

            CpuBlitGLESUIElement _cpuBlitUIElem = (innerViewPortKind == InnerViewportKind.GdiPlusOnGLES) ?
                                                  new GdiOnGLESUIElement(surfaceControl.Width, surfaceControl.Height) :
                                                  new CpuBlitGLESUIElement(surfaceControl.Width, surfaceControl.Height);

            //optional***
            //_bridgeUI.SetUpdateCpuBlitSurfaceDelegate((p, area) =>
            //{
            //    _client.DrawToThisCanvas(_bridgeUI.GetDrawBoard(), area);
            //});

            LayoutFarm.RootGraphic rootGfx = config.RootGfx;
            _cpuBlitUIElem.CreatePrimaryRenderElement(pcx, glPainter, rootGfx);

            //*****
            LayoutFarm.RenderBoxBase renderE = (LayoutFarm.RenderBoxBase)_cpuBlitUIElem.GetPrimaryRenderElement();
            rootGfx.AddChild(renderE);
            rootGfx.SetPrimaryContainerElement(renderE);
            //***
        }
        public static void CreateConvasControlOnExistingControl(
            Control landingControl,
            int xpos, int ypos,
            int w, int h,
            InnerViewportKind internalViewportKind,
            out LayoutFarm.UI.UISurfaceViewportControl canvasViewport)
        {
            //1. init
            InitWinform();
            IFontLoader fontLoader = s_fontstore;

            //2.
            PixelFarm.Drawing.ITextService ifont = null;
            switch (internalViewportKind)
            {
            default:
                ifont = PixelFarm.Drawing.WinGdi.WinGdiPlusPlatform.GetIFonts();
                //ifont = new OpenFontTextService();
                break;

            case InnerViewportKind.GL:
                ifont = new OpenFontTextService();
                break;
            }

            PixelFarm.Drawing.WinGdi.WinGdiPlusPlatform.SetFontLoader(fontLoader);

            //

            //---------------------------------------------------------------------------

            MyRootGraphic myRootGfx = new MyRootGraphic(
                w, h,
                ifont
                );

            //---------------------------------------------------------------------------

            var       innerViewport        = canvasViewport = new LayoutFarm.UI.UISurfaceViewportControl();
            Rectangle screenClientAreaRect = Conv.ToRect(Screen.PrimaryScreen.WorkingArea);

            canvasViewport.InitRootGraphics(myRootGfx, myRootGfx.TopWinEventPortal, internalViewportKind);
            canvasViewport.Bounds =
                new System.Drawing.Rectangle(xpos, ypos,
                                             screenClientAreaRect.Width,
                                             screenClientAreaRect.Height);

            landingControl.Controls.Add(canvasViewport);
            //
            Form ownerForm = landingControl.FindForm();

            if (ownerForm != null)
            {
                ownerForm.FormClosing += (s, e) =>
                {
                    innerViewport.Close();
                };
            }
        }
        PixelFarm.Drawing.DrawBoard CreateSoftwareDrawBoard(int width, int height, InnerViewportKind innerViewportKind)
        {
            PixelFarm.Drawing.WinGdi.GdiPlusRenderSurface gdiRenderSurface = new PixelFarm.Drawing.WinGdi.GdiPlusRenderSurface(width, height);
            var drawBoard = new PixelFarm.Drawing.WinGdi.GdiPlusDrawBoard(gdiRenderSurface);

            drawBoard.CurrentFont = new PixelFarm.Drawing.RequestFont("Tahoma", 10);
            return(drawBoard);
        }
Example #11
0
        PixelFarm.Drawing.DrawBoard CreateSoftwareDrawBoard(int width, int height, InnerViewportKind innerViewportKind)
        {
            //TODO: use Agg
            return(null);
            //PixelFarm.Drawing.WinGdi.GdiPlusRenderSurface gdiRenderSurface = new PixelFarm.Drawing.WinGdi.GdiPlusRenderSurface(width, height);
            //var drawBoard = new PixelFarm.Drawing.WinGdi.GdiPlusDrawBoard(gdiRenderSurface);

            //return drawBoard;
        }
        public void InitRootGraphics(
            RootGraphic rootgfx,
            ITopWindowEventRoot topWinEventRoot,
            InnerViewportKind innerViewportKind)
        {
            //1.
            this.rootgfx           = rootgfx;
            this.topWinEventRoot   = topWinEventRoot;
            this.innerViewportKind = innerViewportKind;
            switch (innerViewportKind)
            {
            case InnerViewportKind.GL:
            {
                ////temp not suppport
                //PixelFarm.Drawing.DrawingGL.CanvasGLPortal.Start();
                bridge = new OpenGL.MyTopWindowBridgeOpenGL(rootgfx, topWinEventRoot);
                bridge.BindWindowControl(this);
                //var view = new OpenGL.GpuOpenGLSurfaceView();
                //view.Width = 800;
                //view.Height = 600;
                ////view.Dock = DockStyle.Fill;
                //this.Controls.Add(view);
                ////---------------------------------------
                //view.Bind(bridge);
                this.winBridge = bridge;
            }
            break;

            case InnerViewportKind.Skia:
            {
                //skiasharp ***
                var bridge = new Skia.MyTopWindowBridgeSkia(rootgfx, topWinEventRoot);
                //var view = new CpuSurfaceView();
                //view.Dock = DockStyle.Fill;
                //this.Controls.Add(view);
                ////---------------------------------------
                //view.Bind(bridge);
                this.winBridge = bridge;
            }
            break;

            case InnerViewportKind.GdiPlus:
            default:
            {
                throw new NotSupportedException();
                //var bridge = new GdiPlus.MyTopWindowBridgeGdiPlus(rootgfx, topWinEventRoot);
                //var view = new CpuSurfaceView();
                //view.Dock = DockStyle.Fill;
                //this.Controls.Add(view);
                ////---------------------------------------
                //view.Bind(bridge);
                //this.winBridge = bridge;
            }
            break;
            }
        }
        public void InitRootGraphics(
            RootGraphic rootgfx,
            ITopWindowEventRoot topWinEventRoot,
            InnerViewportKind innerViewportKind)
        {
            //1.
            this.rootgfx = rootgfx;
            this.topWinEventRoot = topWinEventRoot;
            this.innerViewportKind = innerViewportKind;
            switch (innerViewportKind)
            {
                case InnerViewportKind.GL:
                    {
                        //temp not suppport 

                        throw new NotSupportedException();
                        //PixelFarm.Drawing.DrawingGL.CanvasGLPortal.Start();

                        //var bridge = new OpenGL.MyTopWindowBridgeOpenGL(rootgfx, topWinEventRoot);
                        //var view = new OpenGL.GpuOpenGLSurfaceView();
                        //view.Width = 800;
                        //view.Height = 600;
                        ////view.Dock = DockStyle.Fill;
                        //this.Controls.Add(view);
                        ////--------------------------------------- 
                        //view.Bind(bridge); 
                        //this.winBridge = bridge; 
                    }
                    break;
                case InnerViewportKind.Skia:
                    {
                        //skiasharp ***
                        var bridge = new Skia.MyTopWindowBridgeSkia(rootgfx, topWinEventRoot);
                        var view = new CpuSurfaceView();
                        view.Dock = DockStyle.Fill;
                        this.Controls.Add(view);
                        //--------------------------------------- 
                        view.Bind(bridge);
                        this.winBridge = bridge;
                    }
                    break;
                case InnerViewportKind.GdiPlus:
                default:
                    {
                        var bridge = new GdiPlus.MyTopWindowBridgeGdiPlus(rootgfx, topWinEventRoot);
                        var view = new CpuSurfaceView();
                        view.Dock = DockStyle.Fill;
                        this.Controls.Add(view);
                        //--------------------------------------- 
                        view.Bind(bridge);
                        this.winBridge = bridge;
                    }
                    break;
            }
        }
Example #14
0
        public static Form RunSpecificDemo(LayoutFarm.App demo,
                                           LayoutFarm.AppHost appHost,
                                           InnerViewportKind innerViewportKind = InnerViewportKind.GdiPlusOnGLES)
        {
            System.Drawing.Rectangle workingArea = Screen.PrimaryScreen.WorkingArea;
            Form formCanvas = LayoutFarm.UI.FormCanvasHelper.CreateNewFormCanvas(
                workingArea.Width,
                workingArea.Height,
                innerViewportKind,
                out GraphicsViewRoot viewroot);

#if DEBUG
            formCanvas.Text = innerViewportKind.ToString();
#endif


            formCanvas.FormClosed += (s, e) =>
            {
                demo.OnClosing();
                demo.OnClosed();
            };


            LayoutFarm.AppHostConfig config = new LayoutFarm.AppHostConfig();
            YourImplementation.UISurfaceViewportSetupHelper.SetUISurfaceViewportControl(config, viewroot);
            appHost.Setup(config);

            appHost.StartApp(demo);
            //
            //viewroot.TopDownRecalculateContent();
            //==================================================
            viewroot.PaintToOutputWindow();

            //formCanvas.WindowState = FormWindowState.Maximized;
            formCanvas.Show();
#if DEBUG
            if (dbugShowLayoutInspectorForm)
            {
                LayoutInspectorUtils.ShowFormLayoutInspector(viewroot);
            }
#endif

            //Application.Run(formCanvas);

            formCanvas.Show();
            return(formCanvas);
        }
Example #15
0
        private void cmdShowEmbededViewport_Click(object sender, EventArgs e)
        {
            Form simpleForm = new Form();

            simpleForm.Text        = "SimpleForm2";
            simpleForm.WindowState = FormWindowState.Maximized;
            Rectangle screenClientAreaRect = Screen.PrimaryScreen.WorkingArea;

            MyWinFormsControl actualWinUI = new MyWinFormsControl();

            simpleForm.Controls.Add(actualWinUI);


            InnerViewportKind internalViewportKind = InnerViewportKind.GdiPlus;


            int w = 800;
            int h = 600;


            var textService = new Typography.Text.OpenFontTextService();

            Typography.Text.TextServiceClient client = textService.CreateNewServiceClient();
            MyRootGraphic myRootGfx = new MyRootGraphic(w, h);

            var viewport = new GraphicsViewRoot(screenClientAreaRect.Width, screenClientAreaRect.Height);

            AbstractTopWindowBridge bridge = GetTopWindowBridge(
                internalViewportKind,
                myRootGfx,
                myRootGfx.TopWinEventPortal);

            IGpuOpenGLSurfaceView viewAbstraction = actualWinUI.CreateWindowWrapper(bridge);

            var rootgfx = new MyRootGraphic(w, h);

            viewport.InitRootGraphics(rootgfx,
                                      rootgfx.TopWinEventPortal,
                                      InnerViewportKind.GdiPlus,
                                      viewAbstraction,
                                      bridge);


            viewport.PaintToOutputWindow();
            simpleForm.Show();
            ShowFormLayoutInspector(viewport);
        }
        public void InitRootGraphics(
            RootGraphic rootgfx,
            ITopWindowEventRoot topWinEventRoot,
            InnerViewportKind innerViewportKind)
        {
            //1.
            this.rootgfx           = rootgfx;
            this.topWinEventRoot   = topWinEventRoot;
            this.innerViewportKind = innerViewportKind;

            switch (innerViewportKind)
            {
            case InnerViewportKind.GL:
            {
                PixelFarm.Drawing.DrawingGL.CanvasGLPortal.Start();

                var bridge = new OpenGL.MyTopWindowBridgeOpenGL(rootgfx, topWinEventRoot);
                var view   = new OpenGL.GpuOpenGLSurfaceView();
                view.Width  = 800;
                view.Height = 600;
                //view.Dock = DockStyle.Fill;
                this.Controls.Add(view);
                //---------------------------------------
                view.Bind(bridge);

                this.winBridge = bridge;
            } break;

            case InnerViewportKind.GdiPlus:
            default:
            {
                var bridge = new GdiPlus.MyTopWindowBridgeGdiPlus(rootgfx, topWinEventRoot);
                var view   = new GdiPlus.CpuGdiPlusSurfaceView();
                view.Dock = DockStyle.Fill;
                this.Controls.Add(view);
                //---------------------------------------
                view.Bind(bridge);

                this.winBridge = bridge;
            } break;
            }
        }
        /// <summary>
        /// create new UIViewport based on this control's current platform
        /// </summary>
        /// <returns></returns>
        public UISurfaceViewportControl CreateNewOne(int w, int h, InnerViewportKind innerViewportKind)
        {
            //each viewport has its own root graphics

            UISurfaceViewportControl newViewportControl = new UISurfaceViewportControl();

            newViewportControl.Size = new System.Drawing.Size(w, h);
            RootGraphic         newRootGraphic = _rootgfx.CreateNewOne(w, h);
            ITopWindowEventRoot topEventRoot   = null;

            if (newRootGraphic is ITopWindowEventRootProvider)
            {
                topEventRoot = ((ITopWindowEventRootProvider)newRootGraphic).EventRoot;
            }
            newViewportControl.InitRootGraphics(
                newRootGraphic,//new root
                topEventRoot,
                innerViewportKind);
            return(newViewportControl);
        }
Example #18
0
        static AbstractTopWindowBridge GetTopWindowBridge(
            InnerViewportKind innerViewportKind,
            RootGraphic rootgfx,
            ITopWindowEventRoot topWindowEventRoot)
        {
            switch (innerViewportKind)
            {
            default: throw new NotSupportedException();

            case InnerViewportKind.GdiPlusOnGLES:
            case InnerViewportKind.AggOnGLES:
            case InnerViewportKind.GLES:
                return(new OpenGL.MyTopWindowBridgeOpenGL(rootgfx, topWindowEventRoot));

            case InnerViewportKind.PureAgg:
                return(new GdiPlus.MyTopWindowBridgeAgg(rootgfx, topWindowEventRoot));    //bridge to agg

            case InnerViewportKind.GdiPlus:
                return(new GdiPlus.MyTopWindowBridgeGdiPlus(rootgfx, topWindowEventRoot));
            }
        }
Example #19
0
        public static Form RunSpecificDemo(LayoutFarm.App demo, InnerViewportKind innerViewportKind = InnerViewportKind.GdiPlusOnGLES)
        {
            System.Drawing.Rectangle workingArea = Screen.PrimaryScreen.WorkingArea;
            Form formCanvas = FormCanvasHelper.CreateNewFormCanvas(
                workingArea.Width,
                workingArea.Height,
                innerViewportKind,
                out UISurfaceViewportControl latestviewport);

#if DEBUG
            formCanvas.Text = innerViewportKind.ToString();
#endif

            formCanvas.FormClosed += (s, e) =>
            {
                demo.OnClosing();
                demo.OnClosed();
            };

            var appHost = new LayoutFarm.AppHostWinForm(latestviewport);
            appHost.StartApp(demo);
            //
            latestviewport.TopDownRecalculateContent();
            //==================================================
            latestviewport.PaintMe();

            //formCanvas.WindowState = FormWindowState.Maximized;
            formCanvas.Show();
#if DEBUG
            if (dbugShowLayoutInspectorForm)
            {
                LayoutInspectorUtils.ShowFormLayoutInspector(latestviewport);
            }
#endif

            //Application.Run(formCanvas);

            formCanvas.Show();
            return(formCanvas);
        }
Example #20
0
        public static void CreateReadyForm(
            InnerViewportKind innerViewportKind,
            out GraphicsViewRoot viewroot,
            out Form formCanvas)
        {
            //1. select view port kind

            var workingArea = Screen.PrimaryScreen.WorkingArea;

            formCanvas = FormCanvasHelper.CreateNewFormCanvas(
                workingArea.Width,
                workingArea.Height,
                innerViewportKind,
                out viewroot);

            formCanvas.Text = "FormCanvas 1 :" + innerViewportKind;

            viewroot.PaintToOutputWindow();

            formCanvas.WindowState = FormWindowState.Maximized;
            formCanvas.Show();
        }
Example #21
0
        public static void CreateReadyForm(
            out LayoutFarm.UI.UISurfaceViewportControl viewport,
            out Form formCanvas)
        {
            //1. select view port kind
            InnerViewportKind innerViewportKind = InnerViewportKind.GdiPlus;

            var workingArea = Screen.PrimaryScreen.WorkingArea;

            formCanvas = FormCanvasHelper.CreateNewFormCanvas(
                workingArea.Width,
                workingArea.Height,
                innerViewportKind,
                out viewport);

            formCanvas.Text = "FormCanvas 1 :" + innerViewportKind;

            viewport.PaintMe();

            formCanvas.WindowState = FormWindowState.Maximized;
            formCanvas.Show();
        }
Example #22
0
        public static Form CreateNewFormCanvas(
            MyRootGraphic myRootGfx,
            InnerViewportKind internalViewportKind,
            out LayoutFarm.UI.UISurfaceViewportControl canvasViewport)
        {


            Form form1 = new Form();
            var innerViewport = canvasViewport = new LayoutFarm.UI.UISurfaceViewportControl();
            Rectangle screenClientAreaRect = Conv.ToRect(Screen.PrimaryScreen.WorkingArea);

            canvasViewport.InitRootGraphics(myRootGfx, myRootGfx.TopWinEventPortal, internalViewportKind);
            canvasViewport.Bounds =
                new System.Drawing.Rectangle(0, 0,
                    screenClientAreaRect.Width,
                    screenClientAreaRect.Height);
            //---------------------- 
            form1.Controls.Add(canvasViewport);
            //----------------------
            MakeFormCanvas(form1, canvasViewport);

            form1.SizeChanged += (s, e) =>
            {
                if (form1.WindowState == FormWindowState.Maximized)
                {
                    Screen currentScreen = GetScreenFromX(form1.Left);
                    //make full screen ?
                    if (innerViewport != null)
                    {
                        innerViewport.Size = currentScreen.WorkingArea.Size;
                    }
                }
            };
            //----------------------
            return form1;

        }
Example #23
0
        static void CreateNewFormCanvas(
            int w, int h,
            PixelFarm.Forms.Form form1,
            InnerViewportKind internalViewportKind,
            out LayoutFarm.UI.WinNeutral.UISurfaceViewportControl canvasViewport)
        {
            var rootgfx = new MyRootGraphic(
                LayoutFarm.UI.UIPlatformWinNeutral.platform,
                LayoutFarm.UI.UIPlatformWinNeutral.platform.GetIFonts(),
                w, h);
            var innerViewport = canvasViewport = new LayoutFarm.UI.WinNeutral.UISurfaceViewportControl();
            //temp fix
            Rectangle screenClientAreaRect = new Rectangle(0, 0, 800, 600); // Conv.ToRect(Screen.PrimaryScreen.WorkingArea);

            canvasViewport.InitRootGraphics(rootgfx, rootgfx.TopWinEventPortal, internalViewportKind);
            canvasViewport.Bounds =
                new Rectangle(0, 0,
                              screenClientAreaRect.Width,
                              screenClientAreaRect.Height);
            ////----------------------
            //form1.Controls.Add(canvasViewport);
            ////----------------------
            MakeFormCanvas(form1, canvasViewport);
            //form1.SizeChanged += (s, e) =>
            //{
            //    if (form1.WindowState == FormWindowState.Maximized)
            //    {
            //        Screen currentScreen = GetScreenFromX(form1.Left);
            //        //make full screen ?
            //        if (innerViewport != null)
            //        {
            //            innerViewport.Size = currentScreen.WorkingArea.Size;
            //        }
            //    }
            //};
        }
        public void InitRootGraphics(
            RootGraphic rootgfx,
            ITopWindowEventRoot topWinEventRoot,
            InnerViewportKind innerViewportKind)
        {
            //create a proper bridge****

            this.rootgfx           = rootgfx;
            this.topWinEventRoot   = topWinEventRoot;
            this.innerViewportKind = innerViewportKind;
            switch (innerViewportKind)
            {
            case InnerViewportKind.GL:
            {
                //temp not suppport
                //TODO: review here
                //PixelFarm.Drawing.DrawingGL.CanvasGLPortal.Start();

                var bridge = new OpenGL.MyTopWindowBridgeOpenGL(rootgfx, topWinEventRoot);
                var view   = new OpenGL.GpuOpenGLSurfaceView();

                view.Width        = 800;
                view.Height       = 600;
                openGLSurfaceView = view;
                //view.Dock = DockStyle.Fill;
                this.Controls.Add(view);
                //---------------------------------------
                view.Bind(bridge);
                this.winBridge = bridge;
                //---------------------------------------
                view.SetGLPaintHandler(HandleGLPaint);
                hh1 = view.Handle;         //force real window handle creation
                view.MakeCurrent();
                //int max = Math.Max(this.Width, this.Height);
                int max = Math.Max(view.Width, view.Height);
                canvas2d = PixelFarm.Drawing.GLES2.GLES2Platform.CreateCanvasGL2d(max, max);
                //---------------
                //canvas2d.FlipY = true;//
                //---------------
                canvasPainter = new GLCanvasPainter(canvas2d, max, max);

                //canvasPainter.SmoothingMode = PixelFarm.Drawing.SmoothingMode.HighQuality;
                //----------------------
                //1. win gdi based
                //var printer = new WinGdiFontPrinter(canvas2d, view.Width, view.Height);
                //canvasPainter.TextPrinter = printer;
                //----------------------
                //2. raw vxs
                //var printer = new PixelFarm.Drawing.Fonts.VxsTextPrinter(canvasPainter);
                //canvasPainter.TextPrinter = printer;
                //----------------------
                //3. agg texture based font texture
                //var printer = new AggTextSpanPrinter(canvasPainter, 400, 50);
                //printer.HintTechnique = Typography.Rendering.HintTechnique.TrueTypeInstruction_VerticalOnly;
                //printer.UseSubPixelRendering = true;
                //canvasPainter.TextPrinter = printer;

                var printer = new GLBmpGlyphTextPrinter(canvasPainter, YourImplementation.BootStrapOpenGLES2.myFontLoader);
                canvasPainter.TextPrinter = printer;

                //
                //var myGLCanvas1 = new PixelFarm.Drawing.GLES2.MyGLCanvas(canvasPainter, 0, 0, view.Width, view.Height);
                var myGLCanvas1 = new PixelFarm.Drawing.GLES2.MyGLCanvas(canvasPainter, 0, 0, view.Width, view.Height);
                bridge.SetCanvas(myGLCanvas1);
            }
            break;

#if __SKIA__
            case InnerViewportKind.Skia:
            {
                //skiasharp ***

                var bridge = new Skia.MyTopWindowBridgeSkia(rootgfx, topWinEventRoot);
                var view   = new CpuSurfaceView();
                view.Dock = DockStyle.Fill;
                this.Controls.Add(view);
                //---------------------------------------
                view.Bind(bridge);
                this.winBridge = bridge;
            }
            break;
#endif
            case InnerViewportKind.GdiPlus:
            default:
            {
                var bridge = new GdiPlus.MyTopWindowBridgeGdiPlus(rootgfx, topWinEventRoot);
                var view   = new CpuSurfaceView();
                view.Dock = DockStyle.Fill;
                this.Controls.Add(view);
                //---------------------------------------
                view.Bind(bridge);
                this.winBridge = bridge;
            }
            break;
            }
        }
Example #25
0
        public static Form CreateNewFormCanvas(
            int w, int h,
            InnerViewportKind internalViewportKind,
            out LayoutFarm.UI.UISurfaceViewportControl canvasViewport)
        {
            //1. init
            InitWinform();
            IFontLoader fontLoader = s_fontstore;

            //2.
            PixelFarm.Drawing.ITextService ifont = null;
            switch (internalViewportKind)
            {
            default:
                //ifont = PixelFarm.Drawing.WinGdi.WinGdiPlusPlatform.GetIFonts();
                ifont = new OpenFontTextService();
                break;

            case InnerViewportKind.GL:
                ifont = new OpenFontTextService();
                break;
            }

            PixelFarm.Drawing.WinGdi.WinGdiPlusPlatform.SetFontLoader(fontLoader);

            //

            //---------------------------------------------------------------------------

            MyRootGraphic myRootGfx = new MyRootGraphic(
                w, h,
                ifont
                );

            //---------------------------------------------------------------------------

            var       innerViewport        = canvasViewport = new LayoutFarm.UI.UISurfaceViewportControl();
            Rectangle screenClientAreaRect = Conv.ToRect(Screen.PrimaryScreen.WorkingArea);

            canvasViewport.InitRootGraphics(myRootGfx, myRootGfx.TopWinEventPortal, internalViewportKind);
            canvasViewport.Bounds =
                new System.Drawing.Rectangle(10, 10,
                                             screenClientAreaRect.Width,
                                             screenClientAreaRect.Height);
            //----------------------
            Form form1 = new Form();

            //LayoutFarm.Dev.FormNoBorder form1 = new Dev.FormNoBorder();
            form1.Controls.Add(canvasViewport);
            //----------------------
            MakeFormCanvas(form1, canvasViewport);

            form1.SizeChanged += (s, e) =>
            {
                if (form1.WindowState == FormWindowState.Maximized)
                {
                    Screen currentScreen = GetScreenFromX(form1.Left);
                    //make full screen ?
                    if (innerViewport != null)
                    {
                        innerViewport.Size = currentScreen.WorkingArea.Size;
                    }
                }
            };
            //----------------------
            return(form1);
        }
        public void InitRootGraphics(
            RootGraphic rootgfx,
            ITopWindowEventRoot topWinEventRoot,
            InnerViewportKind innerViewportKind)
        {
            //create a proper bridge****

            _rootgfx           = rootgfx;
            _topWinEventRoot   = topWinEventRoot;
            _innerViewportKind = innerViewportKind;
            switch (innerViewportKind)
            {
#if GL_ENABLE
            case InnerViewportKind.GdiPlusOnGLES:
            case InnerViewportKind.AggOnGLES:
            case InnerViewportKind.GLES:
            {
                //temp not suppport

                var bridge = new OpenGL.MyTopWindowBridgeOpenGL(rootgfx, topWinEventRoot);
                var view   = new OpenGL.GpuOpenGLSurfaceView();
                view.Width  = rootgfx.Width;
                view.Height = rootgfx.Height;
                _gpuSurfaceViewUserControl = view;
                this.Controls.Add(view);
                //---------------------------------------
                view.Bind(bridge);
                _winBridge = bridge;
                //---------------------------------------
                IntPtr hh1 = view.Handle;         //force real window handle creation
                view.MakeCurrent();
                int max = Math.Max(view.Width, view.Height);

                _pcx = GLPainterContext.Create(max, max, view.Width, view.Height, true);

                _glPainter = new GLPainter();
                _glPainter.BindToPainterContext(_pcx);
                _glPainter.TextPrinter = new GLBitmapGlyphTextPrinter(_glPainter, PixelFarm.Drawing.GLES2.GLES2Platform.TextService);



                //canvasPainter.SmoothingMode = PixelFarm.Drawing.SmoothingMode.HighQuality;
                //----------------------
                //1. win gdi based
                //var printer = new WinGdiFontPrinter(canvas2d, view.Width, view.Height);
                //canvasPainter.TextPrinter = printer;
                //----------------------
                //2. raw vxs
                //var printer = new PixelFarm.Drawing.Fonts.VxsTextPrinter(canvasPainter);
                //canvasPainter.TextPrinter = printer;
                //----------------------
                //3. agg texture based font texture
                //var printer = new AggTextSpanPrinter(canvasPainter, 400, 50);
                //printer.HintTechnique = Typography.Rendering.HintTechnique.TrueTypeInstruction_VerticalOnly;
                //printer.UseSubPixelRendering = true;
                //canvasPainter.TextPrinter = printer;
                //3
                var myGLCanvas1 = new PixelFarm.Drawing.GLES2.MyGLDrawBoard(_glPainter);
                //{
                //in mixed mode
                //GDI+ on GLES, Agg on GLES we provide a software rendering layer too
                PixelFarm.Drawing.DrawBoard cpuDrawBoard = CreateSoftwareDrawBoard(view.Width, view.Height, innerViewportKind);
                myGLCanvas1.SetCpuBlitDrawBoardCreator(() => cpuDrawBoard);
                //}

                bridge.SetCanvas(myGLCanvas1);
            }
            break;
#endif

            case InnerViewportKind.PureAgg:
            {
                var bridge = new GdiPlus.MyTopWindowBridgeAgg(rootgfx, topWinEventRoot);         //bridge to agg
                var view   = new CpuSurfaceView();
                view.Dock = DockStyle.Fill;
                this.Controls.Add(view);
                //---------------------------------------
                view.Bind(bridge);
                _winBridge = bridge;
            }
            break;

            case InnerViewportKind.GdiPlus:
            default:
            {
                var bridge = new GdiPlus.MyTopWindowBridgeGdiPlus(rootgfx, topWinEventRoot);         //bridge with GDI+
                var view   = new CpuSurfaceView();
                view.Size = new System.Drawing.Size(rootgfx.Width, rootgfx.Height);
                this.Controls.Add(view);
                //---------------------------------------
                view.Bind(bridge);
                _winBridge = bridge;
            }
            break;

#if __SKIA__
            case InnerViewportKind.Skia:
            {
                //skiasharp ***

                var bridge = new Skia.MyTopWindowBridgeSkia(rootgfx, topWinEventRoot);
                var view   = new CpuSurfaceView();
                view.Dock = DockStyle.Fill;
                this.Controls.Add(view);
                //---------------------------------------
                view.Bind(bridge);
                _winBridge = bridge;
            }
            break;
#endif
            }
        }
Example #27
0
        public static void CreateCanvasControlOnExistingControl(
            Control landingControl,
            int xpos, int ypos,
            int w, int h,
            InnerViewportKind internalViewportKind,
            out GraphicsViewRoot view_root)
        {
            //1. init
            InitWinform();
            IInstalledTypefaceProvider fontLoader = YourImplementation.CommonTextServiceSetup.FontLoader;

            //2.


            switch (internalViewportKind)
            {
            default:
                //gdi, gdi on gles


                break;

            case InnerViewportKind.PureAgg:
            case InnerViewportKind.AggOnGLES:
            case InnerViewportKind.GLES:
            {
                var openFontTextService = new Typography.Text.OpenFontTextService();
                openFontTextService.SvgBmpBuilder = PaintLab.SvgBuilderHelper.ParseAndRenderSvg;

                PixelFarm.Drawing.GLES2.GLES2Platform.TextService = openFontTextService;

                Typography.Text.GlobalTextService.TxtClient = openFontTextService.CreateNewServiceClient();
            }
            break;
            }

            PixelFarm.Drawing.WinGdi.WinGdiPlusPlatform.SetInstalledTypefaceProvider(fontLoader);
            //---------------------------------------------------------------------------
            //3. root graphics

            PixelFarm.Drawing.Rectangle screenClientAreaRect = Conv.ToRect(Screen.PrimaryScreen.WorkingArea);
            w = screenClientAreaRect.Width;
            h = screenClientAreaRect.Height;



            MyRootGraphic myRootGfx = new MyRootGraphic(w, h);

            //4. create event bridge that will bridge from native window event to root graphics
            AbstractTopWindowBridge bridge = GetTopWindowBridge(internalViewportKind, myRootGfx, myRootGfx.TopWinEventPortal);

            //5. actualWinUI is platform specific
            var actualWinUI = new LayoutFarm.UI.MyWinFormsControl();

            actualWinUI.Size = new System.Drawing.Size(w, h);
            landingControl.Controls.Add(actualWinUI);


            //so we create abstraction of actual UI
            IGpuOpenGLSurfaceView viewAbstraction = actualWinUI.CreateWindowWrapper(bridge);

            var viewRoot = view_root = new GraphicsViewRoot(
                screenClientAreaRect.Width,
                screenClientAreaRect.Height);

            view_root.InitRootGraphics(
                myRootGfx,
                myRootGfx.TopWinEventPortal,
                internalViewportKind,
                viewAbstraction,
                bridge);

            //TODO: review here again
            myRootGfx.SetDrawboardReqDelegate(view_root.GetDrawBoard);
            //------
            //TODO: review here
            view_root.SetBounds(xpos, ypos,
                                screenClientAreaRect.Width,
                                screenClientAreaRect.Height);

            //
            Form ownerForm = landingControl.FindForm();

            if (ownerForm != null)
            {
                ownerForm.FormClosing += (s, e) =>
                {
                    //TODO: review here
                    viewRoot.Close();
                };
            }
        }
Example #28
0
        public void InitRootGraphics(RootGraphic rootgfx,
                                     ITopWindowEventRoot topWinEventRoot,
                                     InnerViewportKind innerViewportKind,
                                     IGpuOpenGLSurfaceView nativeWindow,
                                     AbstractTopWindowBridge bridge)
        {
            //create a proper bridge****
            _rootgfx           = rootgfx;
            _topWinEventRoot   = topWinEventRoot;
            _innerViewportKind = innerViewportKind;
            _viewport          = nativeWindow;
            _winBridge         = bridge;

            nativeWindow.SetSize(rootgfx.Width, rootgfx.Height);

            switch (innerViewportKind)
            {
            case InnerViewportKind.GdiPlusOnGLES:
            case InnerViewportKind.AggOnGLES:
            case InnerViewportKind.GLES:
            {
                _winBridge.OnHostControlLoaded();
                try
                {
                    nativeWindow.MakeCurrent();
                }
                catch (Exception ex)
                {
                }
                int w = nativeWindow.Width;
                int h = nativeWindow.Height;

                int max = Math.Max(w, h);

                _pcx       = PixelFarm.DrawingGL.GLPainterCore.Create(max, max, w, h, true);
                _glPainter = new GLPainter();
                _glPainter.BindToPainterCore(_pcx);


                if (PixelFarm.Drawing.GLES2.GLES2Platform.TextService != null)
                {
                    var printer = new GLBitmapGlyphTextPrinter(_glPainter, PixelFarm.Drawing.GLES2.GLES2Platform.TextService);

                    _glPainter.TextPrinter = printer;
                }
                else
                {
                    //warn....!
                }

                //canvasPainter.SmoothingMode = PixelFarm.Drawing.SmoothingMode.HighQuality;
                //----------------------
                //1. win gdi based
                //var printer = new WinGdiFontPrinter(canvas2d, view.Width, view.Height);
                //canvasPainter.TextPrinter = printer;
                //----------------------
                //2. raw vxs
                //var printer = new PixelFarm.Drawing.Fonts.VxsTextPrinter(canvasPainter);
                //canvasPainter.TextPrinter = printer;
                //----------------------
                //3. agg texture based font texture
                //_glPainter.TextPrinter = new CpuBlitTextSpanPrinter2(_glPainter, 400, 50, PixelFarm.Drawing.GLES2.GLES2Platform.TextService);

                //TODO: review this again!
                //3
                var drawboard = new PixelFarm.Drawing.GLES2.MyGLDrawBoard(_glPainter);
                _glPainter.SetDrawboard(drawboard);
                _drawboard = drawboard;

                //{
                //in mixed mode
                //GDI+ on GLES, Agg on GLES we provide a software rendering layer too
                PixelFarm.Drawing.DrawBoard cpuDrawBoard = null;        // CreateSoftwareDrawBoard(view.Width, view.Height, innerViewportKind);
                drawboard.SetCpuBlitDrawBoardCreator(() => cpuDrawBoard ?? (cpuDrawBoard = CreateSoftwareDrawBoard(w, h, innerViewportKind)));
                //}
                ((OpenGL.MyTopWindowBridgeOpenGL)_winBridge).SetCanvas(drawboard);
            }
            break;
            }
        }