void DrawVerticalLines(IPainter painter, Rectangle canvasClipRect, Point canvasStartPoint, Rectangle imageClipRect, int filterArgb)
        {
            Action <int> paintAction =
                x =>
            {
                var currentLineArgb = GetLineColor(x, Image.Size.Width);
                if (currentLineArgb == filterArgb)
                {
                    var canvasX = (x - imageClipRect.Left + 1) * CellSize + canvasStartPoint.X - LineWidth;
                    if (canvasX < canvasClipRect.RightExclusive)
                    {
                        var top    = Math.Max(RulerWidth, canvasClipRect.Top);
                        var bottom = Math.Min(imageClipRect.Height * CellSize + canvasStartPoint.Y, canvasClipRect.BottomExclusive);
                        painter.DrawVerticalLine(canvasX, top, bottom - top, currentLineArgb, GetLineWidth(x, Image.Size.Width));
                    }
                }
            };

            if (painter.SupportsMultithreading)
            {
                Parallel.For(imageClipRect.Left, imageClipRect.RightExclusive, paintAction);
            }
            else
            {
                for (int x = imageClipRect.Left; x < imageClipRect.RightExclusive; x++)
                {
                    paintAction(x);
                }
            }
        }
Beispiel #2
0
        /// <summary>
        /// Default constructor for the SyntaxBoxControl
        /// </summary>
        public EditViewControl(SyntaxBoxControl Parent)
        {
            _SyntaxBox = Parent;

            Painter = new NativePainter(this);
            _Selection = new Selection(this);
            _Caret = new Caret(this);

            _Caret.Change += CaretChanged;
            _Selection.Change += SelectionChanged;

            InitializeComponent();

            CreateAutoList();
            //CreateFindForm ();
            CreateInfoTip();

            SetStyle(ControlStyles.AllPaintingInWmPaint, false);
            SetStyle(ControlStyles.DoubleBuffer, false);
            SetStyle(ControlStyles.Selectable, true);
            SetStyle(ControlStyles.ResizeRedraw, true);
            SetStyle(ControlStyles.Opaque, true);
            SetStyle(ControlStyles.UserPaint, true);
            UpdateStyles();

            //			this.IMEWindow = new Keyrox.Globalization.IMEWindow (this.Handle,_SyntaxBox.FontName,_SyntaxBox.FontSize);
        }
Beispiel #3
0
        protected override void Draw(IPainter <TColor> painter, Point currentCameraLocation)
        {
            var currentPercentage = _currentPercentageBinder();

            if (Math.Abs(currentPercentage - 1f) < 0.01)
            {
                _innerPanel.Width = _outPanel.Width;
                HUDManager <TColor> .Painter.DrawRectangle(Box.Location + currentCameraLocation, _innerPanel.Size, _innerColor);
            }
            else if (currentPercentage > 0)
            {
                _innerPanel.Width = (int)(((_outPanel.Width - 1)) * currentPercentage);
                HUDManager <TColor> .Painter.DrawRectangle(Box.Location + currentCameraLocation, _outPanel.Size, _outColor);

                HUDManager <TColor> .Painter.DrawRectangle(Box.Location + currentCameraLocation, _innerPanel.Size, _innerColor);
            }
            else
            {
                HUDManager <TColor> .Painter.DrawRectangle(Box.Location + currentCameraLocation, _outPanel.Size, _outColor);

                _innerPanel.Width = 0;
            }

            base.Draw(painter, currentCameraLocation);
        }
        internal void PaintSelection(IPainter painter, Rectangle canvasClipRect, Point canvasStartPoint, Point imageStartPoint)
        {
            if (painter.SupportsMultithreading &&
                ShowSelectedRect &&
                SelectedRect.Width > 0 && SelectedRect.Height > 0)
            {
                PaintVSelectionBorder(painter, canvasClipRect, canvasStartPoint, imageStartPoint, selectedRect.Left, selectedRect.Top, selectedRect.BottomExclusive);
                PaintVSelectionBorder(painter, canvasClipRect, canvasStartPoint, imageStartPoint, selectedRect.RightExclusive, selectedRect.Top, selectedRect.BottomExclusive);

                PaintHSelectionBorder(painter, canvasClipRect, canvasStartPoint, imageStartPoint, selectedRect.Left, selectedRect.RightExclusive, selectedRect.Top);
                PaintHSelectionBorder(painter, canvasClipRect, canvasStartPoint, imageStartPoint, selectedRect.Left, selectedRect.RightExclusive, selectedRect.BottomExclusive);

                if (ShowSelectedRectPoints)
                {
                    var x1 = (SelectedRect.Left - imageStartPoint.X) * CellSize + canvasStartPoint.X - 1;
                    var y1 = (selectedRect.Top - imageStartPoint.Y) * CellSize + canvasStartPoint.Y - 1;
                    var x2 = (SelectedRect.RightExclusive - imageStartPoint.X) * CellSize + canvasStartPoint.X - 1;
                    var y2 = (selectedRect.BottomExclusive - imageStartPoint.Y) * CellSize + canvasStartPoint.Y - 1;

                    PaintShifter(painter, canvasClipRect, x1, y1);
                    PaintShifter(painter, canvasClipRect, x2, y1);
                    PaintShifter(painter, canvasClipRect, x1, y2);
                    PaintShifter(painter, canvasClipRect, x2, y2);

                    var xm = (x1 + x2) / 2;
                    var ym = (y1 + y2) / 2;

                    PaintShifter(painter, canvasClipRect, xm, y1);
                    PaintShifter(painter, canvasClipRect, xm, y2);
                    PaintShifter(painter, canvasClipRect, x1, ym);
                    PaintShifter(painter, canvasClipRect, x2, ym);
                }
            }
        }
