동구의 블로그

        private void ChangeTabColor(DrawItemEventArgs e)
        {
            Font TabFont;
            Brush BackBrush = new SolidBrush(Color.Green); //Set background color
            Brush ForeBrush = new SolidBrush(Color.Yellow);//Set foreground color
            if (e.Index == this.tabControl1.SelectedIndex)
            {
                TabFont = new Font(e.Font, FontStyle.Italic FontStyle.Bold);
            }
            else
            {
                TabFont = e.Font;
            }
            string TabName = this.tabControl1.TabPages[e.Index].Text;
            StringFormat sf = new StringFormat();
            sf.Alignment = StringAlignment.Center;
            e.Graphics.FillRectangle(BackBrush, e.Bounds);
            Rectangle r = e.Bounds;
            r = new Rectangle(r.X, r.Y + 3, r.Width, r.Height - 3);
            e.Graphics.DrawString(TabName, TabFont, ForeBrush, r, sf);
            //Dispose objects
            sf.Dispose();
            if (e.Index == this.tabControl1.SelectedIndex)
            {
                TabFont.Dispose();
                BackBrush.Dispose();
            }
            else
            {
                BackBrush.Dispose();
                ForeBrush.Dispose();
            }
        }

new SolidBrush(label.DrawPen.Color);

//불투명하게 적용
this.RectangleShape1.BackStyle = Microsoft.VisualBasic.PowerPacks.BackStyle.Opaque;
// BackColor 지정
this.RectangleShape1.BackColor = Color.Yellow;

//임시폴더 경로가져오기 
string tempFolderPath = System.IO.Path.GetTempPath();
 
//임시파일 경로가져오기
string tempFile = System.IO.Path.GetTempFileName();

    class DemandsDataGridView:DataGridView
    {
        DataGridViewCell previousCell;
        bool resetting = false;

        public DemandsDataGridView()
        {
            this.CellPainting += new DataGridViewCellPaintingEventHandler(dataGridView_CellPainting);
            this.CellLeave += new DataGridViewCellEventHandler(dataGridView_CellLeave);
            this.SelectionChanged += new EventHandler(dataGridView_SelectionChanged);
        }

        void dataGridView_SelectionChanged(object sender, EventArgs e)
        {
            if (this.CurrentCell != null && this.resetting==false)
            {
                if (this.CurrentCell.ColumnIndex == 0 || this.CurrentCell.RowIndex == 0)
                {
                    this.resetting = true;
                    this.CurrentCell.Selected = false;
                    this.CurrentCell = this.previousCell;
                    this.resetting = false;
                }
            }
        }

        void dataGridView_CellLeave(object sender, DataGridViewCellEventArgs e)
        {
            this.previousCell = this.CurrentCell;
        }
    }

