동구의 블로그

/* 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);
        }



    }

void Document_PrintPage(object sender, System.Drawing.Printing.PrintPageEventArgs e) 
{ 
   int itar=0; 
   foreach (char c in this.richTextBox.Text) 
   { 
      if (c != '\n') 
      { 
         this.richTextBox.Select(itar, 1); 
         Point point = this.richTextBox.GetPositionFromCharIndex(itar); 
         e.Graphics.DrawString(c.ToString(), this.richTextBox.SelectionFont, new SolidBrush(this.richTextBox.SelectionColor), point); 
      } 
      itar++; 
   } 
}  

namespace 순열
{
    class Program
    {
        static void Main(string[] args)
        {
            char[] datas = new char[] { 'a', 'b','c' };

            Perm(datas, 0);

            Console.ReadKey();
        }

        /// <summary>
        /// 순열을 출력한다.
        /// </summary>
        /// <param name="a"></param>
        /// <param name="k"></param>
        private static void Perm(char[] a, int k)
        {
            if (k == a.Length - 1)//순열을 출력
            {
                for (int i = 0; i < a.Length; i++)
                {
                    Console.Write("{0} ", a[i]);
                }
                Console.WriteLine();
            }
            else
            {
                for (int i = k; i < a.Length; i++)
                {
                    //a[k]와 a[i]를 교환
                    char temp = a[k];
                    a[k] = a[i];
                    a[i] = temp;

                    Perm(a, k + 1); //a[k+1],…,a[n-1]에 대한 모든 순열
                    //원래 상태로 되돌리기 위해 a[k]와 a[i]를 다시 교환
                    temp = a[k];
                    a[k] = a[i];
                    a[i] = temp;
                }
            }
        }
    }
}