Beispiel #5
0
 public Point(ICoor coor)
 {
     Coors = new List <ICoor> {
         coor
     };
     Painter = new PointPainter();
 }
Beispiel #6
0
        public void Draw(IPainter <TVertex, TBox> painter, ISelector <TVertex, TBox> selector)
        {
            // Set reference to external painter object (only for cell Update)
            lastPainter = painter;
            // Basic cell visual data
            painter.FillPolygon(vertices, GetBackFillType());
            if (UseEffect3D && Closed && !IsSelected)
            {
                painter.DrawBorder3D(verticesEffect3D);
            }            //else
            painter.DrawPolygon(vertices);
            // Adding this cell to selector if needed
            if (selector != null)
            {
                selector.AddCell(this, vertices);
            }
            // Other common cell visual data
            TVertex center      = Center;
            TBox    internalBox = GetInternalBox(InternalBoxCoefficient);

            if (!Closed)
            {
                if (HasMine)
                {
                    if (!IsLabelState)
                    {
                        painter.DrawMine(center, internalBox, true);
                    }
                }
                else
                {
                    switch (State)
                    {
                    case CellState.Label:
                        painter.DrawMine(center, internalBox, false);
                        break;

                    case CellState.Normal:
                        if (MinesNumber != 0)
                        {
                            painter.DrawInteger(center, internalBox, MinesNumber);
                        }
                        break;
                    }
                }
            }
            else                // closed
            {
                switch (State)
                {
                case CellState.Undefined:
                    painter.DrawUndefined(center, internalBox);
                    break;

                case CellState.Label:
                    painter.DrawLabel(center, internalBox);
                    break;
                }
            }
        }
        public void PaintPrintPageImage(IPainter painter, int page, Size pageSize, Rectangle margins, string appInfo, string fileInfo)
        {
            var lineWidth = Math.Max((int)(PixelsPerMm / 4m), 1);

            painter.FillRectangle(margins.Left, margins.Top, margins.Width, margins.Height, WhiteColorArgb);

            using (painter.TranslateCoordinates(new Size(margins.Left, margins.Top)))
            {
                if (page < PagesCount - PrintPalettePagesCount)
                {
                    PaintSchemePage(painter, page, new Size(margins.Width, margins.Height), new Rectangle(0, 0, margins.Width, margins.Height), lineWidth);
                }
                else
                {
                    PaintPalettePage(painter, page, lineWidth, margins);
                }
            }

            var infoY       = margins.BottomExclusive + (int)(CellSizeMm / 2);
            var textSize    = (int)(PixelsPerMm * 3);
            var textPainter = new TextPainter(GridPainter.SymbolsFont, (int)(PixelsPerMm * 3));

            painter.PaintText(appInfo, new Point(margins.Left, infoY), textSize, spaceBetweenCharacters: lineWidth);

            var fileInfoWidth = textPainter.GetTextSize(fileInfo, spaceBetweenCharacters: lineWidth).Width;

            painter.PaintText(fileInfo, new Point(margins.RightExclusive - fileInfoWidth, infoY), textSize, spaceBetweenCharacters: lineWidth);

            var pageNo      = String.Format(Resources.PrintPageNo, page + 1, PagesCount);
            var pageNoWidth = textPainter.GetTextSize(pageNo, spaceBetweenCharacters: lineWidth).Width;

            painter.PaintText(pageNo, new Point(margins.Left + (margins.Width - pageNoWidth) / 2, infoY), textSize, spaceBetweenCharacters: lineWidth);
        }