/* VB
             Private Sub dgvLegends_CellPainting(ByVal sender As Object, ByVal e As System.Windows.Forms.DataGridViewCellPaintingEventArgs) Handles dgvLegends.CellPainting
        'Draw custom cell borders.
        'If current column is DisplayName...
        If dgvLegends.Columns("DisplayName").Index = e.ColumnIndex AndAlso e.RowIndex >= 0 Then
                Dim Brush As New SolidBrush(dgvLegends.ColumnHeadersDefaultCellStyle.BackColor)
                e.Graphics.FillRectangle(Brush, e.CellBounds)
                Brush.Dispose()
                e.Paint(e.CellBounds, DataGridViewPaintParts.All And Not DataGridViewPaintParts.ContentBackground)

                ControlPaint.DrawBorder(e.Graphics, e.CellBounds, dgvLegends.GridColor, 1, ButtonBorderStyle.Solid, dgvLegends.GridColor, 1, ButtonBorderStyle.Solid, dgvLegends.GridColor, 1, ButtonBorderStyle.Solid, dgvLegends.GridColor, 1, ButtonBorderStyle.Solid)

            e.Handled = True
        End If
    End Sub
             */
            if (e.RowIndex == 0 || e.ColumnIndex == 0)
            {
                Brush b = new SolidBrush(Color.Black);
                e.Graphics.FillRectangle(b, e.CellBounds);
                b.Dispose();
                e.Paint(e.CellBounds, DataGridViewPaintParts.All | DataGridViewPaintParts.ContentBackground);
                ControlPaint.DrawBorder(e.Graphics, e.CellBounds, Color.Black, 0, ButtonBorderStyle.Outset,
                    Color.Black, 0, ButtonBorderStyle.Outset, Color.Black, 1,
                    ButtonBorderStyle.Outset, Color.Black, 1, ButtonBorderStyle.Outset);
                e.Handled = true;
            }

                               #region 델파이소스 (선 판별)
                                /*
                                function PtOnLine(const P1: TPoint; const P2: TPoint;
                                  const P: TPoint; const Ptol: Integer): Boolean;
                                {-------------------------------------------------------}
                                {  Checks if point P is on line between points P1 & P2  }
                                {-------------------------------------------------------}
                                var
                                  dx,  dy  : Integer;
                                  dx1, dy1 : Integer;
                                  a, b, c  : Integer;
                                begin
                                  Result := False;
                                  dx := P2.X - P1.X;
                                  dy := P2.Y - P1.Y;
                                  dx1 := P.X - P1.X;
                                  dy1 := P.Y - P1.Y;
                                  if (Abs(dx) > 0) and (Abs(dy) < Abs(dx)) then
                                  begin
                                    if (dx*dx1 >= 0) and (Abs(dx1) <= Abs(dx)) then
                                    begin
                                      a := (dy*dx1);
                                      b := (dx*dy1);
                                      c := Abs(dx*Ptol);
                                      if Abs(a-b) <= c then Result := True;
                                    end;
                                  end
                                  else if Abs(dy) > 0 then
                                  begin
                                    if (dy*dy1 >= 0) and (Abs(dy1) <= Abs(dy)) then
                                    begin
                                      a := (dx*dy1);
                                      b := (dy*dx1);
                                      c := Abs(dy*Ptol);
                                      if Abs(a-b) <= c then Result := True;
                                    end;
                                  end;
                                end;*/

                                #endregion
                                Point startP = link.Locations[j];
                                Point endP = link.Locations[j+1];
                                int dx = endP.X - startP.X;
                                int dy = endP.Y - startP.Y;
                                int dx1 = point.X - startP.X;
                                int dy1 = point.Y - startP.Y;
                                int a = 0, b = 0, c = 0;
                                if (Math.Abs(dx) > 0 && Math.Abs(dy) < Math.Abs(dx))
                                {
                                    if (dx * dx1 >= 0 && Math.Abs(dx1) <= Math.Abs(dx))
                                    {
                                        a = (dy * dx1);
                                        b = (dx * dy1);
                                        c = Math.Abs(dx * ptol);
                                        if (Math.Abs(a - b) <= c)
                                        {
                                            iDraw = link;
                                            return iDraw;
                                        }
                                    }
                                }
                                else if (Math.Abs(dy) > 0)
                                {
                                    if (dy * dy1 >= 0 && (Math.Abs(dy1) <= Math.Abs(dy)))
                                    {
                                        a = (dx * dy1);
                                        b = (dy * dx1);
                                        c = Math.Abs(dy * ptol);
                                        if (Math.Abs(a - b) <= c)
                                        {
                                            if (Math.Abs(a - b) <= c)
                                            {
                                                iDraw = link;
                                                return iDraw;
                                            }
                                        }
                                    }
                                }

        void timer_Tick(object sender, EventArgs e)
        {
            if (this.selectedFigure == null)
                return;

            using (Graphics g = this.panel_drawPaper.CreateGraphics())
            {
                Global global = Global.GetInstance();
                
                Point point = this.PointToScreen(this.selectedFigure.Location);
                point =new Point(point.X-2, point.Y-2);

                Rectangle rect = new Rectangle(point, new Size(global.DrawManager.DrawSize+5, global.DrawManager.DrawSize+5));

                ControlPaint.FillReversibleRectangle(rect, Color.Black);
            }
        }

    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        // The following three methods will draw a rectangle and allow 
        // the user to use the mouse to resize the rectangle.  If the 
        // rectangle intersects a control's client rectangle, the 
        // control's color will change.

        bool isDrag = false;
        Rectangle theRectangle = new Rectangle
            (new Point(0, 0), new Size(0, 0));
        Point startPoint;

        private void Form1_MouseDown(object sender,
            System.Windows.Forms.MouseEventArgs e)
        {

            // Set the isDrag variable to true and get the starting point 
            // by using the PointToScreen method to convert form 
            // coordinates to screen coordinates.
            if (e.Button == MouseButtons.Left)
            {
                isDrag = true;
            }

            Control control = (Control)sender;

            // Calculate the startPoint by using the PointToScreen 
            // method.
            startPoint = control.PointToScreen(new Point(e.X, e.Y));
        }

        private void Form1_MouseMove(object sender,
            System.Windows.Forms.MouseEventArgs e)
        {

            // If the mouse is being dragged, 
            // undraw and redraw the rectangle as the mouse moves.
            if (isDrag)

            // Hide the previous rectangle by calling the 
            // DrawReversibleFrame method with the same parameters.
            {
                ControlPaint.DrawReversibleFrame(theRectangle,
                    this.BackColor, FrameStyle.Dashed);

                // Calculate the endpoint and dimensions for the new 
                // rectangle, again using the PointToScreen method.
                Point endPoint = ((Control)sender).PointToScreen(new Point(e.X, e.Y));

                int width = endPoint.X - startPoint.X;
                int height = endPoint.Y - startPoint.Y;
                theRectangle = new Rectangle(startPoint.X,
                    startPoint.Y, width, height);

                // Draw the new rectangle by calling DrawReversibleFrame
                // again.  
                ControlPaint.DrawReversibleFrame(theRectangle,
                    this.BackColor, FrameStyle.Dashed);
            }
        }

        private void Form1_MouseUp(object sender,
            System.Windows.Forms.MouseEventArgs e)
        {

            // If the MouseUp event occurs, the user is not dragging.
            isDrag = false;

            // Draw the rectangle to be evaluated. Set a dashed frame style 
            // using the FrameStyle enumeration.
            ControlPaint.DrawReversibleFrame(theRectangle,
                this.BackColor, FrameStyle.Dashed);

            // Find out which controls intersect the rectangle and 
            // change their color. The method uses the RectangleToScreen  
            // method to convert the Control's client coordinates 
            // to screen coordinates.
            Rectangle controlRectangle;
            for (int i = 0; i < Controls.Count; i++)
            {
                controlRectangle = Controls[i].RectangleToScreen(Controls[i].ClientRectangle);
                if (controlRectangle.IntersectsWith(theRectangle))
                {
                    Controls[i].BackColor = Color.BurlyWood;
                }
            }

            // Reset the rectangle.
            theRectangle = new Rectangle(0, 0, 0, 0);
        }



    }