[Object C] Alert Yes/No Button

- (IBAction)NewGame_Button:(id)sender

{

UIAlertView *alert = [[UIAlertView alloc] init];

[alert setTitle:@"경고"];

[alert setMessage:@"새게임을 시작하면 기존 데이터는 모두 지워집니다."];

[alert setDelegate:self];

[alert addButtonWithTitle:@"Yes"];

[alert addButtonWithTitle:@"Cancle"];

[alert show];

[alert release];

}

이후 아래 함수를 사용하면 Delegate가 알아서 잡아줌 

- (void)alertView:(UIAlertView *)alertView clickedButtonAtIndex:(NSInteger)buttonIndex

{

if (buttonIndex == 0)

{

NSLog(@"YES");

}

else if (buttonIndex == 1)

{

NSLog(@"NO");

}

}

[C#] String To Byte

byte[] StringToByte = Encoding.Default.GetBytes("STRING!!!!");

[C#] Process Kill

PKILL = 프로세스 이름
ex) notepad

// 프로세스 킬
        public void PKILL(string PKILL)
        {

            ProcessStartInfo cmd = new ProcessStartInfo();
            Process process = new Process();
            cmd.FileName = @"cmd";
            cmd.WindowStyle = ProcessWindowStyle.Hidden;
            cmd.CreateNoWindow = true;
            cmd.UseShellExecute = false;
            cmd.RedirectStandardOutput = true;
            cmd.RedirectStandardInput = true;
            cmd.RedirectStandardError = true;
            process.EnableRaisingEvents = false;
            process.StartInfo = cmd;
            process.Start();

            string cmd1 = "\"IMAGENAME eq ";  

            process.StandardInput.Write(@"C:\windows\system32\taskkill.exe /fi " + cmd1 + PKILL + "*\"" + Environment.NewLine);

            process.StandardInput.Close();
            process.Close();
        }

[C#] Mouse Capture -> 화면캡쳐에 적용

입력 = int, int
출력 = Bitmap

using System.Runtime.InteropServices;


        private Bitmap CaptureCursor(ref int x, ref int y)
        {
            Bitmap bmp;
            IntPtr hicon;

            Win32Stuff.CURSORINFO ci = new Win32Stuff.CURSORINFO();
            Win32Stuff.ICONINFO icInfo;
            ci.cbSize = Marshal.SizeOf(ci);
            if (Win32Stuff.GetCursorInfo(out ci))
            {
                if (ci.flags == Win32Stuff.CURSOR_SHOWING)
                {
                    hicon = Win32Stuff.CopyIcon(ci.hCursor);
                    if (Win32Stuff.GetIconInfo(hicon, out icInfo))
                    {
                        x = ci.ptScreenPos.x - ((int)icInfo.xHotspot);
                        y = ci.ptScreenPos.y - ((int)icInfo.yHotspot);
                        Icon ic = Icon.FromHandle(hicon);
                        bmp = ic.ToBitmap();

                        return bmp;
                    }
                }
            }
            return null;
        }



캡쳐된 화면에 그리는법


// 마우스 커서 캡쳐
int iCurX = 0;
int iCurY = 0;
Bitmap Cur = CaptureCursor(ref iCurX, ref iCurY);
Rectangle curRec = new Rectangle(iCurX, iCurY, Cur.Width, Cur.Height); // 마우스넣을 사각형
g.DrawImage(Cur, curRec); // 캡쳐한 화면(g)에 마우스 그려넣기

[C#] Win32Stuff Class

using System.Runtime.InteropServices;


    class Win32Stuff
    {

        #region Class Variables

        public const int SM_CXSCREEN = 0;
        public const int SM_CYSCREEN = 1;

        public const Int32 CURSOR_SHOWING = 0x00000001;

        [StructLayout(LayoutKind.Sequential)]
        public struct ICONINFO
        {
            public bool fIcon;         // Specifies whether this structure defines an icon or a cursor. A value of TRUE specifies
            public Int32 xHotspot;     // Specifies the x-coordinate of a cursor's hot spot. If this structure defines an icon, the hot
            public Int32 yHotspot;     // Specifies the y-coordinate of the cursor's hot spot. If this structure defines an icon, the hot
            public IntPtr hbmMask;     // (HBITMAP) Specifies the icon bitmask bitmap. If this structure defines a black and white icon,
            public IntPtr hbmColor;    // (HBITMAP) Handle to the icon color bitmap. This member can be optional if this
        }
        [StructLayout(LayoutKind.Sequential)]
        public struct POINT
        {
            public Int32 x;
            public Int32 y;
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct CURSORINFO
        {
            public Int32 cbSize;        // Specifies the size, in bytes, of the structure.
            public Int32 flags;         // Specifies the cursor state. This parameter can be one of the following values:
            public IntPtr hCursor;          // Handle to the cursor.
            public POINT ptScreenPos;       // A POINT structure that receives the screen coordinates of the cursor.
        }

        #endregion


        #region Class Functions

        [DllImport("user32.dll", EntryPoint = "GetDesktopWindow")]
        public static extern IntPtr GetDesktopWindow();

        [DllImport("user32.dll", EntryPoint = "GetDC")]
        public static extern IntPtr GetDC(IntPtr ptr);

        [DllImport("user32.dll", EntryPoint = "GetSystemMetrics")]
        public static extern int GetSystemMetrics(int abc);

        [DllImport("user32.dll", EntryPoint = "GetWindowDC")]
        public static extern IntPtr GetWindowDC(Int32 ptr);

        [DllImport("user32.dll", EntryPoint = "ReleaseDC")]
        public static extern IntPtr ReleaseDC(IntPtr hWnd, IntPtr hDc);


        [DllImport("user32.dll", EntryPoint = "GetCursorInfo")]
        public static extern bool GetCursorInfo(out CURSORINFO pci);

        [DllImport("user32.dll", EntryPoint = "CopyIcon")]
        public static extern IntPtr CopyIcon(IntPtr hIcon);

        [DllImport("user32.dll", EntryPoint = "GetIconInfo")]
        public static extern bool GetIconInfo(IntPtr hIcon, out ICONINFO piconinfo);


        #endregion
    }

[C#] GZipCompress GZip압축클래스

입력 = Byte[]
출력 = Byte[]

using System.IO.Compression;


    public static class GZipCompress
    {
   
        public static byte[] Compress(byte[] buffer)
        {
            MemoryStream ms = new MemoryStream();
            GZipStream zip = new GZipStream(ms, CompressionMode.Compress, true);
            zip.Write(buffer, 0, buffer.Length);
            zip.Close();
            ms.Position = 0;

            MemoryStream outStream = new MemoryStream();

            byte[] compressed = new byte[ms.Length];
            ms.Read(compressed, 0, compressed.Length);

            byte[] gzBuffer = new byte[compressed.Length + 4];
            Buffer.BlockCopy(compressed, 0, gzBuffer, 4, compressed.Length);
            Buffer.BlockCopy(BitConverter.GetBytes(buffer.Length), 0, gzBuffer, 0, 4);
            return gzBuffer;
        }

        public static byte[] Decompress(byte[] gzBuffer)
        {
            MemoryStream ms = new MemoryStream();
            int msgLength = BitConverter.ToInt32(gzBuffer, 0);
            ms.Write(gzBuffer, 4, gzBuffer.Length - 4);

            byte[] buffer = new byte[msgLength];

            ms.Position = 0;
            GZipStream zip = new GZipStream(ms, CompressionMode.Decompress);
            zip.Read(buffer, 0, buffer.Length);

            return buffer;
        }
    }

[C#] Byte + Byte 함수

        public static byte[] byte_merge(byte[] arg1, byte[] arg2)
        {
            byte[] tmp = new byte[arg1.Length + arg2.Length];
            for (int i = 0; i < arg1.Length; i++)
            {
                tmp[i] = arg1[i];
            }
            for (int j = 0; j < arg2.Length; j++)
            {
                tmp[arg1.Length + j] = arg2[j];
            }
            return tmp;
        }