Beispiel #8
0
        protected override void Draw(IPainter <TColor> painter, Point currentCameraLocation)
        {
            _image.Update(HUDManager <TColor> .GameTimer.GetElapsedTime());
            _image.Draw(painter, Box.Location + currentCameraLocation);

            base.Draw(painter, currentCameraLocation);
        }
Beispiel #9
0
 protected virtual void Draw(IPainter <TColor> painter, Point currentCameraLocation)
 {
     foreach (var control in Controls)
     {
         control.MainDraw(painter, currentCameraLocation);
     }
 }
        void DrawHorizontalLines(IPainter painter, Rectangle canvasClipRect, Point canvasStartPoint, Rectangle imageClipRect, int filterArgb)
        {
            Action <int> paintAction =
                y =>
            {
                var currentLineArgb = GetLineColor(y, Image.Size.Height);
                if (currentLineArgb == filterArgb)
                {
                    var canvasY = (y - imageClipRect.Top + 1) * CellSize + canvasStartPoint.Y - LineWidth;
                    if (canvasY < canvasClipRect.BottomExclusive)
                    {
                        var left  = Math.Max(RulerWidth, canvasClipRect.Left);
                        var right = Math.Min(imageClipRect.Width * CellSize + canvasStartPoint.X, canvasClipRect.RightExclusive);
                        painter.DrawHorizontalLine(left, canvasY, right - left, currentLineArgb, GetLineWidth(y, Image.Size.Height));
                    }
                }
            };

            if (painter.SupportsMultithreading)
            {
                Parallel.For(imageClipRect.Top, imageClipRect.BottomExclusive, paintAction);
            }
            else
            {
                for (int y = imageClipRect.Top; y < imageClipRect.BottomExclusive; y++)
                {
                    paintAction(y);
                }
            }
        }
Beispiel #11
0
 public Client(IDesigner designer, IPainter painter, ICanvas canvas)
 {
     _designer          = designer;
     _painter           = painter;
     _canvas            = canvas;
     _shapeDescriptions = new List <string>();
 }
Beispiel #12
0
 public SnowGameEngine
     (IGameContext gameContext, IPainter painter, IGameEventFactory eventFactory)
     : base(gameContext, painter, eventFactory)
 {
     _gameSpeed  = 80;
     _slowFactor = 0;
 }
Beispiel #13
0
        public void Paint(IPainter painter, DrawingContext dc, JointCollection joints)//change dc to draw on screen
        {
            Joint rightHand = joints.Where(joint => joint.JointType == JointType.HandRight).FirstOrDefault();
            Joint leftHand  = joints.Where(joint => joint.JointType == JointType.HandLeft).FirstOrDefault();
            Joint head      = joints.Where(joint => joint.JointType == JointType.Head).FirstOrDefault();

            if (rightHand.Position.Y > head.Position.Y)
            {
                rightHandFalg = true;
                leftHandFalg  = false;
            }
            if (leftHand.Position.Y > head.Position.Y)
            {
                leftHandFalg  = true;
                rightHandFalg = false;
            }
            if (rightHandFalg)
            {
                DrawInBmp(painter.SkeletonPointToScreen(rightHand.Position), DrawThickness, trackedJointBrush);
            }
            if (leftHandFalg)
            {
                DrawInBmp(painter.SkeletonPointToScreen(leftHand.Position), ClearThickness, backgroundBrush);
            }
            dc.DrawImage(bmp, new System.Windows.Rect(0, 0, RenderWidth, RenderHeight));
            if (leftHandFalg)
            {
                dc.DrawRectangle(CleanerBrush, null, new Rect(leftHand.Position.X - ClearThickness, leftHand.Position.Y - ClearThickness / 2, ClearThickness * 2, ClearThickness));
            }
        }
Beispiel #14
0
 public void DrawPicture(IPainter painter, ICanvas canvas)
 {
     if (_draft != null)
     {
         painter.DrawPicture(_draft, canvas);
     }
 }
