Esempio n. 1
0
            public void Draw(ref Graphics g, ref GPage p)
            {
                Matrix m = null;

                float[] mtx = null;
                m = g.Transform.Clone();

                g.ScaleTransform(p.DrawWidth / (XScale.ValTo - XScale.ValFrom), -p.DrawHeight / (Yscale.ValTo - Yscale.ValFrom));
                g.TranslateTransform(XScale.ValFrom, -Yscale.ValFrom);

                Pen.ResetTransform();
                mtx = g.Transform.Elements;
                Pen.ScaleTransform(1 / mtx[0], 1 / mtx[3]);
                Pen.TranslateTransform(0, 0);
                if (Points != null)
                {
                    g.DrawLines(Pen, Points);
                    if (ShowPoints)
                    {
                        var c = Pen.Color;
                        Pen.Color = Color.FromArgb(255 - Pen.Color.R, 255 - Pen.Color.G, 255 - Pen.Color.B);
                        g.DrawRectangles(Pen, Points.Select(x => new RectangleF(x.X, x.Y, (float)0.01, 1)).ToArray());
                        Pen.Color = c;
                    }
                }
                g.Transform.Dispose();
                g.Transform = m;
            }
Esempio n. 2
0
            public void Draw(ref Graphics g, ref GPage p)
            {
                float s       = 0;
                float s1      = 0;
                float s2      = 0;
                float eX      = 0;
                float eY      = 0;
                float majXOff = 0;
                float majYoff = 0;
                float minXoff = 0;
                float minYoff = 0;
                float vXoff   = 0;
                float vYoff   = 0;

                if (Visible)
                {
                    switch (_scaletype)
                    {
                    case GScaleTypes.HorBottom:
                        eX      = sX + p.DrawWidth;
                        eY      = sY;
                        majXOff = 0;
                        majYoff = ValMajSize;
                        minXoff = 0;
                        minYoff = ValMinSize;
                        vXoff   = 0;
                        vYoff   = ValOffset + ValMajSize;
                        break;

                    case GScaleTypes.HorTop:
                        eX      = sX + p.DrawWidth;
                        eY      = sY;
                        majXOff = 0;
                        majYoff = -ValMajSize;
                        minXoff = 0;
                        minYoff = -ValMinSize;
                        vXoff   = 0;
                        vYoff   = -ValOffset - ValMajSize;
                        break;

                    case GScaleTypes.VerLeft:
                        eX      = sX;
                        eY      = sY - p.DrawHeight;
                        majXOff = -ValMajSize;
                        majYoff = 0;
                        minXoff = -ValMinSize;
                        minYoff = 0;
                        vXoff   = -ValOffset - ValMajSize;
                        vYoff   = 0;
                        break;

                    case GScaleTypes.VerRight:
                        eX      = sX;
                        eY      = sY - p.DrawHeight;
                        majXOff = ValMajSize;
                        majYoff = 0;
                        minXoff = ValMinSize;
                        minYoff = 0;
                        vXoff   = ValOffset + ValMajSize;
                        vYoff   = 0;
                        break;
                    }
                    if (ValFrom != ValTo)
                    {
                        g.DrawLine(Pen, sX, sY, eX, eY);
                        if (ValMinStep > 0)
                        {
                            for (s = ValFrom; s <= ValTo; s += ValMinStep)
                            {
                                s1 = sX + (((s - ValFrom) / (ValTo - ValFrom))) * (eX - sX);
                                s2 = sY + (((s - ValFrom) / (ValTo - ValFrom))) * (eY - sY);
                                g.DrawLine(Pen, s1, s2, s1 + minXoff, s2 + minYoff);
                                if (ShowMinLines)
                                {
                                    switch (_scaletype)
                                    {
                                    case GScaleTypes.VerRight:
                                    case GScaleTypes.VerLeft:
                                        g.DrawLine(MinLinesPen, 0, s2, p.DrawWidth, s2);
                                        break;

                                    default:
                                        g.DrawLine(MinLinesPen, s1, 0, s1, -p.DrawHeight);
                                        break;
                                    }
                                }
                            }
                        }
                        if (ValMajStep > 0)
                        {
                            for (s = ValFrom; s <= ValTo; s += ValMajStep)
                            {
                                s1 = sX + (((s - ValFrom) / (ValTo - ValFrom))) * (eX - sX);
                                s2 = sY + (((s - ValFrom) / (ValTo - ValFrom))) * (eY - sY);
                                g.DrawLine(Pen, s1, s2, s1 + majXOff, s2 + majYoff);
                                if (ShowMajLines)
                                {
                                    switch (_scaletype)
                                    {
                                    case GScaleTypes.VerRight:
                                    case GScaleTypes.VerLeft:
                                        g.DrawLine(MajLinesPen, 0, s2, p.DrawWidth, s2);
                                        break;

                                    default:
                                        g.DrawLine(MajLinesPen, s1, 0, s1, -p.DrawHeight);
                                        break;
                                    }
                                }
                                if (ValVisible)
                                {
                                    g.DrawString(s.ToString(ValFormat), ValFont, ValBrush, s1 + vXoff, s2 + vYoff, ValSFormat);
                                }
                            }
                        }
                    }
                }
            }