Beispiel #15
0
 public GameEngine(IGameContext gameContext, IPainter painter, IGameEventFactory eventFactory)
 {
     _gameContext  = gameContext;
     Painter       = painter;
     _eventFactory = eventFactory;
     CurrentEvent  = _eventFactory.Create("Start", _gameContext);
 }
Beispiel #16
0
        static Grid RenderFlatGrid(Dictionary <string, string> gsa2names, Dictionary <string, RectList> name2rects, int rangeX, int rangeY, int rangeZ)
        {
            int  width  = rangeX * 64;
            int  height = rangeZ * 64;
            Grid grid   = RasterLib.RasterApi.CreateGrid(width, height, 1, 4);

            IPainter painter = RasterLib.RasterApi.Painter;

            for (int z = -rangeZ; z <= rangeZ; z++)
            {
                //for (int y = 0; y <= rangeY; y++)
                int y = 0;
                {
                    for (int x = -rangeX; x <= rangeX; x++)
                    {
                        GridSpaceAddress gsa = new GridSpaceAddress(x, y, z);
                        if (gsa2names.ContainsKey(gsa.ToString()))
                        {
                            string   name      = gsa2names[gsa.ToString()];
                            RectList cellRects = name2rects[name];

                            Console.WriteLine("Rendering " + name);
                            Grid tempGrid = new Grid(64, 64, 64, 4);
                            RasterLib.RasterApi.Renderer.RenderRectsToGrid(cellRects, tempGrid, 0, 0, 0);

                            BirdsEye(tempGrid, grid, (x + rangeX) * 64 / 2, (z + rangeZ) * 64 / 2);
                        }
                    }
                }
            }

            GC.Collect();

            return(grid);
        }
Beispiel #17
0
        private void RegisterBindings()
        {
            IKernel kernel = new StandardKernel();

            kernel.Bind <IConfigurationDataProvider>().To <ConfigurationDataProvider>();

            kernel.Bind <IGameEventFactory>().ToFactory(() => new UseFirstArgumentAsNameInstanceProvider());

            kernel.Bind <ICellFactory>().ToFactory(() => new UseFirstArgumentAsNameInstanceProvider());
            kernel.Bind <ICell>().To <GroundPiece>().Named("GroundPiece");
            kernel.Bind <ICell>().To <Snowflake>().Named("Snowflake");
            kernel.Bind <ICell>().To <FlyingSnowflake>().Named("FlyingSnowflake");

            kernel.Bind <IGameContext>().To <SnowGameContext>();
            IGameContext gameContext = kernel.Get <IGameContext>();

            kernel.Bind <IGameEvent>().To <Start>().Named("Start")
            .WithConstructorArgument("gameContext", gameContext);
            kernel.Bind <IGameEvent>().To <Move>().Named("Move")
            .WithConstructorArgument("gameContext", gameContext);

            kernel.Bind <Start>().ToSelf().InSingletonScope();
            kernel.Bind <Move>().ToSelf().InSingletonScope();

            kernel.Bind <IPainter>().To <PainterWithLabel>()
            .WithConstructorArgument("gameContext", gameContext);
            IPainter painter = kernel.Get <IPainter>();

            kernel.Bind <IGameEngine>().To <SnowGameEngine>()
            .WithConstructorArgument("gameContext", gameContext)
            .WithConstructorArgument("painter", painter);
            _gameEngine = kernel.Get <IGameEngine>();
        }
Beispiel #18
0
        static Grid RenderNetGrid(Dictionary <string, string> gsa2names, Dictionary <string, RectList> name2rects, int rangeX, int rangeY, int rangeZ)
        {
            int  width  = rangeX * 64 * 2;
            int  height = rangeY * 64 * 2;
            int  depth  = rangeZ * 64 * 2;
            Grid grid   = RasterLib.RasterApi.CreateGrid(width, 64, depth, 4);
            int  ox     = width / 2;
            int  oz     = depth / 2;

            IPainter painter = RasterLib.RasterApi.Painter;

            for (int z = -rangeZ; z <= rangeZ; z++)
            {
                //for (int y = 0; y <= rangeY; y++)
                int y = 0;
                {
                    for (int x = -rangeX; x <= rangeX; x++)
                    {
                        GridSpaceAddress gsa = new GridSpaceAddress(x, y, z);
                        if (gsa2names.ContainsKey(gsa.ToString()))
                        {
                            string   name      = gsa2names[gsa.ToString()];
                            RectList cellRects = name2rects[name];

                            Console.WriteLine("Rendering " + name);
                            RasterLib.RasterApi.Renderer.RenderRectsToGrid(cellRects, grid, x * 64 + ox, y * 64, z * 64 + oz);
                        }
                    }
                }
            }

            GC.Collect();

            return(grid);
        }
        protected override void Draw(IPainter <TColor> painter, Point currentCameraLocation)
        {
            var text = _stringBinder();

            var textAdjustPosition = new Point();

            if (_align != TextAlign.Left)
            {
                var size = HUDManager <TColor> .Painter.GetTextSize(_iFontSize, text);

                switch (_align)
                {
                case TextAlign.Center:
                    textAdjustPosition.X = size.X / 2;
                    break;

                case TextAlign.Right:
                    textAdjustPosition.X = size.X;
                    break;
                }
            }

            HUDManager <TColor> .Painter.DrawString(text, _iFontSize, Box.Location + currentCameraLocation - textAdjustPosition, _color);

            base.Draw(painter, currentCameraLocation);
        }
Beispiel #20
0
 public Game(ISpaceUpdater spaceUpdater,
             ISpaceStore spaceStore, IPainter painter, IGUIManager GUIManager)
 {
     this.spaceUpdater = spaceUpdater;
     this.spaceStore   = spaceStore;
     this.painter      = painter;
     this.GUIManager   = GUIManager;
 }
Beispiel #21
0
 /// <summary>
 /// 初始畫
 /// </summary>
 /// <param name="painter">繪圖</param>
 /// <param name="printer">列印</param>
 /// <param name="x">x</param>
 /// <param name="y">y</param>
 /// <param name="radius">radius</param>
 public Round(IPainter painter, IPrinter printer, double x, double y, double radius)
 {
     this.painter = painter;
     this.printer = printer;
     this.x       = x;
     this.y       = y;
     this.radius  = radius;
 }
Beispiel #22
0
        public MyBrush()
        {
            Painter = new BrushIPainter();

            Reaction = new NoReactionIReaction();

            startPoint = new Point(-1, -1);
        }
Beispiel #23
0
 public Controller(Board board, IPainter painter)
 {
     this.firstPlayer   = board.FirstPlayer;
     this.secondPlayer  = board.SecondPlayer;
     this.currentPlayer = board.FirstPlayer;
     this.board         = board;
     this.painter       = painter;
 }
Beispiel #24
0
        protected override void Draw(IPainter <TColor> painter, Point currentCameraLocation)
        {
            HUDManager <TColor> .Painter.DrawRectangle(Box.Location + currentCameraLocation, Box.Size, _isHovered?_innerColorHovered : _innerColor);

            HUDManager <TColor> .Painter.DrawRectangleOutline(Box.Location + currentCameraLocation, Box.Size, _isHovered?_outColorHovered : _outColor);

            base.Draw(painter, currentCameraLocation);
        }
        public void Draw(IPainter <Color> painter, Point location, float scale)
        {
            var currentTexture = GetCurrentTexture();

            var texture = new Texture(currentTexture);

            painter.Draw(texture, location, scale, Color.White);
        }
Beispiel #26
0
 public Colorizer(IPainter <T> painter)
 {
     this.painter  = painter;
     SourceFilter  = x => true;
     WordSelector  = x => x as string ?? string.Empty;
     SearchOptions = RichTextBoxFinds.WholeWord;
     ResetColors   = true;
 }
        static void Main(string[] args)
        {
            IEnumerable <ProportionalPainter> painters = new ProportionalPainter[10];

            IPainter fastestPainter = CompositePainterFactories.CreateFastestSelector(painters);

            IPainter group = CompositePainterFactories.CombineProportional(painters);
        }
Beispiel #28
0
        public void MainDraw(IPainter <TColor> painter, Point currentCameraLocation)
        {
            if (!IsVisible)
            {
                return;
            }

            Draw(painter, currentCameraLocation);
        }
Beispiel #29
0
 public override void Dispose(bool disposing)
 {
     if (disposing)
     {
         InnerPainter.Dispose();
         InnerPainter = null;
     }
     base.Dispose(disposing);
 }
Beispiel #30
0
 /// <summary>
 /// 初始畫
 /// </summary>
 /// <param name="painter">畫圖庫</param>
 /// <param name="printer">列印庫</param>
 /// <param name="x1">x1</param>
 /// <param name="y1">y1</param>
 /// <param name="x2">x2</param>
 /// <param name="y2">y2</param>
 public Rectangle(IPainter painter, IPrinter printer, double x1, double y1, double x2, double y2)
 {
     this.painter = painter;
     this.printer = printer;
     this.x1      = x1;
     this.y1      = y1;
     this.x2      = x2;
     this.y2      = y2;
 }
Beispiel #31
0
 public CaptchaController(
     IOptions <PainterOption> painterOpt,
     ICodeTextGenerator codeTextGenerator,
     IPainter painter)
 {
     _painterOption     = painterOpt.Value;
     _codeTextGenerator = codeTextGenerator;
     _painter           = painter;
 }
Beispiel #32
0
    public Game()
    {
      ResetToDefault();
      ratioD = d2 / d1;

      pixel_painter = new PixelPainter();
      sprite_painter = new SpritePainter();
      painter = sprite_painter;

      rnd = new Random((int) DateTime.Now.ToBinary());
      random_numbers = new double[asteriks_count_max];
      for (var i = 0; i < asteriks_count_max; i++) random_numbers[i] = (rnd.NextGaussian(rnd.Next(-100, 100), 100 / 2));

      render = new Thread(Render){ IsBackground = true };
    }
Beispiel #33
0
 public Drawing(IPainter painter)
 {
     _painter = painter;
 }
Beispiel #34
0
		/// <summary>
		/// Default constructor for the SyntaxBoxControl
		/// </summary>
		public EditViewControl(CodeEditorControl Parent) : base()
		{
			_CodeEditor = Parent;


            Painter = new Painter_GDI(this);
			_Selection = new Selection(this);
			_Caret = new Caret(this);

			_Caret.Change += new EventHandler(this.CaretChanged);
			_Selection.Change += new EventHandler(this.SelectionChanged);


			//	this.AttachDocument (_SyntaxBox.Document);


			InitializeComponent();


			CreateAutoList();
			//CreateFindForm ();
			CreateInfoTip();

            this.SetStyle(ControlStyles.AllPaintingInWmPaint, false);
            this.SetStyle(ControlStyles.OptimizedDoubleBuffer, false);
			this.SetStyle(ControlStyles.Selectable, true);
			this.SetStyle(ControlStyles.ResizeRedraw, true);
			this.SetStyle(ControlStyles.Opaque, true);
			this.SetStyle(ControlStyles.UserPaint, true);
           // this.SetStyle(ControlStyles.UserMouse, true);
		}
Beispiel #35
0
 public virtual void Draw(IPainter painter)
 {
   painter.Draw(this);
 }
Beispiel #36
0
        /// <summary>
        /// Default constructor for the SyntaxBoxControl
        /// </summary>
        public EditViewControl(SyntaxBoxControl Parent)
        {
            _SyntaxBox = Parent;

            Painter = new NativePainter(this);
            _Selection = new Selection(this);
            _Caret = new Caret(this);

            _Caret.Change += CaretChanged;
            _Selection.Change += SelectionChanged;


            InitializeComponent();


            CreateAutoList();
            //CreateFindForm ();
            CreateInfoTip();

            SetStyle(ControlStyles.AllPaintingInWmPaint, false);
            SetStyle(ControlStyles.DoubleBuffer, false);
            SetStyle(ControlStyles.Selectable, true);
            SetStyle(ControlStyles.ResizeRedraw, true);
            SetStyle(ControlStyles.Opaque, true);
            SetStyle(ControlStyles.UserPaint, true);
            UpdateStyles();

            mKeysThatInsertFromAutolist.Add(Keys.Space);
            mKeysThatInsertFromAutolist.Add(Keys.Enter);
            mKeysThatInsertFromAutolist.Add(Keys.Tab);
            mKeysThatInsertFromAutolist.Add(Keys.OemPeriod);
            mKeysThatInsertFromAutolist.Add(Keys.OemOpenBrackets);
            //mKeysThatInsertFromAutolist.Add(


            //			this.IMEWindow = new Alsing.Globalization.IMEWindow (this.Handle,_SyntaxBox.FontName,_SyntaxBox.FontSize);
        }
Beispiel #37
0
		/// <summary>
		/// Initializes a new Instance of current Class.
		/// </summary>
		/// <param name="primitivePainter">Painter used for Primitives.</param>
		public PrimitivePainter(IPainter primitivePainter)
		{
			if (primitivePainter == null)
				throw new ArgumentNullException("primitivePainter");
			this.primitivePainter = primitivePainter;
		}
Beispiel #38
0
		public void OverridePainter(IPainter painter)
		{
			Painter = painter;
			Painter.Invalidate();
		}