김용유닷컴

주말은…

희자매파파 — Sat, 13 May 2023 11:02:40 +0900

나의 주말은 언제나 작은애와 함께 시작한다.

아침에 언어치료를 하고 바로 합창단 연습으로 이동하고… 합창단 연습이 끝나면 바로 또 이동해 노래 수업으로 이동..
끝나고 나면 상황 봐서 큰애를 픽업하러 가고..

그게 아니면 작은애와 집으로 가든지.. 아님 작은애와 데이트…
그것도 아니면 엄니집으로 가서 엄니 만나기…

매주 거의 같은 패턴이다.. 바쁠때면 이 패턴이 깨지긴 하지만..
돈만 많다면 이 패턴도 괜찮은데.. 돈 없이 이런 패턴을 이어가는건 좀 불안하다.

신방도서관에 오다

희자매파파 — Wed, 10 May 2023 11:43:18 +0900

간만에 집(사무실)에서 나와서 도서관에 왔다.
이곳 도서관은 처음 와 본 듯..
근데 생각보다 많이 커서 조금은 놀랐다.
동네에 있는 작은 도서관과 달리 규모도 크고..’
아마 주변에 있는 아파트 영향인듯..

천안에 이런 큰 도서관도 많다는 걸.. 잘 다니지를 않아서..
한동안은 이런 저런 도서관에 많이 다녔는데..

벤치에 앉아서 잠깐의 여유를 즐기는 것도 괜찮은 듯 싶다.

카페에 오다..

희자매파파 — Fri, 5 May 2023 13:18:17 +0900

31년만에 비 오는 어린이날이라고 한다.
어디 가기도 그렇고.. 집에 어린이도 없고..
청소년과 어른이만 있는 집이라서 그냥 집에 있으려고 했으나..
작은 청소년님이 카페를 가보고 싶다고 해서 집에서 멀지 않은 카페를 찾았다.

타타 베이글이란 베이글 전문 카페라고 해서 왔는데.. 12시가 지난줄 모르고 모닝 세트를 시켰으나.. 시간이 지났다고 주문 실패…

그래서 그냥 음료에 베이글 주문..

음료를 마시며 앉아서 지금 이 블로그 작성중..

나머지 일정은 올리게 되면 다시 올릴 것임..

만차

희자매파파 — Sun, 16 Apr 2023 00:14:05 +0900

이날 주차 할데가 없었다. 결국 10분 넘게 목적지에서 도보로 10분 거리에 주차함. ㅠㅠ

블로그를 다시 써 보려고 합니다.

희자매파파 — Sun, 16 Apr 2023 00:01:26 +0900

블로그를 만들어 놓고 한 동안 쓰지를 않고 있었습니다.

낼모레면 반백살이 되어 가게 되면서 어딘가에 나의 흔적을 남겨 놓고 싶다는 생각이 듭니다.

그래서 한동안 놓았던 블로깅을 다시 시작해 볼까 합니다.

우선 세운 목표는 최소 일주일에 한 번씩 공부하거나 느낀 점들을 블로그에 남겨 두려고 합니다.

너무 게을러지지 않는 나를 위해.

이런저런 정보도 모아 놓고 누군가에게 나의 경험이 도움이 되길 바라며...

이제 다시 시작해 보자고!!

사는것이란....

희자매파파 — Sat, 15 Apr 2023 23:54:49 +0900

사람들은 사는게 뭐라고 물어보면.. 이런 저런 이야기를 한다..

"죽지 못해 사는거지.."

"그냥.. 사는 거야.."

"오늘보다는 내일이 나을것이라는 믿음(?)으로 사는거지.."

등등... 사람들의 생각은 모두 다 다를 것이다..

자신의 삶이 남에게 피해를 주지만 않는다면 어떤 삶이든 잘못되지는 않는다고 생각한다..

사람마다 행복의 가치가 다르고.., 추구하는 바가 다르고...

너의 삶이 틀렸다고 말하는 사람이 있을수도 있고.. 그렇게 살지 말라고 하는 사람도 있을 수 있다.

하지만, 누가 뭐라든 당신의 삶의 주인공은 당신이고 당신이 노력하는 바에 따라 달라질 수가 있는 것이다.

눈치 보지 마라..

너의 행동에 책임을 질 수만 있다면 너의 행동. 생각. 말은 모두 다 틀린것이 아니다.

다만 남과 다를뿐..

Windows 전원 모드 추가 명령어

희자매파파 — Tue, 21 Dec 2021 13:45:23 +0900

-고성능
powercfg -duplicatescheme 8c5e7fda-e8bf-4a96-9a85-a6e23a8c635c

- 최고의 성능
powercfg -duplicatescheme e9a42b02-d5df-448d-aa00-03f14749eb61

- 절전
powercfg -duplicatescheme a1841308-3541-4fab-bc81-f71556f20b4a

- 균형 조정
powercfg -duplicatescheme 381b4222-f694-41f0-9685-ff5bb260df2e

OpenCV를 CODESYS에 설치 가능한 패키지..

희자매파파 — Wed, 30 Jun 2021 10:10:53 +0900

메뉴얼상에 나오는 패키지...
sudo apt-get install libopencv-dev=2.4.9.1+dfsg-1+deb8u1. <-- 설치 안됨

sudo apt-get install libopencv-dev=3.2.0+dfsg-6 <- 2021.06.30 설치 가능 버전

Windows10 God Mode 만들기

희자매파파 — Tue, 1 Dec 2020 11:45:13 +0900

설정 및 실행방법

1. 바탕화면 등에 새 폴더를 하나를 만들기로 하고 ..

2. 폴더의 이름을 GodMode.{ED7BA470-8E54-465E-825C-99712043E01C} 로 설정한다

3. 폴더 더블클릭해 실행한다.

-. 즐겨찾기에 고정해두면 다음부터는 그냥 빠른 실행 가능함.

웬만한 윈도우 설정을 관리할 수 있음.

시작프로그램을 레지스트리에서 직접 수정하기

희자매파파 — Tue, 10 Dec 2019 13:45:29 +0900

윈도우에서 실행창(윈도우키 + R)을 실행시키고 regedit를 입력해 레지스트리 편집기를 실행시킨 후 다음 위치에 있는 실행 파일 중 필요 없는 파일만 삭제하면 된다.

HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run

HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\RunOnce

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\RunOnce

HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Run

HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\RunOnce

이렇게 처리한 후 재부팅해보면 원하는 시작프로그램만 실행하게 됨

sprintf 함수 관련 수집

희자매파파 — Sun, 19 Aug 2018 10:24:52 +0900

sprintf

#include <stdio.h> // C++ 에서는 <cstdio>

int sprintf ( char * str, const char * format, ... );

str 에 데이터를 형식에 맞추어 쓴다.
str 가 가리키는 배열에 형식 문자열에 지정한 방식 대로 C 문자열을 쓴다. 쉽게 설명하자면, printf 에서 화면에 출력하는 대신에 화면에 출력할 문자열을 인자로 지정한 문자열에 쓴다는 것이다. 이 때, 인자로 지정한 배열의 크기는 배열에 쓰여질 문자열의 크기 보다 커야만 한다. 주의할 점은 sprintf 함수는 자동적으로 str 맨 마지막에 NULL 문자를 붙이기 때문에 항상 한 칸의 여유가 있어야 한다.

인자

str

C 문자열이 저장될 char 배열을 가리키는 포인터

format

위 str 에 쓰여질 문자열을 포함하는 형식 문자열으로, 이는 형식 태그를 포함할 수 있다. 이 때, 형식 태그는 부수적 인자로 지정한 데이터와 치환되어 쓰여지게 된다. 이 때, 데이터가 치환되는 방식은 형식 태그에 의해 좌우된다. 따라서 부수적 인자의 개수는 적어도 형식 문자열에 사용된 형식 태그의 수 보다 많아야 한다.

형식 태그는 아래와 같이 생겼다.

%[플래그(flag)][폭(width)][.정밀도][크기(length)]서식 문자(specifier)

이 때 서식 문자(specifier) 는 대응하는 인자를 어떠한 형태로 표현할지를 결정하는데에 가장 중요한 역할을 한다.

서식문자	출력 형태	예
`c`	문자	`a`
`d` or `i`	부호 있는 십진법으로 나타난 정수	`392`
`e`	지수 표기법(Scientific notation) 으로 출력하되, e 문자를 이용한다.	`3.9265e+2`
`E`	지수 표기법(Scientific notation) 으로 출력하되, E 문자를 이용한다.	`3.9265E+2`
`f`	십진법으로 나타낸 부동 소수점 수	`392.65`
`g`	%e 나 %f 보다 간략하게 출력	`392.65`
`G`	%E 나 %f 보다 간략하게 출력	`392.65`
`o`	부호 있는 팔진수	`610`
`s`	문자열	`sample`
`u`	부호없는 십진법으로 나타낸 정수	`7235`
`x`	부호없는 16 진법으로 나타낸 정수 (소문자 사용)	`7fa`
`X`	부호없는 16 진법으로 나타낸 정수 (대문자 사용)	`7FA`
`p`	포인터 주소	`B800:0000`
`n`	아무것도 출력하지 않는다. 그 대신, 인자로 부호 있는 int 형을 가리키는 포인터를 전달해야 되는데, 여기에 현재까지 쓰여진 문자 수가 저장된다.
`%`	% 다음에 %를 또 붙이면 stdout 에 % 를 출력한다.

위 서식 문자를 이용한 다양한 출력 형태는 아래와 같다.

#include <stdio.h>
int main()
{
    int integer = 123;
    char character = 'c';
    char string[] = "hello, world";
    int* pointer = &integer;
    double pi = 3.141592;
   char buf[100];


    sprintf(buf, "integer : (decimal) %d (octal) %o \n", integer, integer);
   printf("%s \n", buf);

    sprintf(buf,"character : %c \n", character);
   printf("%s \n", buf);

    sprintf(buf,"string : %s \n", string);
   printf("%s \n", buf);

    sprintf(buf,"pointer addr : %p \n", pointer);
   printf("%s \n", buf);

    sprintf(buf,"floating point : %e // %f \n", pi, pi);
   printf("%s \n", buf);

    sprintf(buf,"percent symbol : %% \n");
   printf("%s \n", buf);

    return 0;
}

출력 결과

형식 태그에는 위 말고도 플래그, 폭, .정확도, 제한자(modifier), 부-서식문자(sub-specifiers) 에 관련된 정보들이 포함될 수 있다. 먼저 플래그를 살펴보면 플래그는 기본적으로 출력되는 형태에 대해 조금 더 자세하게 지정할 수 있게 해준다. 플래그는 아래와 같다.

플래그	설명
`-`	폭에 맞추어 왼쪽 정렬을 하여 출력한다. - 를 붙이지 않는다면 기본적으로 오른쪽 정렬이 되어 출력한다. (아래 폭 지정자 참조).
`+`	출력 결과값이 양수인 경우라도 + 기호를 앞에 붙여서 출력하도록 한다. (물론 음수면 자동적으로 - 가 붙는다). 기본적으로 지정하지 않았을 경우 음수에만 앞에 - 가 붙는다.
(공백)	앞에 부호가 붙지 않는다면 한 칸을 띄어서 출력한다. (다시말해 123 은 " 123" 으로 출력되고 -123 은 "-123" 으로 출력된다)
`#`	o, x, X 서식 문자들과 사용되면 출력되는 값 앞에 각각 0, 0x, 0X 가 붙게 된다. (이 때 0 은 제외한다) e, E, f 서식 문자들과 사용되면 소수점 아래 수들이 없음에도 불구하고 강제적으로 소수점을 붙이도록 한다. 원래 소수점 아래 수들이 없다면 소수점을 붙이지 않는다. g 와 G 서식 문자들과 사용되면 e 와 E 일때와 동일한 작업을 하지만 소수들의 뒷부분에 붙는 0 들 (123.1200 등) 은 제거되지 않는다.
`0`	수들을 왼쪽으로 정렬하되 빈 칸을 삽입하는 대신에 0 을 삽입한다. (폭 지정자 참조)

폭은 말그대로 출력되는 데이터의 폭을 지정해준다. 참고로 여기서의 폭(width)은 뒤에 나오는 길이(length) 와는 완전히 다른 개념이므로 유의 하시기 바란다.

폭	설명
(수)	출력할 최소의 문자 개수. 만일 이 수 보다 출력할 수 보다 작다면 빈칸을 삽입하여 길이를 맞춘다. 대신에, 이 수 보다 출력할 수가 큰 수의 경우 잘려서 출력되지는 않는다.
`*`	폭을 형식 문자열에 지정해서 받지 않지만, 그 대신에 형식 문자열 뒤에 오는 인자들에 넣어서 받는다. 이 때, 이는 정수 값이여야 하며 폭을 지정하는 변수 뒤에 출력할 데이터가 위치하면 된다.

/* 사용 예 */
#include <stdio.h>
int main()
{
   FILE *fp = fopen("output.txt", "w");
   char buffer[100];
   int i = 123;
   int j = -123;
   double f = 3.141592;

   sprintf(buffer, "폭 맞추기 \n");
   fputs (buffer, fp);
   sprintf(buffer, "i : %6d \n", i);
   fputs (buffer, fp);
   sprintf(buffer, "i : %7d \n", i);
   fputs (buffer, fp);
   sprintf(buffer, "i : %2d \n\n", i);
   fputs (buffer, fp);

   sprintf(buffer, "왼쪽 정렬 \n");
   fputs (buffer, fp);
   sprintf(buffer, "i : %5d끝 \n", i);
   fputs (buffer, fp);
   sprintf(buffer, "오른쪽 정렬 \n");
   fputs (buffer, fp);
   sprintf(buffer, "i : %-5d끝 \n\n", i);
   fputs (buffer, fp);

   sprintf(buffer, "# 문자의 사용 \n");
   fputs (buffer, fp);
   sprintf(buffer, "i : %#x \n", i);
   fputs (buffer, fp);
   sprintf(buffer, "i : %#X \n\n", i);
   fputs (buffer, fp);

   sprintf(buffer, "부호 붙이기 \n");
   fputs (buffer, fp);
   sprintf(buffer, "%+d, %+d \n", i,j);
   fputs (buffer, fp);
   return 0;
}

출력 결과

파일에 쓰여진 모습

정밀도는 말그대로 수치 데이터를 출력할 때 어떠한 정밀도로 출력하는지 (즉, 몇 자리 까지 출력해야 되는지) 를 지정해준다. 참고적으로 정밀도를 나타낼 때, 앞에 꼭 마침표(.) 을 찍는 것을 잊지 말기 바란다. 마침표를 찍는 이유는 앞에 폭과 구분을 하기 위해서 이다.

. 정밀도 설명

.숫자 정수 지정자 (d,i,o,u,x,X) 의 경우 : 정밀도는 출력되야할 최소의 자리수를 일컫는다. 만일, 어떤 정수의 자리수가 정밀도 보다 작다면 앞에 0 이 붙어서 자리수를 맞추게 된다. 또한 자리수가 더 크다고 해서 정수를 잘라서 출력하지는 않는다. 만일 정밀도가 0 이라면, 소수점 뒤에 자리수를 출력하지 않는다.
e,E, F 의 경우 : 여기서 정밀도는 소수점 이하 출력될 자리수를 의미한다.
g, G 의 경우 : 출력될 유효 숫자의 수를 의미한다.
s 의 경우 : 출력될 문자의 최대 개수를 의미한다. 원래는 널 문자를 만나기 전까지 모든 문자가 출력되었었다.
c 의 경우 : 아무 효과 없다.
만일 정밀도가 지정되지 않는다면 기본값으로 1 이 된다. 또한, 마침표(.) 을 찍었는데 아무런 숫자를 적지 않았다면 기본적으로 0 이 적혔다고 생각한다.

.* 형식 문자열에서 정밀도를 나타내지는 않지만 뒤에 인자로 정밀도 값을 준다. 이 때 인자는 형식 태그가 적용되는 데이타 앞에 있어야 한다.

. 정밀도	설명
.숫자	정수 지정자 (d,i,o,u,x,X) 의 경우 : 정밀도는 출력되야할 최소의 자리수를 일컫는다. 만일, 어떤 정수의 자리수가 정밀도 보다 작다면 앞에 0 이 붙어서 자리수를 맞추게 된다. 또한 자리수가 더 크다고 해서 정수를 잘라서 출력하지는 않는다. 만일 정밀도가 0 이라면, 소수점 뒤에 자리수를 출력하지 않는다. e,E, F 의 경우 : 여기서 정밀도는 소수점 이하 출력될 자리수를 의미한다. g, G 의 경우 : 출력될 유효 숫자의 수를 의미한다. s 의 경우 : 출력될 문자의 최대 개수를 의미한다. 원래는 널 문자를 만나기 전까지 모든 문자가 출력되었었다. c 의 경우 : 아무 효과 없다. 만일 정밀도가 지정되지 않는다면 기본값으로 1 이 된다. 또한, 마침표(.) 을 찍었는데 아무런 숫자를 적지 않았다면 기본적으로 0 이 적혔다고 생각한다.
`.*`	형식 문자열에서 정밀도를 나타내지는 않지만 뒤에 인자로 정밀도 값을 준다. 이 때 인자는 형식 태그가 적용되는 데이타 앞에 있어야 한다.

길이는 출력하는 데이터의 정확한 크기를 지정하는데 사용된다. 예를 들어서 %d 서식문자의 경우 막연하게 '정수형 데이터를 십진법으로 출력한다' 였지만 길이를 지정해주면 어떻나 크기로 데이터를 출력해야되는지 (int 냐 short 냐 등등) 을 지정할 수 있다.

길이	설명
`h`	인자를 short int 혹은 unsigned short int 로 생각한다. (오직 i, d, o, u , x, X 서식 문자에만 적용된다)
`l`	정수 서식 문자(i,d,o,u,x, X) 에 사용되었을 경우 인자를 long int 나 unsigned long int 로 생각하며 c 나 s 에 사용되었을 경우 wide character 나 wide string 으로 생각한다.
`L`	인자를 long double 로 생각한다. (오직 부동 소수점 서식 문자인 e,E,f,g, G 에만 적용된다)

/* 사용 예 */
#include <stdio.h>
int main()
{
    double f = 3.141592;
    int i = 12345;
    char buffer[100];

    sprintf(buffer, "f : %.3f \n", f);
    printf("buf: %s \n", buffer);
    sprintf(buffer, "i : %.10d \n", i);
    printf("buf : %s \n", buffer);

    return 0;
}

출력 결과

부수적인 인자

형식 문자열에 따라 함수는 여러 인자들을 가지며, 각 인자는 형식 문자열의 각 형식 태그에 순차적으로 대응된다. 기본적으로 형식 문자열에 들어 있는 형식 태그의 수와 뒤따라 붙는 인자들의 수는 같아야 한다. (물론 .* 이나 * 과 같은 예외적인 상황은 제외한다)

sprintf 함수의 활용 - 수를 문자열로 바꾸기

sprintf 함수를 잘 이용하면 수를 손쉽게 문자열로 바꿀 수 있다. 바로 다음과 같이.

#include <stdio.h>
int main()
{
    int i;
    char str[100];

    scanf("%d", &i);
    sprintf(str, "%d", i);

    printf("str : %s \n", str);

    return 0;
}

실행 결과

i 의 값을 %d 의 형태로 str 에 문자열로 넣었으니 str 에는 i 의 값이 문자열의 형태로 변환된다.
마찬가지 방법으로 i 의 값을 16 진수나 8 진수 형태로 (%x, %o) 넣을 수 도 있다.

리턴값

str 에 쓰기가 성공할 경우 쓰여진 총 문자의 개수가 반환된다. 이 때, 이 문자의 개수는 맨 마지막에 자동적으로 붙는 NULL 문자는 포함하지 않는다.
실패할 경우 음수가 리턴된다.

실행 예제

/*

sprintf 함수 예제
이 예제는 http://www.cplusplus.com/reference/clibrary/cstdio/sprintf/
에서 가져왔습니다.

*/
#include <stdio.h>
int main ()
{
    char buffer [50];
    int n, a=5, b=3;
    n=sprintf (buffer, "%d plus %d is %d", a, b, a+b);
    printf ("[%s] is a %d char long string\n",buffer,n);
    return 0;
}

실행 결과

연관된 함수

printf : 표준 출력(stdout) 에 데이터를 형식에 맞추어 출력한다.
sscanf : 문자열에서 데이터를 형식에 맞추어 읽는다.

출처: http://itguru.tistory.com/66 [Programming IT]

비트, HEXA 연산하기

희자매파파 — Fri, 3 Aug 2018 16:52:06 +0900

BIT / HEXA 연산

<범례>

BIT * 지정 BIT 값을 방법

HEX * 지정 HEXA 값을 변경.

* 지정 비트를 1로 만드는 방법 (+)

bitwise OR 오퍼레이터 (|)를 사용해 변경.

BIT number |= << n n번째 비트를 1로 설정됨

HEX number |= 0xHH 0xHH 값을 더해줌..

* 지정 비트를 0으로 만드는 방법 (-)

bitwise AND 오퍼레이터(&)를 사용해 변경

BIT number &= ~(1<< n) n번째 비트를 0으로 설정됨

HEX number &= ~(0xHH) 0xHH 값을 빼줌..

* 지정 비트가 0이면 1, 1이면 0으로 만드는 방법 (XOR)

XOR 오퍼레이터 (^) 를 사용해 변경

BIT number ^= 1 << n n번째 비트가 1이면 0, 0이면 1으로 설정됨.

HEX number ^= 0xHH 값의 비트를 반대로 설정

* n번째 비트를 알아내는 방법 (CHECK)

bitwise AND 오퍼레이터(&)를 사용해 변경

BIT (number >> n) & 1 n번째 비트가 1이면 1을, 0면 0을 리턴함.

HEX number & 0xHH 0xHH 값이 존재하면 1 없으면 0

VCL(C++ Builder, Delphi) 기본 색상표 정의표

희자매파파 — Tue, 3 Jul 2018 16:07:34 +0900

VCL 기본 색상 정의표
VCL 이름	색상표	색상	지정명	색상
clNone	$1FFFFFFF		NONE
clAqua	$FFFF00		AQUA
clBlack	$0		BLACK
clBlue	$FF0000		BLUE
clCream	$F0FBFF		CREAM
clDkGray	$808,080		DKGRAY
clFuchsia	$FF00FF		FUCHSIA
clGray	$808,080		GRAY
clGreen	$8,000		GREEN
clLime	$00FF00		LIME
clLtGray	$C0C0C0		LTGRAY
clMaroon	$80		MAROON
clMedGray	$A4A0A0		MEDGRAY
clMoneyGreen	$C0DCC0		MONEYGREEN
clNavy	$800,000		NAVY
clOlive	$8,080		OLIVE
clPurple	$800,080		PURPLE
clRed	$0000FF		RED
clSilver	$C0C0C0		SILVER
clSkyBlue	$F0CAA6		SKYBLUE
clTeal	$808,000		TEAL
clWhite	$FFFFFF		WHITE
clYellow	$00FFFF		YELLOW

clWebAliceBlue	$FFF8F0		WEBALICEBLUE
clWebAntiqueWhite	$D7EBFA		WEBANTIQUEWHITE
clWebAqua	$FFFF00		WEBAQUA
clWebAquamarine	$D4FF7F		WEBAQUAMARINE
clWebAzure	$FFFFF0		WEBAZURE
clWebBeige	$DCF5F5		WEBBEIGE
clWebBisque	$C4E4FF		WEBBISQUE
clWebBlack	$0		WEBBLACK
clWebBlanchedAlmond	$CDEBFF		WEBBLANCHEDALMOND
clWebBlue	$FF0000		WEBBLUE
clWebBlueViolet	$E22B8A		WEBBLUEVIOLET
clWebBrown	$2A2AA5		WEBBROWN
clWebBurlywood	$87B8DE		WEBBURLYWOOD
clWebCadetBlue	$A09E5F		WEBCADETBLUE
clWebChartreuse	$00FF7F		WEBCHARTREUSE
clWebChocolate	$1E69D2		WEBCHOCOLATE
clWebCoral	$507FFF		WEBCORAL
clWebCornFlowerBlue	$ED9564		WEBCORNFLOWERBLUE
clWebCornSilk	$DCF8FF		WEBCORNSILK
clWebCrimson	$3C14DC		WEBCRIMSON
clWebCyan	$FFFF00		WEBCYAN
clWebDarkBlue	$8B0000		WEBDARKBLUE
clWebDarkCyan	$8B8B00		WEBDARKCYAN
clWebDarkGoldenRod	$0B86B8		WEBDARKGOLDENROD
clWebDarkGray	$A9A9A9		WEBDARKGRAY
clWebDarkgreen	$6,400		WEBDARKGREEN
clWebDarkKhaki	$6BB7BD		WEBDARKKHAKI
clWebDarkMagenta	$8B008B		WEBDARKMAGENTA
clWebDarkOliveGreen	$2F6B55		WEBDARKOLIVEGREEN
clWebDarkOrange	$008CFF		WEBDARKORANGE
clWebDarkOrchid	$CC3299		WEBDARKORCHID
clWebDarkRed	$00008B		WEBDARKRED
clWebDarkSalmon	$7A96E9		WEBDARKSALMON
clWebDarkSeaGreen	$8FBC8F		WEBDARKSEAGREEN
clWebDarkSlateBlue	$8B3D48		WEBDARKSLATEBLUE
clWebDarkSlategray	$4F4F2F		WEBDARKSLATEGRAY
clWebDarkTurquoise	$D1CE00		WEBDARKTURQUOISE
clWebDarkViolet	$D30094		WEBDARKVIOLET
clWebDeepPink	$9314FF		WEBDEEPPINK
clWebDeepskyBlue	$FFBF00		WEBDEEPSKYBLUE
clWebDimGray	$696,969		WEBDIMGRAY
clWebDodgerBlue	$FF901E		WEBDODGERBLUE
clWebFirebrick	$2222B2		WEBFIREBRICK
clWebFloralWhite	$F0FAFF		WEBFLORALWHITE
clWebForestGreen	$228B22		WEBFORESTGREEN
clWebFuchsia	$FF00FF		WEBFUCHSIA
clWebGainsboro	$DCDCDC		WEBGAINSBORO
clWebGhostWhite	$FFF8F8		WEBGHOSTWHITE
clWebGold	$00D7FF		WEBGOLD
clWebGoldenRod	$20A5DA		WEBGOLDENROD
clWebGray	$808,080		WEBGRAY
clWebGreen	$8,000		WEBGREEN
clWebGreenYellow	$2FFFAD		WEBGREENYELLOW
clWebHoneydew	$F0FFF0		WEBHONEYDEW
clWebHotPink	$B469FF		WEBHOTPINK
clWebIndianRed	$5C5CCD		WEBINDIANRED
clWebIndigo	$82004B		WEBINDIGO
clWebIvory	$F0FFFF		WEBIVORY
clWebKhaki	$8CE6F0		WEBKHAKI
clWebLavender	$FAE6E6		WEBLAVENDER
clWebLavenderBlush	$F5F0FF		WEBLAVENDERBLUSH
clWebLawnGreen	$00FC7C		WEBLAWNGREEN
clWebLemonChiffon	$CDFAFF		WEBLEMONCHIFFON
clWebLightBlue	$E6D8AD		WEBLIGHTBLUE
clWebLightCoral	$8080F0		WEBLIGHTCORAL
clWebLightCyan	$FFFFE0		WEBLIGHTCYAN
clWebLightGoldenrodYellow	$D2FAFA		WEBLIGHTGOLDENRODYELLOW
clWebLightGreen	$90EE90		WEBLIGHTGREEN
clWebLightgrey	$D3D3D3		WEBLIGHTGREY
clWebLightPink	$C1B6FF		WEBLIGHTPINK
clWebLightSalmon	$7AA0FF		WEBLIGHTSALMON
clWebLightSeaGreen	$AAB220		WEBLIGHTSEAGREEN
clWebLightSkyBlue	$FACE87		WEBLIGHTSKYBLUE
clWebLightSlateGray	$998,877		WEBLIGHTSLATEGRAY
clWebLightSteelBlue	$DEC4B0		WEBLIGHTSTEELBLUE
clWebLightYellow	$E0FFFF		WEBLIGHTYELLOW
clWebLime	$00FF00		WEBLIME
clWebLimeGreen	$32CD32		WEBLIMEGREEN
clWebLinen	$E6F0FA		WEBLINEN
clWebMagenta	$FF00FF		WEBMAGENTA
clWebMaroon	$80		WEBMAROON
clWebMediumAquamarine	$AACD66		WEBMEDIUMAQUAMARINE
clWebMediumBlue	$CD0000		WEBMEDIUMBLUE
clWebMediumOrchid	$D355BA		WEBMEDIUMORCHID
clWebMediumPurple	$DB7093		WEBMEDIUMPURPLE
clWebMediumSeaGreen	$71B33C		WEBMEDIUMSEAGREEN
clWebMediumSlateBlue	$EE687B		WEBMEDIUMSLATEBLUE
clWebMediumSpringGreen	$9AFA00		WEBMEDIUMSPRINGGREEN
clWebMediumTurquoise	$CCD148		WEBMEDIUMTURQUOISE
clWebMediumVioletRed	$8515C7		WEBMEDIUMVIOLETRED
clWebMidnightBlue	$701,919		WEBMIDNIGHTBLUE
clWebMintcream	$FAFFF5		WEBMINTCREAM
clWebMistyRose	$E1E4FF		WEBMISTYROSE
clWebMoccasin	$B5E4FF		WEBMOCCASIN
clWebNavajoWhite	$ADDEFF		WEBNAVAJOWHITE
clWebNavy	$800,000		WEBNAVY
clWebOldLace	$E6F5FD		WEBOLDLACE
clWebOlive	$8,080		WEBOLIVE
clWebOliveDrab	$238E6B		WEBOLIVEDRAB
clWebOrange	$00A5FF		WEBORANGE
clWebOrangeRed	$0045FF		WEBORANGERED
clWebOrchid	$D670DA		WEBORCHID
clWebPaleGoldenrod	$AAE8EE		WEBPALEGOLDENROD
clWebPaleGreen	$98FB98		WEBPALEGREEN
clWebPaleTurquoise	$EEEEAF		WEBPALETURQUOISE
clWebPaleVioletRed	$9370DB		WEBPALEVIOLETRED
clWebPapayaWhip	$D5EFFF		WEBPAPAYAWHIP
clWebPeachPuff	$B9DAFF		WEBPEACHPUFF
clWebPeru	$3F85CD		WEBPERU
clWebPink	$CBC0FF		WEBPINK
clWebPlum	$DDA0DD		WEBPLUM
clWebPowderBlue	$E6E0B0		WEBPOWDERBLUE
clWebPurple	$800,080		WEBPURPLE
clWebRed	$0000FF		WEBRED
clWebRosyBrown	$8F8FBC		WEBROSYBROWN
clWebRoyalBlue	$E16941		WEBROYALBLUE
clWebSaddleBrown	$13458B		WEBSADDLEBROWN
clWebSalmon	$7280FA		WEBSALMON
clWebSandyBrown	$60A4F4		WEBSANDYBROWN
clWebSeaGreen	$578B2E		WEBSEAGREEN
clWebSeashell	$EEF5FF		WEBSEASHELL
clWebSienna	$2D52A0		WEBSIENNA
clWebSilver	$C0C0C0		WEBSILVER
clWebSkyBlue	$EBCE87		WEBSKYBLUE
clWebSlateBlue	$CD5A6A		WEBSLATEBLUE
clWebSlateGray	$908,070		WEBSLATEGRAY
clWebSnow	$FAFAFF		WEBSNOW
clWebSpringGreen	$7FFF00		WEBSPRINGGREEN
clWebSteelBlue	$B48246		WEBSTEELBLUE
clWebTan	$8CB4D2		WEBTAN
clWebTeal	$808,000		WEBTEAL
clWebThistle	$D8BFD8		WEBTHISTLE
clWebTomato	$4763FF		WEBTOMATO
clWebTurquoise	$D0E040		WEBTURQUOISE
clWebViolet	$EE82EE		WEBVIOLET
clWebWheat	$B3DEF5		WEBWHEAT
clWebWhite	$FFFFFF		WEBWHITE
clWebWhiteSmoke	$F5F5F5		WEBWHITESMOKE
clWebYellow	$00FFFF		WEBYELLOW
clWebYellowGreen	$32CD9A		WEBYELLOWGREEN

OCX 사용자가 강제로 등록하기..

희자매파파 — Fri, 8 Jun 2018 16:40:19 +0900

개발을 하다보면 외부 OCX를 쓸 일이 생기게 된다.

그래서, 기존에 사용하던 OCX를 올리려고 하다보면 윈도우 버전이 안 맞아서 되지 않는 경우가 있다..

그럴때 regsvr32를 실행시킬때 약간의 옵션(?)을 주어서 등록하면 된다.

regsvr32 /s /n /i:user [OCX 위치 이름]

이렇게도 안 되면 다른 방법을 찾아봐야 될듯..

RAD Studio 단축키

희자매파파 — Wed, 6 Jun 2018 14:40:09 +0900

RAD Studio 단축키

바로 가기	작업
Alt + [	해당 구분 기호를 찾습니다 (앞으로).
Alt + ]	해당 구분 기호를 찾습니다 (역방향).
Alt + ←	Alt + ↑ 또는 Ctrl + 클릭 (선언 부로 이동) 작업 이전 위치로 돌아갑니다.
Alt + F7	Messages View에 표시되기 전에 오류 또는 메시지의 위치로 이동합니다.
Alt + F8	Messages View에 표시된 다음 오류 또는 메시지의 위치로 이동합니다.
Alt + PgDn	다음 탭으로 이동합니다.
Alt + PgUp	이전 탭으로 이동합니다.
Alt + →	Alt + ← 작업 이전 위치로 이동합니다.
Alt + Shift + ↓	커서를 한 줄 아래로 이동하여 원래의 커서 위치의 오른쪽에서 단일 열에을 선택합니다.
Alt + Shift + End	커서 위치부터 현재 줄의 끝까지 선택합니다.
Alt + Shift + Home	커서 위치부터 현재 줄의 처음까지 선택합니다.
Alt + Shift + ←	왼쪽의 열을 선택합니다.
Alt + Shift + PgDn	커서를 한 화면 아래로 이동하고 원래의 커서 위치를 유지합니다.
Alt + Shift + PgUp	커서를 한 화면 위로 이동하고 원래의 커서 위치를 유지합니다.
Alt + Shift + →	오른쪽의 열을 선택합니다.
Alt + Shift + ↑	커서를 한 줄 위로 이동하여 원래의 커서 위치의 오른쪽에서 단일 열에을 선택합니다.
Alt + ↑	선언 부로 이동합니다.
Click + Alt + Mousemove	열 단위 블록을 선택합니다.
Ctrl + /	선택한 코드 블록의 각 행에 // 를 추가하여 코드를 주석으로 처리하거나, 제거합니다.
Ctrl + Alt + F12	열려있는 파일의 드롭 다운 목록을 표시합니다.
Ctrl + Alt + Shift + End	커서 위치에서 화면의 끝까지 열을 선택합니다.
Ctrl + Alt + Shift + Home	커서 위치에서 화면의 시작까지 열을 선택합니다.
Ctrl + Alt + Shift + ←	왼쪽의 열을 선택합니다.
Ctrl + Alt + Shift + PgDn	커서 위치에서 현재 파일의 끝까지 열을 선택합니다.
Ctrl + Alt + Shift + PgUp	커서 위치에서 현재 파일의 시작 부분까지 열을 선택합니다.
Ctrl + Alt + Shift + →	오른쪽의 열을 선택합니다.
Ctrl + BackSpace	커서의 왼쪽으로 한 단어를 삭제합니다 (앞의 공백까지의 문자가 삭제됩니다.)
Ctrl + Click	선언 부로 이동합니다.
Ctrl + Delete	현재 선택된 블록을 삭제합니다.
Ctrl + ↓	아래에 한 줄 스크롤합니다.
Ctrl + End	파일의 끝으로 이동합니다.
Ctrl + Enter	커서 위치의 파일을 엽니 다.
Ctrl + Home	파일의 시작 부분으로 이동합니다.
Ctrl + I	커서 위치에 탭 문자를 삽입합니다.
Ctrl + J	템플릿 팝업 메뉴를 엽니 다.
Ctrl + K + n	커서 위치에 책갈피 설정 ( n 은 0 ~ 9의 숫자).
Ctrl + K + E	현재 단어를 소문자로 변환합니다.
Ctrl + K + F	현재 단어를 대문자로 변환합니다.
Ctrl + K + T	커서 위치의 한 단어를 선택합니다.
Ctrl + ←	한 단어 왼쪽으로 이동합니다.
Ctrl + n	책갈피로 이동합니다 ( n 은 0-9의 책갈피 번호).
Ctrl + N	커서 위치에 줄 바꿈을 삽입합니다.
Ctrl + O + C	열 단위 블록 모드를 선택합니다.
Ctrl + O + K	열 단위 블록 모드를 해제합니다.
Ctrl + O + L	행 방향 블록 모드를 선택합니다.
Ctrl + O + O	컴파일러 옵션을 삽입합니다.
Ctrl + P	다음 문자를 ASCII 시퀀스로 해석합니다.
Ctrl + PgDn	화면의 맨 아래로 이동합니다.
Ctrl + PgUp	화면 상단으로 이동합니다.
Ctrl + Q + #	커서 위치에 책갈피를 설정합니다.
Ctrl + →	한 단어 오른쪽으로 이동합니다.
Ctrl + Shift + C	커서 위치의 클래스 선언에 대응하는 클래스 보완을 시작합니다.
Ctrl + Shift + #	커서 위치에 책갈피를 설정합니다.
Ctrl + Shift + B	버퍼 목록을 표시합니다.
Ctrl + Shift + ↓	선언에서 구현 또는 구현에서 선언으로 이동합니다.
Ctrl + Shift + Enter	사용 항목을 검색합니다.
Ctrl + Shift + J	동기화 편집 모드를 선택합니다.
Ctrl + Shift K-A	모든 코드 블록을 확장합니다.
Ctrl + Shift K + C	모든 클래스를 축소합니다.
Ctrl + Shift K + E	코드 블록을 축소합니다.
Ctrl + Shift K-G	초기화 / 종료 또는 인터페이스 / 구현
Ctrl + Shift K + M	모든 메서드를 축소합니다.
Ctrl + Shift K + N	네임 스페이스 / 단위를 축소합니다.
Ctrl + Shift K + O	코드 축소를 활성화 또는 비활성화 전환합니다.
Ctrl + Shift K + P	중첩 된 절차를 축소합니다.
Ctrl + Shift K + R	모든 영역을 축소합니다.
Ctrl + Shift K-T	현재 블록의 축소 및 확장을 전환합니다.
Ctrl + Shift K-U	코드 블록을 확장합니다.
Ctrl + Shift + End	커서 위치에서 현재 파일의 끝까지 선택합니다.
Ctrl + Shift + G	새로운 글로벌 고유 식별자 (GUID)를 삽입합니다.
Ctrl + Shift + Home	커서 위치에서 현재 파일의 처음까지 선택합니다.
Ctrl + Shift + I	선택된 블록을 들여 씁니다.
Ctrl + Shift + ←	커서의 왼쪽으로 한 단어를 선택합니다.
Ctrl + Shift + P	기록 된 키 스트로크 매크로를 재생합니다.
Ctrl + Shift + PgDn	커서 위치에서 화면의 하단까지를 선택합니다.
Ctrl + Shift + PgUp	커서 위치에서 화면 상단에서을 선택합니다.
Ctrl + Shift + R	키 스트로크 매크로 기록 시작 / 정지를 전환합니다.
Ctrl + Shift + →	커서의 오른쪽으로 한 단어를 선택합니다.
Ctrl + Shift + Space	코드 파라미터 팝업 창을 엽니 다.
Ctrl + Shift + T	[To-Do 항목 추가 대화 상자를 엽니 다.
Ctrl + Shift + Tab	이전 코드 페이지 (또는 파일)로 이동합니다.
Ctrl + Shift + Tab	이전 페이지로 이동합니다.
Ctrl + Shift + U	선택된 블록 들여 쓰기를 해제합니다.
Ctrl + Shift + ↑	선언에서 구현 또는 구현에서 선언으로 이동합니다.
Ctrl + Shift + Y	커서 위치부터 줄 끝까지 삭제합니다.
Ctrl + Space	코드 완성 팝업 창을 엽니 다.
Ctrl + T	오른쪽으로 한 단어를 삭제합니다 (다음 스페이스까지의 문자가 삭제됩니다.)
Ctrl + Tab	다음 코드 페이지 (또는 파일)로 이동합니다.
Ctrl + ↑	한 행 위로 스크롤합니다.
Ctrl + Y	현재 행을 삭제합니다.
F1	선택된 정규화 된 네임 스페이스의 도움말을 표시합니다.
Shift + Alt + arrow	열 단위 블록을 선택합니다.
Shift + BackSpace	커서의 왼쪽 문자를 삭제합니다.
Shift + ↓	커서를 한 화면 아래로 이동하여 원래의 커서 위치의 오른쪽에서 현재 위치까지 선택합니다.
Shift + End	커서 위치부터 현재 줄의 끝까지 선택합니다.
Shift + Enter	커서 위치에 새 줄을 삽입합니다.
Shift + Home	커서 위치부터 현재 줄의 처음까지 선택합니다.
Shift + ←	커서의 왼쪽 문자를 선택합니다.
Shift + PgDn	커서를 한 화면 아래로 이동하여 원래의 커서 위치의 오른쪽에서 현재 위치까지 선택합니다.
Shift + PgUp	커서를 한 화면 위로 이동하여 원래의 커서 위치의 왼쪽에서 현재 위치까지 선택합니다.
Shift + →	커서의 오른쪽 문자를 선택합니다.
Shift + Space	공백을 삽입합니다.
Shift + Tab	커서를 왼쪽으로 한 탭 위치로 이동합니다.
Shift + ↑	커서를 한 줄 위로 이동하여 원래의 커서 위치의 왼쪽에서 현재 위치까지 선택합니다.

참고

http://docwiki.embarcadero.com/RADStudio/XE5/en/Default_Keyboard_Shortcuts

크롬 속도 향상시키기 - chrome://flags 설정

희자매파파 — Thu, 22 Feb 2018 09:51:51 +0900

크롬 카나리 기준 V20, PC, 노트북 저사양에서 직접 일일히 설정하면서 스압 움짤 페이지들 시간재면서 확인해봤습니다.

솔직히 뭔설정인지도 모르는게 몇개있고 최적화 혹은 좋은 성과를 보여주었다 라고해서 넣은것도 몇개있습니다.

저번에 퍼온글이 너무 문제가 많아서 한번 직접 하나씩 사용해보고 안전한걸 넣었습니다.

- chrome://flags/#------ 복사해서 주소창에 입력 또는 페이지에서 찾기로 제목검색하시길바랍니다.

- 사용 혹은 사용 중지라고 써놓은 것은 적용 후의 상태입니다.

버튼식은 눌렀을때 사용중지라고 뜨면 사용 설정된 것이고

선택식은 사용 설정됨을 선택하면 사용 상태인것입니다.

소프트웨어 렌더링 목록 무시 Mac, Windows, Linux, Chrome OS, Android

내장된 소프트웨어 렌더링 목록을 무시하고 지원되지 않는 시스템 설정에 GPU 가속 사용

chrome://flags/#ignore-gpu-blacklist

사용

(PC추천)실험용 캔버스 기능 Mac, Windows, Linux, Chrome OS, Android

아직 개발 중인 캔버스 실험 기능을 사용합니다.

chrome://flags/#enable-experimental-canvas-features

사용

(PC추천)디스플레이 목록 2D 캔버스 Mac, Windows, Linux, Chrome OS, Android

표시 목록을 사용하도록 설정하여 2D 캔버스 명령을 기록하세요.

이렇게 하면 2D 캔버스 래스터화를 별도의 스레드에서 수행할 수 있습니다.

chrome://flags/#enable-display-list-2d-canvas

사용

빠른 탭/창 닫기 Mac, Windows, Linux, Chrome OS, Android

빠른 탭/창 닫기 사용 - 탭의 onunload js 핸들러를 GUI와 별도로 실행합니다.

chrome://flags/#enable-fast-unload

사용

부드러운 스크롤 Windows, Linux, Chrome OS, Android

페이지 콘텐츠를 스크롤할 때 부드럽게 애니메이션 처리

chrome://flags/#smooth-scrolling

사용중지

실험용 QUIC 프로토콜 Mac, Windows, Linux, Chrome OS, Android

실험용 QUIC 프로토콜 지원을 사용하도록 설정합니다.

chrome://flags/#enable-quic

사용

'stale-while-revalidate' 캐시 명령 사용 Mac, Windows, Linux, Chrome OS, Android

'Cache-Control: stale-while-revalidate' 명령의 실험적 구현을 사용 설정합니다.

이를 통해 서버에서 대기 시간을 개선하기 위해 일부 리소스가 백그라운드에서 재검증되도록 지정할 수 있습니다.

chrome://flags/#enable-stale-while-revalidate

사용

(Android용)TCP 빠른열기 Linux, Chrome OS, Android

이전에 연결된 클라이언트가 초기 SYN 패킷에 추가 인증 정보를 전송할 수 있도록 옵션을 사용 설정하여

데이터에서 신속하게 '시작'명령을 보낼 수 있도록 합니다.

chrome://flags/#enable-tcp-fast-open

사용

(PC용)HTTP용 단순 캐시 Mac, Windows, Linux, Chrome OS

HTTP용 단순 캐시는 새로운 캐시이며 디스크 공간 할당에 파일 시스템을 사용합니다.

chrome://flags/#enable-simple-cache-backend

사용

Memory coordinator Windows, Linux, Chrome OS, Android

Enable memory coordinator instead of memory pressure listeners.

chrome://flags/#enable-memory-coordinator

사용

Clear data savings on startup Mac, Windows, Linux, Chrome OS, Android

Clears data savings obtained by using data reduction proxy when chrome starts.

chrome://flags/#clear-data-reduction-proxy-data-savings

사용

Brotli 콘텐츠 인코딩 Mac, Windows, Linux, Chrome OS, Android

Brotli 콘텐츠 인코딩 지원을 사용 설정합니다.

chrome://flags/#enable-brotli

사용

Token Binding Mac, Windows, Linux, Chrome OS, Android

Token Binding 지원을 사용 설정합니다.

chrome://flags/#enable-token-binding

사용

리소스가 적은 경우 IPC 최적화를 로드합니다. Mac, Windows, Linux, Chrome OS, Android

리소스가 적은 경우 IPC 최적화를 로드합니다.

chrome://flags/#enable-loading-ipc-optimization-for-small-resources

사용

- 안전하고 적당한 속도를 내주는 설정은

소프트웨어 렌더링 목록 무시 사용, 빠른 탭/창 닫기 사용, 부드러운 스크롤 사용중지,

실험용 QUIC 프로토콜 사용, TCP 빠른열기 사용, Clear data savings on startup 사용

설정만 설정해보시길 바랍니다.

- 실험용 캔버스 기능, 디스플레이 목록 2D 캔버스 PC 사용추천은

PC와 노트북+Adguard 에서 네이버 로딩속도가 더 빨라서 추천이라고 써놨고 모바일에서는 별 체감이 안갔습니다.

다른폰에서는 확인해보시길바랍니다.

- 추가로 새탭 및 오프라인 페이지 관련 기능이 필요없다면

페이지에서 찾기 후 오프라인/새 탭/new tab 으로 검색하셔서 필요한것을 사용 중지 하시면 됩니다.

- Zero-copy 래스터라이저, 래스터 스레드의 수

이 두가지 설정은 별차이를 못느껴서 삭제했습니다

- 저도 자세히 모르고 일일히 체감으로 적용한거라 문제있으시면

우측 상단 기본값으로 재설정 눌러서 기본값으로 변경하시길 바랍니다.

- 출처 : https://www.clien.net/service/board/lecture/9957818

Visual Basic 6.0 주석 지우기 프로그램 Ver 1.01

희자매파파 — Fri, 14 Jul 2017 16:58:05 +0900

아직도 비베6을 쓰는 사람이 있겠냐고 하겠지만, 내가 일하는 장비업계에서는 과거에 만든 프로그램들이 비주얼스튜디오 6(C++,VB)로 된 것들이 꽤 있다.

비주얼 베이직 6.0 을 사용하다보면 다른 사람에게 주석을 제거하고 줘야 할 때가 있다.

그런데, 비주얼 베이직용 주석 제거 프로그램이 있나 찾아보니 없다..(내가 서치능력이 떨어지느듯..)

그래서 우선 내가 사용하기 위해 만들었다.

파일을 불러와서 주석을 삭제한 후 저장하도록 만들었다.

기존 파일은 현재 불러온 파일의 경로 밑에 backup 폴더를 만든 후 백업을 하도록 했다.

이 프로그램이 필요한 사람은 누구나 무료로 사용해도 된다..

VB Comment Delete Project.exe

프로그램 개발툴 : C++ Builder 10.2

* 문제점 파악과 해결 결과를 표시

1. (2017.07.14, 16:00) 첫번째 버전을 사용하다보니 연속 라인으로 처리해 버리는 언더바(_) 문자가 있을 경우 처리하지 않는 경우가 있어 주석문자(`)가 나타난 후 언더바(_) 문자가 나올 경우에는 연속으로 주석을 지워버리도록 수정을 했다.

2. (2017.07.14, 17:15) 또 다른 문제점 확인...

프로그램 상 문자열 처리 내의 ` 문자가 있을 경우 같이 지워버리는 문제가 발생됨.

~~우선은 문자열 처리 내의 주석 처리 부분은 지우지 않도록 수정..~~

~~주석을 지우는 것도 중요하지만, 프로그램이 정상 동작하는 것이 우선이기에..~~

~~이에 대한 예외 조건 처리는 시간 날 때 다시 해야겠다.. 우선은 다른 일부터 해야 되기에..~~

(2017.07.15:12:30) 처리 완료. 추가로 첫번째 문자에 주석 처리 문자가 있을 경우에는 문자열 처리라도 무조건 주석으로 처리하도록 변경.

--------- 이상 -------------

Mac 부팅 옵션 키

희자매파파 — Thu, 24 Dec 2015 14:43:40 +0900

일반적으로 아무런 문제가 없는 OS X 가 잘 설치 되어 있을때, 아무런 키도 누르지 않으면 위와 같은 화면이 나오고 부팅이 진행 될 것이다. 하지만, CD-ROM에 CD가 삽입되어 있거나, 부트캠프로 윈도우가 설치되어 있다거나, OS X에 치명적인 문제가 발생했다면 문제를 해결하기 위한 다른 방식의 부팅방법이 필요하다. 부팅에 관련한 옵션 키를 누를때는 사과로고 아래의 상태막대가 나타나기 전에 키를 누르고 있어야 부팅옵션이 작용한다.

C : CD-ROM에 CD가 삽입되어 있을 경우 CD로 부팅을 할 수 있다.

D : 물리적으로 첫번째 하드 디스크를 시동 디스크로 선택한다. 논리적으로 파티션을 분할하여 시동디스크를 만들었을 경우, 원래의 시동 디스크로 부팅 할 수 있다.

N : 네트워크 부팅이 가능하도록 한다. 맥북 에어와 같이 물리적 CD-ROM 드라이브가 없을 경우, 다른 컴퓨터에 네트워크로 접근하여 OS X 의 설치가 가능하다.

R : 모니터의 해상도를 기본 해상도로 설정하여 부팅한다. 이 옵션은 OS X에 외부 모니터를 연결하여 해상도 문제가 발생 했을 때 해상도를 기본 셋팅으로 바꾸어 준다.

T : OS X 가 설치되어 있는 하드디스크를 외장하드로 인식하게 한다. 복구 불가능한 문제가 발생 했을 경우 하드 디스크 안의 데이터를 다른 컴퓨터에 옮길 수 있도록 외장하드처럼 인식하게 만들어 준다. FireWire를 통하여 연결이 가능하다.

Option : boot camp를 사용할 경우 부팅 티스크를 선택할 수 있다. 부팅이 가능한 디스크가 여러개 일 경우에도 선택이 가능하다.
Mouse button held down : CD-ROM에 삽입되어 있는 미디어를 부팅시에 꺼낼 수 있다.

Shift : 시작프로그램을 실행하지 않음으로 안전모드로 부팅할 수 있다.

Command + V : 콘솔 모드로 부팅을 하게 되며, 시작시에 어떤 실행들이 이루어지는지 텍스트 형식으로 볼 수 있다.

Command + S : 싱글 유저 모드로 부팅을 한다. 부팅이 완료되면 사용자가 커맨드를 입력할 수 있게 된다. 문제를 해결하기 위해 사용된다.

Command + Option + P + R : PRAM을 초기화 한다. PRAM에는 OS X 가 시동하는데 있어서 기본이 되는 정보들이 저장되어 있다.

Command + Option + N + V : 전원관리 시스템을 초기화 한다. 배터리에 관한 문제가 발생 했을 경우 사용한다.

위의 옵션들은 대부분 문제가 발생했을 경우 사용하게 된다. 지금 당장은 필요하지 않은 옵션들이지만, 문제가 발생했을 경우, 위의 옵션을 통해서 해결할 수 있는 문제들도 많이 있기 때문에 알아두는 것이 유용하다.

출처 : http://devist.tistory.com/34

소나무꽃이 피다

희자매파파 — Wed, 13 May 2015 12:15:40 +0900

우리집에 백년에 한번 핀다는 소나무 꽃이 피었다. 좋은 징조일까?

조바심... 그러나... 여유를 갖자..

희자매파파 — Wed, 15 Apr 2015 10:34:30 +0900

요즘 들어 일이 없다..

즉... 수입이 없다는 소리....

그런데, 나가야 될 돈은 많고...

이럴때일수록 담대해지자...

조급함을 달래고...

어차피... 기회는 다시 올테니까..

그동안 못했던 공부도 하고...

힘을 내보자...

나에게 힘을 내보라고 혼자서 끄적거려 본다...

참자... 또 참자...

그리고 힘을 내자...

청남대 나들이

희자매파파 — Tue, 18 Nov 2014 12:45:39 +0900

큰애 1학년때 학부모들과 함께 청남대 나들이 했을때의 모습...

넘 늦게 올리느는듯... 게을르다... 게을러...

천안 행복학교 - 목천초 합창 출전[유튜브 링크외 첨부 파일도 올림]

희자매파파 — Tue, 18 Nov 2014 02:07:02 +0900

지난 11월 9일에 있었던 청소년 어울림 마당에 출전(?)했던 목천초 아이들의 모습...

노래부르는 것을 즐기고 재밌어 하는 아이들을 보니.. 나까지 괜시리 기분 좋아짐..

이것저것 여러 방과후도 하고...

어쨌건 신나게 뛰어놀아서 까만 아이들을 보니 잘 놀면서 크는것 같아 흐믓...

아이들이 신나는 놀이같이 배우는 학교가 좋은 학교이겠죠..

아래 영상은 유튜브에 올렸던 영상...

아마 유튜브로 올린 영상이 나을거예요... 원래 영상의 4분의 1로 줄이긴 했지만(유튜브)... 8분의 1로 줄인 첨부영상(다음TV팟)보단 낫겠죠..

웬만하면 PC에서 전체화면 최고화질(1080p)로 보세요.. 그럼 더 당시의 감동을 느낄 수 있을 거예요..

티스토리에도 용량의 한도때문에 작게 만든 버전도 같이 첨부로 올림..

아이폰6+ 기다리는 중..

희자매파파 — Sat, 1 Nov 2014 13:25:18 +0900

아이폰을 늦게 주문해... 아직도 못 받고 있다..

졸부 같다던 6+ 128 Gold여서 인지.. KT에서는 못 받고 있다..

그냥 유플에서 받을걸 그랬나..

그냥.. 맘 비우고 담주에 천천히 받아야 겠다..

근데.. 아이폰5 할부 2달 남았는데... 이번에 하면서 다 처리해 버려야 겠다..

오랜 맥북에 생명을 불어넣자..

희자매파파 — Thu, 16 Oct 2014 09:59:45 +0900

내 시스템은 MacBook Air (13-inch, Mid 2011)이다..

128G SSD를 가지고 있어서 매번 용량 문제에 걸렸었다..

그동안 SD 카드를 이용해 그를 커버하긴 했으나 속도 문제에서도 힘들었다.

또 가끔씩 윈도우를 써야되는 상황에서 패러렐즈를 써야 되나 내 맥이 워낙 느리기에 부트캠프가 최선의 선택이었다.

이런 상황에서 SSD의 용량 확장이 필요했고.. 그러다가 찾은 것이 트렌센드의 JetDrive 500 이다..

(미국제를 주문했다가 취소하고 이제품으로 변경... 미국제는 외장 하드는 이뻤다.. 그런데, 바꾸자고 하는 SSD 용량이 적어서 결국 취소..)

맘 같아선 960G를 사고 싶었지만... 총알의 부족으로 480G로 변경했다..

맥북 뚜껑은 제공되는 전용공구를 이용해 열고 위 사진같이 교체하고 닫으면 끝...

(그전에 이전 맥북내용을 옮기던지.. 새로 설치하던지는 각자의 선택임)

그리고,, 사용하고 남은 SSD는 제공되는 전용케이스를 사용해 외장 하드로 변신,.,

집에서 창업할 때 주의할 점..

희자매파파 — Mon, 18 Aug 2014 23:49:21 +0900

1. 집은 집이란 생각 버리기...

집에서 창업을 하게 되면.. 집과 사무실의 개념이 모호해진다. 집에 작은 부분이라도 사무실 같이 꾸며놓고 일을 하자.

2. 가족과의 시간은 정해서.

가족과의 시간은 정해서 하자. 사업하는 것이 장난은 아니다.. 내 일하는 시간엔 가족의 방해는 오히려 독이 될 수 있다.

3. 쉴때는 쉬자..

혼자 일하다 보면 직장에서 야근하듯이 쉬지 않고 일하게 된다. 직장에서 겪어 보지 않았는가?

야근은 오히려 독이 되듯이.. 하루종일. 일주일 내내 한달내내.. 일만 하지 말자..

쉴땐 쉬고.. 일할땐 일하자..

4. 가족의 조언은 최소로...

가족은 나에게 조언을 해주는 것은 받아들이되 너무 의존하지 말자.

가족과 같이 사업을 하지 않는 이상.. 가족이 날 다 이해해 줄수는 없다.

가족에게 내가 일하면서 어렵다고 하는 것은 징징대는 것으로밖에 들리지 않을 것이다.

5. 계획표를 짜자..

계획표 없이 일을 하다보면... 항상 제자리에 머물수밖에 없다.

쉴때와 일할때... 그리고, 기한이 필요한 일과.. 기한이 덜 필요한 일을 분배할 줄 알아야만 한다..

와이로? 일본어((わいろ)? 한자어(蛙二鷺)? 제대로 알아보자..

희자매파파 — Mon, 4 Aug 2014 09:30:23 +0900

이이제이를 듣다보면 자주 나오는 말중에 와이로(Wairo)라는 말이 나온다..

문맥상 보면 뇌물이라는 말로 해석 될 수 있으나 이 말이 일본어인지 한자어인지.. 궁금해 찾아보았다..

일본어 와이로(わいろ,[賄賂,회뢰 : 뇌물을 주고 받음, a bribe, payoff])와

한자어 와이로(蛙二鷺)는 발음은 같으나 언어자체가 틀리다..

일본의 것은 히라가나로 우리의 것은 개구리 와(蛙)와 두 이(二) 거기에 해오라기 로(鷺)로 이러어져 있는 한자어로 볼 수 있다.

특이하게 뜻은 같으나 다른 단어이지만, 우리와 같은 발음으로 표시 되는 것으로 알 수 있다.

(동음이의어인가? 언어가 틀리니 동음이의어라고 보긴 어렵다.)

이 와이로(蛙二鷺)에 대한 어원은 다음과 같은 이야기에서 볼 수 가 있다.

옛날 물 맑은 개울가에서 꾀꼬리와 뜸부기가 노래를 하고 있었는데, 한 소절씩 부르고 난 뒤 서로가 자신의 목소리가 더 맑고 아름답다고 싸우게 되었다.

하루종일 말싸움(실랑이)를 했지만, 결론이 나지 않자 해오라기한테 누구의 목소리가 더 아름다운지 판결을 내려달라고 부탁을 하게 된다.

해오라기는 그 자리에서 바로 두 새의 판결을 내지 않고, 내일 다시 한번 듣고 판결을 내려주겠다고 하고 집으로 가 버렸다.

다음날 해오라기는 뜸부기의 목소리가 더 아름답다고 판결을 내렸다. 꾀꼬리와 다른 새들은 아무리 생각해도 꾀꼬리가 더 아름답다고 생각했는데, 왜 해오라기가 더 아름답다고 판결을 내렸는지 해오라기와 뜸부기의 뒷조사를 하게 된다.

그날 밤 그들은 뜸부기가 개구리 두마리를 잡아와서 해오라기한테 주는 것을 보았다. 즉 와이로(蛙二鷺)를 바친 것이다.

그 이후 사람들은 자신의 이익을 위해 관계가 있는 사람들에게 주는 뇌물을 다른 말로 와이로(蛙二鷺)라고 했던 것이다.

즉, 와이로(蛙二鷺)는 개구리 두마리를 해오라기에게 뇌물로 주었다는 뜻으로 전해지게 되었다...

(참고 사이트 : 물망초의 꿈 블로그 - http://blog.daum.net/_blog/BlogTypeView.do?blogid=0JTQl&articleno=8740705&categoryId=814111&regdt=20120105004044)

일본어의 사전에서 찾은 내용 (참고 : 다음 사전 - http://dic.daum.net/word/view.do?wordid=jkw000088152&q=%E3%82%8F%E3%81%84%E3%82%8D)

わいろ [ 賄賂 ] 상위어 : わい 회뢰, 뇌물.

賄賂わいろを使つかう 뇌물을 쓰다

賄賂わいろをおくる 뇌물을 주다.

동의어 そでのした

관련표현

복합어

わいろざい [賄賂罪] 회뢰죄, 뇌물죄

예문

巨額きょがくのわいろ 거액의 뇌물

浮世声色こわいろ身振師みぶりしと、名に流れたる市川や 무서운 얼굴색을 흉내 낸다고 이름이 나 있는 이치카와(市川)다

賄賂わいろの罷まかり通とおる政界せいかい 뇌물이 버젓이 통하는 정계

賄賂わいろをおくる 뇌물을 주다.

賄賂わいろを使つかう 뇌물을 쓰다

賄賂わいろ 회뢰.

声色こわいろを使つかう 남의 목소리를 흉내내다.

賄賂わいろが利きかない 뇌물이 통하지 않는다.

정부의 고관에게 뇌물을 바치다 政府せいふの高官こうかんに賄賂わいろを贈おくる. 꺼림해서 그 돈은 받을 수 없다. (→꺼림하다)

프린텍 스티커 라벨 사용기

희자매파파 — Tue, 29 Jul 2014 11:02:03 +0900

프린텍에서 새로운 라벨 스티커를 출시하였다는 말을 듣고 구매하려고 했는데,

우연찮게 체험단 행사를 하게 되는 것을 알게 되고 체험단을 신청하였다.

뭐.. 안 되겠지 하고 잊고 있었는데, 내방안에 스티커가 도착해 있었다.

그런데, 무슨 일인지 7월이 너무나 바쁘게 지나가다보니..

체험단을 잊어 버리고 있었다.. 너무나 무관심하고 삶에 지친 나..ㅠㅠ

도착했을때 찍은 사진과 리뷰하기 위해 추가로 찍은 사진을 위주로 리뷰를 작성한다..

나머지 리뷰는 추후 추가하길 약속하면서...

이번 체험단에서 받은 스티커라벨은 총 10종으

아래와 같이 스티커는 색상으로 구분할 수 가 있다..

주황색 - 의류용

연두색 - 다용도용

붉은색 - 방수용

나중에 빠른 분류를 할때 색상 만으로도 쉽게 구분하려고한 프린텍의 작은 포인트라고 볼 수 있다.

라벨의 개봉은 위와 같이 뜯기 전, 뜯은 후, 보관시로 나눌수가 있다.

한번에 라벨을 다 쓰는 경우는 적기 때문에 보통은 위와 같이 사용후 닫아 놓으면 분실이나 섞이는 염려는 접어 두어도 될 듯 하다..

용지는 위와 같이 앞면에 라벨이 분리되도록 되어 있다. 뒷면에는 사용방법이 간단히 적혀 있다..

맨 마지막 경고 문고처럼 팩안에 넣어서 평평하게 보관해야만 프린터에서 걸리는 것을 막을 수가 있다....

이번에 리뷰는 의류용 스티커 라벨부터 테스트 해보기로 했다.

(나머지 스티커는 사용할 때마다 찍어서 계속 리뷰를 올려야겠다. 우선 마감이 이달 말이니까.. 우선 체크용으로 하나 부터 작성)

프린텍 소프트웨어에서 편집하고 나서 우리집 프린터인 HP CP1215에서 출력,...

그런데.. 실패했다.. 프린터 설정이 제대로 되지 않는 듯해서.. 이방법 저 방법 시도해 봤지만.. 우리집 레이저 프린터 드라이버에 문제가 있는듯,.. 뭐... 하지만,... 실패한건 어쩔 수 없이.. 나중에 수기용으로 써야 되겠다..

그래도 리뷰는 진행해야 되니까.. 강제로 출력..

이 출력물들을 아이들 옷과 여러 제품에 부착...

우선 아이들 옷에 부착..

작은애 가방에도 부착 테스트...

리뷰 결과.. 그리고 바라는 점..

부착해본 결과... 부착력은 포스트잇보다는 조금 견고하게 부착이 됨...

하지만, 오랫동안 부착은 불가능.. 즉.. 하루 이틀 정도 부착이 필요할 경우에는 추천..

장기로 부착할 경우엔 프린텍 제품이 아닌 천 전용 제품(라벨 인쇄 후 다리미로 부착 하는 방식)이 필요할 듯 하다.

그리고, 국내에도 맥 유저가 적긴 하지만, 늘어나고 있는 추세이므로, 라벨 소프트웨어도 백용도 출시하면 좋을 듯 하다.

더불어 최종 인쇄물이 필요한 것이므로 출력시 도움말이 좀 더 자세했으면 좋겠다..

[수정]iOS8이 새로 나왔네요..(개발용기기 미등록 기기는 업데이트시 벽돌 되네요.)

희자매파파 — Tue, 3 Jun 2014 10:20:37 +0900

iOS8이 발표 되었네요..

제 아이폰5에 설치를 함 해봐야겠네요..

벽돌이 될 수도 있지만, 뭐.. 어차피 한번 해보고 안 되면 복원하죠..(개발자를 업데이트 해야 하는데 아직 안해서..)

~~추후 리뷰는 우선 설치해보고 되는지부터 확인후 진행하겠습니다.~~

~~업데이트 성공!! 되었네요.. 벽돌폰을 각오하고 했는데.. 업데이트 가능하네요...~~

업데이트 되었으나 약 3시간뒤에 바로 개발자 기기로 등록되지 않았다고 기기등록을 요청하면서 벽돌이 되어 버리네요..

아래 내용들은 벽돌 되기전까지 내용들입니다..

개발자 기기로 등록되어 있는 기기들만 가능하네요.. 개발자용 기기로 되지 않으신 분들은 업데이트 하지 마세요.

전 다시 복원해서 돌려놓기는 했지만, 귀찮거나 힘드신 분들은 시도하지 마세요..

전체적으로 글꼴이 바뀌었네요..

아직 베타여서 그런지 일부 메뉴는 아직 영어로 나오는군요..

새로 생긴 아이콘이 2개 있음..

버그 리포트(아마 베타버전이라서 있는듯..)와 헬스 아이콘..

버그 리포트는 현재 가지고 있는 Apple ID를 가지고 로그인하면 버그 발생시 리포트를 보낼 수 있음..

헬스 아이콘은 아마 추후에 늘어날 헬스 장비랑 연동이 가능할 듯..

자세한건 더 사용해봐야겠음..

가운데 버튼을 두번 누르면.. 아래와 같이 최근 사용한 연락처와 즐겨찾기 연락처를 왔다 갔다 할 수가 있음..

이건 괜찮은 듯.. 매번 종료하고 전화나 연락처로 갔는데 그럴 필요가 없는듯.. 처음에 최근 사용이 나오지만, 이 상태에서 연락처쪽을 스위핑하면 좌우로 이동 가능... 여기서 연락하려는 연락처를 선택하면 전화나 메시지.. 페이스 타임을 한번에 걸 수 있음..

Spotlight 검색 화면이 약간 달라짐. .아직 나타나지 않은 ShowTime이나 Location nearby 버튼들이 있는 것으로 보아 조만간 이 아이콘들도 활성화 될듯..

다른것들은 사용하면서 추가 해봐야 될 듯... 추가 되는데로 계속 업데이트 예정..

모든 장비의 핀 배열 모음

희자매파파 — Thu, 15 May 2014 16:10:41 +0900

Pinouts (pin-out) - allpinouts.com

END overLIB ==================== -->

Pinout or pin-out is a diagram or table which decribes the function of each wire in a cable or each pin in a connector.
This page list a large pinouts archive for:

This page quick link is: http://allpinouts.com.
To find a particolar pin-out on this site, please use the search tool on the left.
Of course, you're welcome to contribute this page with your own pinouts information.

Connectors

[Buses] [Parallel I/O] [Serial I/O] [HardDrives] [DiskDrives] [Video] [Home Audio/Video] [Joystick/Mice] [Keyboards] [Data Storage] [Memories] [Motherboards / Power] [Networking] [Cartridge/Expansion] [Telephone] [Cellular Phones] [Misc]

Buses

Parallel I/O

Serial I/O

Harddrives

Diskdrives

Video

Home audio/video

Keyboards

Joysticks/Mice

Data storage

Memories

Motherboards / Power

Networking

Cartridges/Expansions

Telephones

- no data -

Cellular Phones

Misc

Cables

[Nullmodem] [Modem] [Serial] [Printer] [Parallel] [Loopback plugs] [Data Storage] [TV/Video/Monitor] [Networking] [Misc]

Nullmodem

Modem

Serial

Printer

Parallel

Loopback plugs

Data Storage

TV/Video/Monitor

Networking

Misc

Adapters

[BUS] [Serial] [Parallel] [Keyboard] [Mouse] [Joystick] [Video] [Misc]

BUS

Serial

Parallel

Keyboard

Mouse

Joysticks

Video

Misc

출처 : http://www.technick.net/public/code/pinouts.php

[출처] 모든 장비의 핀배열 모음|작성자 TopGun

포맷 안 된 디스크(메모리,SDD,HDD)을 윈도우7에서 파티션 및 포맷하는 방법

희자매파파 — Fri, 21 Mar 2014 13:18:43 +0900

가끔씩 새로운 시스템에 새로운 디스크를 삽입했을때 디스크가 나타나지 않는 경우가 있다.

이럴때 강제로 디스크를 마운트해서 사용하는 방법을 적어둔다..

윈도우7의 경우 부팅CD 혹은 부팅USB를 만들어 부팅후 설치화면에서 컴퓨터 복구 모드로 들어가서 명령프롬프트(도스 커맨드0를 선택해 도스창을 띄운다.

윈도우창에서는 기본적이 DOS 명령들이 PATH가 잡혀있으므로 별도의 PATH 설정은 필요없다.

0. diskpart 를 실행한다.

X:>diskpart

1 .디스크파트가 실행되면 디스크 현황을 보기 위해 다음 명령어를 실행!!.

DISKPART>list disk

2. 파티션 설정할 DISK SET (첫번째 디스크: 0, 두번째 디스크: 1 .....)

DISKPART> sel disk 2 ( 여기서는 3번째 디스크를 선택함)

3. 파티션 생성

DISKPART> create partition primary size=XXXX

전체를 선택할 할당할 영역을 선택..(1GB = 1024 )

두번째 파티션을 생셩하려면

(아래의 예는 두번째 파티션으로 2GB 를 설정하는 예제입니다. 두번째도 primary 단어를 사용합니다.)

DISKPART> create partition primary size=2048

4. 드라이브 문자 지정

(아래의 예는 C 드라이브로 지정)

DISKPART> assign letter C

5. Active 지정

DISKPART> active

6. Format

- 빠른포맷으로 NTFS로 생성

DISKPART> format fs=ntfs label="kimyongyu" quick

- 빠른포맷으로 FAT로 생성

DISKPART> format fs=fat label="kimyongyu" quick

스마트기기의 작은 화면을 큰화면에서 봐자-MyDP(SlimPort)

희자매파파 — Mon, 27 Jan 2014 01:48:16 +0900

스마트폰을 TV에서 보자

MyDP(SlimPort)

이번에 리뷰하게 된 제품은 안드로이드 기기를 사용하는 자들에게 도움이 될 아이템이다.

자신의 안드로이드기기를 좀 더 큰 화면에서 보고 싶어하는 이들이 많이 있을 것이다..

이럴때 사용하는 방법중 여러 방법이 있을 수 있지만, 가장 단순하게 연결할 수 있고 속도가 빠른 방법은 직접 연결하는 것이다.

그럴때 필요한 어댑터가 이번에 리뷰하게 된 제품이다.

제품은 아래와 같이 비닐 포장으로 되어 있다. 그런데, 보통의 비닐 포장의 윗부분(종이부분)이 스테플러를 이용해 찝어 놓은 방식이 아닌 접착 방식이다. 그런데, 이부분은 상당히 강력(?)하게 접착 되어 있다. 종이 뜯는걸 포기하고 칼로 사사삭...

제품을 꺼내면 아래와 같이 단순하다.. 스마트기기와 연결되는 선과 전원을 충전할수 있는 USB 포트와 TV와 연결을 위한 HDMI 단자로 이루어져 있다. HDMI 케이블은 1.1~1.4버전까지 테스트 한 결과 모두 이상없이 연결이 잘 된다.. 그래서 본 리뷰는 HDMI 1.4 케이블을 가지고 진행하였다.

(이 기기와는 큰 차이가 없을 듯하지만, 그래도 최신 제품을 가지고 하는것이 나을듯 하다. 물론 버전이 낮은 케이블도 아무 이상 없이 잘 된다.)

내가 가지고 있는 안드로이드 제품 중 이번 리뷰에 사용한 제품은 넥서스7 2세대 제품이다. 레퍼런스 제품으로 최신 버전인 킷캣으로 업데이트 한 상태에서 리뷰를 진행하였다. 가장 먼저 케이블과 TV를 연결하면 화면은 아래와 같이 표시가 된다.

가로로 눕혀 보아도 이 부분에서는 적용 되지 않는다.

가장 먼저 안드로이드 마켓에 접속해 보았다. 왼쪽화면은 현재 화면이고 우측 화면은 안드로이드와 같이 찍은 화면이다..

7인치 넥서스가 46인치 TV 화면에 아무런 문제 없이 바로 적용 된다. 물론 눕힌 화면이 그대로 적용된다.

앱 실행중 화면을 띄워 본 결과 바로바로 적용이 된다.. 이 부분은 화면과의 적응 부분이 필요하겠지만, 넥서스의 화면과 대형 화면과의 이질감은 없어 보인다. 만족!!

다음으로 게임 화면을 적용해보았다.

바로 대형 화면으로 표시된다.. 오오옷...

그런데, 넥서스를 가지고 게임을 한 결과 아직 적응이 덜 되어서인지.. 넥서스만 가지고 테스트 할 때보다 적응이 덜 된다. 아마 이부분은 추후 익숙해지면 괜찮을 듯 하다.. 옆에 있는 케이블이 조금 걸리적 거리긴 하지만.. (무선이었으면 좋겠지만, 이 케이블의 용도는 게임용이 아니라는 것..)

마지막으로 테스트 한 것은 동영상 테스트...

유투브를 활용해 본 화면이다..

자세히 보면 하단의 넥서스 화면과 전혀 속도 차이가 느껴지지 않을 정도이다..

이 화면을 전체 화면으로 보면...

생각보다 깨끗하다.. 유투브 영상이 FULLHD를 지원하지 않는 것도 있겠지만 동영상 감상하는데는 아무런 문제가 없다.

음향도 HDMI 케이블로 전송이 가능해 별도의 스피커가 필요하지 않다는 점도 좋은 점수를 줄 만하다..

하지만, 집에 있는 IPTV에서 보던 화면이라서 새롭지는 않지만, 외출시 스마트 TV가 없는 곳에서는 활용하는데 아무런 문제가 없을 듯하다.

* 리뷰를 마치며

내가 주로 사용하는 스마트 기기는 애플 제품이다. 안드로이드 제품을 서브로 사용하긴 하지만, 이런 제품이 안드로이드쪽에서는 저렴(?)하게 나오므로 안드로이드 제품도 쓸만하다는 생각이다.. (며칠전 리포트를 보니 국내 안드로이드 OS 점유율이 90% 가까이 라고 하니.. 이런면에서 국내에서는 더 인기가 좋을듯..)

플쪽에서도 이런 제품이 있긴 하지만, 고가이다 보디 안드로이드 제품보다는 구매할 때 망설여지게 된다.

비싼 돈을 들이지 않고 자신의 안드로이드 스마트 기기를 대형 화면에서 볼 때 이 제품은 최선의 선택이라고 생각이 든다.

외출시나 외부에서 프리젠테이션 필요할 때, 영화 감상을 하고 싶을때 이 제품이 있으면 든든한 파트너가 될 것이다.

이 글은 위드블로그에서 제품 또는 서비스를 지원받아 작성된 글 입니다.

갑자기 개인 명함이 갖고 싶어졌다..

희자매파파 — Fri, 17 Jan 2014 16:42:55 +0900

회사에서 새로 명함을 주문하다 보니...

나만의 개인 명함을 갖고 싶어졌다...

퇴근 후 틈틈히 Design 해서 만들어봐야겠다..

어차피 출력은 주문하면 되니까...

명함 시안 나오면 그때 다시 올려봐야지..

윈도우7에서 터미널 서비스 구동하기

희자매파파 — Thu, 26 Dec 2013 17:14:02 +0900

윈도우7에 기본적으로 터미널 서비스 클라이언트는 있으나 서버 서비스는 설치 되어 있지 않다..

그래서 아래의 사이트에서 자신의 OS에 맞는 서비스를 설치하면 된다..

http://www.microsoft.com/ko-kr/download/details.aspx?id=7887

설치 후, 제어판-> 프로그램 제거 또는 변경 -> Windows 기능 사용/사용 안함에서

원격서버 관리 도구 -> 역활 관리 도구 -> 원격 데스크톱 서비스 도구 항목을 선택해 줘야만 원격에서 자신의 컴에 접속할 수 가 있다.

접속은 원격 데스크탑 연결을 선택해 접속하면 된다..

아이폰5 고장나다..

희자매파파 — Tue, 19 Nov 2013 00:30:00 +0900

토요일(11/16)부터 아이폰5가 전원이 안 켜져서 동부대우서비스 센터 방문해 배터리 교체..

토요일(11/16)~월요일(11/18) 오전까지 잘 씀...

월요일(11/18) 오후에 안켜지는 문제 발생.. 충전 단자를 꽂으면 켜졌다 꺼졌다 하는 문제 발생(토요일과 같은 현상)

화요일(11/19) 다시 오전 8시 40분에 동부대우서비스 센터 방문..

--> 돌아온 답은 여기서 리퍼가 안 됨.. 애플 본사로 보내야 한다고 함..

그럼 그동안 사용할 폰은?.. 그것은 KT 직영 A/S 센터로 가라고 함..

--> KT 천안 직영 A/S 센터(쌍용동 이마트 가기전에 있음..)에 9시 20분 도착...

10시부터 영업 시작한다고 해서.. 시간 때우고 있음..

9시 50분... 아이패드로 찍어간 영상 보여줌..

애플로 보내야 한다고 하면서 임대폰 대여해줌.. 아이폰 4가 아닌.. 아이폰 3gs... ㅠㅠ

그사이 아이폰 찾기 끔..(이거 켜 놓으면 안 된다고 해서.. PC로 접속해 아이폰 찾기 해제...)

새로운 아이폰에 나노유심->일반유심 어댑터를 장착해 끼움..

개통 완료....

이제부터 열흘간은 느린 아이폰3GS와 함께 생활해야 함..

아이폰 4로 주면 안 되는건가.. 3GS는 넘 느리네. 예전에 이것도 무지 빨라 보였는데...

어쨌건.. 오늘 안 것. 하나..

동부대우일렉으로 안 가고 주위에 KT 직영 AS 센터로 가도 아이폰 수리 및 접수가 된다는 사실...

그동안 난 동부대우일렉만 되는줄 알고 있었음..

어쨌건.. 오늘 오전 2시간을 아이폰때문에 시간 허비함..

이정희씨의 대한 새누리당 반응을 보면서..

희자매파파 — Tue, 12 Nov 2013 11:41:13 +0900

이정희 의원이 박근혜 대통령을 박근혜씨라고 해서 새누리당이... 대통령 모욕이니.. 하는데...

그전에 당신들은 노무현 대통령님한테는 어떤 식으로 했는지 기억 좀 하길 바란다..

무슨 새대가리도 아니고.. 넘 하는거 아닌가..

난 통진당을 좋아하는 편은 아니지만.. 새누리당이 발끈 하는거 보니 이 영상을 그들에게 보여주고 싶다..

이 동영상과 이정희 의원의 발언 중 누가 더 문제가 있는 것인가?

한번 새누리당 의원에게 묻고 싶다.

역지사지.

희자매파파 — Thu, 24 Oct 2013 16:28:13 +0900

별것 아닌거라 나는 생각하지만
상대방은 별것이라도 생각한다.

내가 별것 아니라고 생각해도
상대방이 별것이라고 생각하면
그것은 별것이 된다.

난 이정도쯤이야라고 생각하지만
상대는 이정도까지라고 생각한다.

사람사이에 이 정도, 별것이라는게
참 어렵다.

특히나 가까운 사이에서 그런일이
생기면 유난히 어렵다.

그 별것을 풀어줄려고 해도
상대가 풀어주기엔 너무 큰 상처를 받았다면
그것은 풀기가 너무나 어렵다.

하지만 인생은 짧지 않다는거.
역으로 생각해 상처를 준사람은
상처 준 사람의 입장에서.
상처 받은 사람은 상처 준 사람입장에서
한번쯤은 생각해 봤으면 좋겠다.

시간이 지나면 풀어지겠지란 것은
단순한 생각이다.

풀지 않고 가면 추후에 또 다시
상처준 그때 이야기를 꺼낸다는 것.

사람들 모두 역지사지를 했으면 좋겠다.

상처 준 사람이 화해의 손길을 내밀었을때
받아줄 수 있는 사람이
진정한 승자이고 대인이다.

화해의 손길을 거부하고 혼자만의 세계에
빠져있는것은 "나 못 났소."하는 것과 같다.

그냥 오늘은 길게 써 보고 싶어서 끄적여 본다.

아이들과 함께 즐겁게 케익을 만들 수 있는 미케익(천안점)을 다녀왔어요..

희자매파파 — Tue, 24 Sep 2013 00:17:05 +0900

이번 미케익을 리뷰하는 날이 본인 생일 전날이었네요..

리뷰어가 되자 마자 방문해 본 것은 이번이 처음이었네요..

예약은 필수라고 해서 전일 저녁 늦게 미리 예약하고 다음날 저녁에 방문하였습니다.

아이들과 함께 아빠 생일 케익 만들기로 하고 아이들에고 추억도 남겨주고 싶었기에 아이들이 만들기로 하고 전 옆에서 도와주기만을 하기로 했습니다.

그런데 가는 날이 장날이라고 비가 주루룩 내리더군요.

들어가서 마음씨 좋아보이는 주인 아저씨가 저희를 반갑게 맞아주셨네요. 위드블로그에서 리뷰 나왔다고 하니 잘 협조 해 주셨고요..(감사합니다.)

아이들이 원하는 초코케익으로 진행을 요청했네요..

전 다른 케익을 하고 싶었지만 아이들이 오늘은 주인이니까 아이들의 의견을 따르기로 했습니다.

우선 자리에 앉게 되면 위와 같은 돌림판이 저희를 반갑게 맞아 줍니다. 이 돌림판에 주문한 케익이 올라가겠죠..

케익이 오기 전 시간이 남아 입구를 찍어 보았네요. 미처 못 봤는데 케익 사진들이 보이네요. 저걸 참고했어야 했는데, 애들이 하기에는 너무 어려울 듯 해서 아이들이 하고 싶은데로 하게 했네요.

마음 좋아 보이는 주인 아저씨가 저희 큰딸에게 장식하는 방법을 가르쳐 줍니다. 아이는 열심히 따라 하네요..

배우는게 금방이네요. 처음에는 큰아이가 우선 한 줄을 다 장식하고 다음 줄은 작은 아이에게 넘겨 줄 모양이네요.

간만에 큰 아이가 집중하는 모습을 보이네요. 책볼때 말고 이렇게 집중할 줄은 몰랐네요.

큰아이가 하는 동안 작은 아이는 다른 분들이 하는 것들을 지며보고 있네요. 언니가 아직 넘겨주지 않아서 장식을 못하고 있지만 곧 할 것이라고 믿고 있죠. 큰아이가 양보를 해 주어야만 할텐데요. 과연 양보를 해 줄까요?

큰아이가 만든 1차 장식입니다. 아직 초등학교 2학년인 아이 치고는 잘 한 것이겠죠? 뭐 제가 했어도 비슷했을 듯 싶네요.

제가 방문했을때는 이상하게도 여자분들만 계시더군요. 만남 백일 케익 만드는 청소년들.. 부모님 생신 케익 만드는 직장 여성분...

남자는 커플로 온 남자밖에 없었네요.. 그렇다고 남자분들이 못 갈 곳은 아니랍니다. 혼자 만들수 있는 공간도 있거든요.

그리고 남자분들도 케익하나 만들어서 여자분에게 주는 로맨스도 필요할 듯 하고요.(뭐 명품백을 좋아하는 분들에게는 효과 없겠지만요..)

작은 아이는 장식을 하고 큰 아이는 과일과 초콜릿과 사탕으로 장식을 하고 있네요. 많은 장식품들이 있는데 그릇에 담아서 계산대에 가면 주인아저씨가 계산 해 주신답니다.(저희는 애 때문인지 나중에 끝나고 계산 해 주신다고 하셔서 바로 장식을 했네요.. 이런 작은 부분까지 신경 써 주신부분 감사합니다.)

장식을 올리고 추가로 모양을 내고 있네요. 전 글자를 세기거나 가루를 뿌려 장식을 하고 싶었지만 아이들은 직접 꾸미는 재미로 인해 그것은 못하게 하네요. 그래도 아이들이 좋아하니까. 뭐.. 괜찮습니다.

아이들이 좋아할 만한 장식들이 참 많아요. 그리고 더 좋은건 그런 장식들이 생각보다 비싸지는 않더라구요.(학생들 입장에서는 비쌀수도 있겠네요.)

간단한 도마와 칼도 준비되어 있어서 과일 장식이나 다른 장식을 자신만의 방식으로 만들수 있는 점도 하나의 매력이네요.

주인 아저씨의 자젹증이네요. 설탕공예사 자격증인 듯 하네요.

그럼 혹시 여기 설탕 장식을 주인 아저씨가 직접 만드시는건가? 에고 물어볼 걸 그랬네요...ㅠㅠ

가게는 아담하지만 케익 만드는데는 아무런 문제가 없습니다. 아까 앞에서 얘기한것과 같이 혼자와서 만들 수 있는 공간도 충분하고요.

연인에게나 가족에게 특별한 날에 케익 만들어 주고 싶을때 미케익을 찾아서 만들면 참 좋을 듯 하네요..

마지막으로 저희 두 딸이 만든 작품을 보여 드리면서 리뷰를 마치고자 합니다.

아참. 젤로 중요한거 하나 빼 먹었네요. 케익은 제가 좋아하는 맛이네요. 달지도 않고 부드러운 케익이네요.

유통기한도 잘 지켜지고 있어서인지 신선한 느낌이 강하고요.

맛도 보여주고 자신만의 케익을 만들고 싶으신 분들은 꼭 미케익에 들르셔서 케익 만들어 보세요.

P.S 가격이 2만원 넘었는데 그냥 쿨하게 깎아주신 주인아저씨 멋있었어요. 그리고, 썰렁한 농담도 괜찮았구요.

지금까지 받아본 생일 케익 중 최고의 케익이었던것 같습니다.

다음 11월 안사람 생일에는 저 혼자나 아니면 아이들과 다시 한번 찾아뵙고 만들고 싶습니다.

그때도 반갑게 맞아주세요..

위치는 충남 천안시 동남구 신부동 462-14 세세빌 3층이예요.

전화번호는 041-552-7749 입니다.

정신없네..

희자매파파 — Fri, 23 Aug 2013 12:35:04 +0900

요즘 참 정신없는 듯 지낸다..

휴일이 언제였는지..

제대로 쉬어본게 언제였는지..

애들과 놀러가본게 언제였는지..

좀 더 가족과 많은 시간을 보내기 위해 회사를 옮겼는데..

오히려 더 바빠졌으니..

내가 원했던건 이게 아닌데..

좀 덜 벌어도 가족들과 더 많은 시간을 보낼려고 했던 것인데..

진짜로 업종 변경을 해야 하나..

고민이 심각하다..

내가 과연 무엇이 잘못된 것일까..

아주 많은 고민이 되는 하루다..

일이 힘든 것도 싫지만, 그만큼의 휴식을 갖지 못하는게 더 싫다..

나도 친구처럼 잠수를 타야 하나..

나에게 프로그래머는 어울리지 않는 직업인 것일까..

프로그래머는 맞지만.. 지금 하는 장비쪽 프로그래머는 그만 두는 것이 나은 것일까..

이런저런 생각이 많이 든다..

오늘은 와이프와 진지하게 얘기를 해 봐야겠다..

중소기업 지원자들을 보면서..

희자매파파 — Thu, 4 Jul 2013 08:10:37 +0900

이제는 개발자이기도 하면서 사람도 뽑고 있는 자리에 있게 되었다.

그런데, 지금 다니는 회사가 작은 회사이긴 하지만 너무 얼토당토 않는 이력서들을 보면 괜히 화가 난다.

사진 없는 이력서..

경력이 10년이 넘어간다고 하면서 이력서에는 그냥 프로젝트 이름만 달랑 있고..

혹시나 해서 불러서 면접 보면 거기서 한 것은 옆에서 시다(도움)만 주었을 뿐이고 그 프로젝트에 대해서 제대로 아는 것도 없다.

이런 사람은 경력이 10년이라고 하나 우리쪽에서는 1년짜리랑 마찬가지로 밖에 볼 수 없다.

무조건 경력이 많다고 임금을 세게 부르거나..(이건 뭐 뽑든지 말든지라는 식인듯..) 대기업 같이 요구하려면 그냥 대기업에 가든지..

대기업에서 안 되니까 중소기업에 오는 사람들은 중소기업에 오면 그만큼 힘들 다는 사실을 알아야만 한다.

대기업에서는 중소기업이 뭐가 될 것 같다 그러면 바로 아이템을 뺏어가는 식이 많으니까..

허탈함도 느끼고...

하지만, 중소기업도 중소기업만의 장점이 있다..

대기업에서는 다양한 경험이 어렵지만, 중소기업에서는 그 다양한 경험을 할 수 가 있다는 것이다.

대기업 다니시다가 중소기업으로 오시는 분들 중 대부분이 한가지 분야만 잘 하신다.

그러다 보니 다른 분야의 것을 개발하려고 하면 대부분 퇴사 해 버리신다.

뭐, 어찌보면 단점일 수도 있겠지만, 자신의 기술을 늘리는데는 대기업보다는 중소기업이 오히려 나을 수 있다는 것이다.

중소기업도 돈을 많이 주고 싶다. 하지만, 중소기업 대부분이 대기업에 의존해 일을 하다보니 대기업에서 NEGO가 들어오다보니

대기업만큼 돈을 주기 어려운 것이다. 대기업이 조금만 중소기업을 생각한다면 자신들의 NEGO폭을 조금만 줄였으면 좋겠다.

그럼 꼭 대기업에 가지 않고도 중소기업으로 오는 사람들도 많을 것이다.

대기업의 완장을 차고 싶어서 가시는 분들은 대기업으로 가시라.. 대신 20~30년 까지도 버틸 자신이 있으셔야만 한다.

돈을 많이 주는 만큼 그만큼 일을 시키니까..

말이 삼천포로 빠져서 그런데..

결론은 이거다..

중소기업에 지원하는 지원자 여러분들..

대기업에 이력서나 경력서를 쓰시는 것 같이 중소기업에도 작성해 달라는 것이다..

그리고, 자신의 실력을 객관적으로 보고 희망 연봉을 적으시라는 것이다..

내가 보기엔 이정도 받기에 뭐한데 내가 생각한 것 보다 1~2천 넘게 부르시니 면접을 보고 싶어도 면접을 볼 수가 없으니까 말이다..

조금만 객관적으로 자신을 돌아보시고 이력서를 내고 기다려보시라..

아마 많은 곳에서 연락이 올 것이다..

어차피 1%의 대기업보다는 99%의 중소기업이 훨씬 많으니까..

tvN 몬스타 중에서... 박규동-민세이의 바람이 분다..

희자매파파 — Sun, 19 May 2013 08:48:46 +0900

어제인가.. 그제인가..

우연히 보게 되었는데.. 재밌네...

뻔한 이야기일수도 있는데.. 1화 마지막에 나온 "바람이 분다"는 참 괜찮았다..

옆의 안사람은 눈가가 촉촉해 지기도 하고...

다음회가 기다려지는군...

목천초등학교 효도 잔치 중에서..

희자매파파 — Fri, 10 May 2013 17:29:02 +0900

5월 8일 어버이날..

목천초에서 효도잔치를 했다..(사실 이 행사는 매년 진행된다..)

올해는 목천초 100주년 기념이기도 하고..

이날 우리 애들은 유치원과 2학년에서 활약함...

그날 행사에 참석한 우리 애들 활약 모습을 담아보았다..

아이뻐5로 촬영후 다음팟으로 인코딩해서 올림..

가희 활약..우측 두번째줄에 있음...

둘째 나희 활약.. 따로 놀지만.. 열심히 하는 모습이 귀여움...

나도 모르게 무인단속카메라에 걸렸다고 생각되면...

희자매파파 — Mon, 6 May 2013 18:57:03 +0900

자동차 오너라면 한번쯤은 무인 단속 카메라에 걸려 보신적이 있을 것이다.

나도 몇번 걸렸으니.. 뭐...

그런데, 이럴때 에매하게 찍혔나 싶을때 알아보는 사이트가 있다..

경찰청에서 운영하는 교통법칙금.과태료 조회 및 납부 시스템....

여기서 먼저 조회해보면 나올 것이다..

https://www.efine.go.kr/

보통 찍히고 나면 빠르면 3~4일 걸리지만, 일주일 이상 걸릴수도 있다고 하니 참고 하는것도 괜찮을 듯 싶다..

참고로 5년동안 자료가 보관이라고 한다. ㅠㅠ.. (내 아는 사람은 3~6개월 뒤에 나온 사람도 있다고 한다..)

그 다음으로 단속 결과 확인 사이트도 있다..

이곳은 공인인증없이 차번호와 주민번호 뒷자리만으로도 조회가 된다..

http://vimshome.ts2020.kr/jsp/hpg/pubservice.jsp

마지막으로 도로교통동단 운전면허 시험장 사이트에서도 가능하니 참고하는 것도 괜찮을 듯 하다.

http://dls.koroad.or.kr/main.jsp

그래도 젤로 좋은건 신호 잘 지키고 안전 운전 하는 것일것이다..

대선을 바라보면서(박근혜 vs 문재인)

희자매파파 — Wed, 28 Nov 2012 08:50:56 +0900

이번 대선을 바라보면서 참.. 여러가지 생각을 하게된다.

지난 노무현 대통령때와 비슷하면서도 다르고..

현 가카 뽑을때랑 비슷한면도 있고..

독재자였으면서 자신의 정적을 없앴던 자의 딸은 과거는 과거일뿐이라고 말하면서, 자신은 아버지에 대한 것은 지우려고 하고..

그런거 보면 드라마 "내딸 서영이"가 오히려 나아 보일 정도다.. 이건 뭐.. 아버지일은 자신과 아예 무관하다고 하는 것은 아닌듯한데..

그러면서 아버지와 어머니의 향수를 자극해 대통령이 되려고 하니..

또 다른 후보는 야권 단일화를 단일화가 같기도 하고 단순화 같기도 하고..

좀 에매모호한 단일화가 되어 버렸고.. (이건 언론의 플레이이기도 하다.. 안철수는 분명 문재인을 지지 한다고 했는데, 뉴스에서는 그걸 빼버리지 않나..)

난 이번 대선에서 정권 교체가 이뤄지길 바라는 사람이다..(어떤 의미에서의 정권 교체는 박근혜가 되더라도 지금 같지 않게 한다면 박근혜도 인정해 줄 것이다.)

대선 후에 상대방의 좋은 공약은 가져와서 써도 되었으면 하는 소시민의 한사람이기도 하다..

공식 선거 운동이 가능한 동안은 난 그날그날의 상황을 보면서 나의 생각을 적어볼 생각이다.

현재까지는 문재인에게 조금 더 마음이 기울어져 있지만, 선거 운동을 지켜보면서 바뀔수도 있다.(뭐. 그렇다고 박근혜를 찍을려면 나를 설득해주는 사람이 있다면 모르겠지만..)

참.. 어제 TV 광고는 감성이 아닌 이성에 호소한 문재인의 승으로 보고 싶다.

칼 맞은 것을 광고로 쓰는 것은 이해하지만, 난 그 당시 상황을 오히려 정치적으로 이용해 박근혜의 위치가 더 올라섰다는 것은 부정하지 못할 것이다.

1.기회는 평등할 것입니다.

2.과정은 공정할 것입니다.

3.결과는 정의로울 것입니다.

어제 이 광고 카피가 맘에 든다.

목천 초등학교 1학년 1반 갯벌 체험 갔어요..

희자매파파 — Mon, 24 Sep 2012 00:17:20 +0900

1학년 1반이 지난 9월 15일에 갯벌 체험에 다녀 왔습니다.

거기서 찍은 사진들 일부를 올려 봅니다.

재밌게 보셨으면 좋겠습니다.

참고용 소스 모음

희자매파파 — Mon, 16 Jul 2012 20:35:02 +0900

-------------------------------------------------------------------*/
//////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////// - 콘트롤 - ////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------*/

//---List Box / file Dir Dlg--------------------------------------------------------

//----------------------------------------------------------------------------
   // 폴더 얻기
   char szTemp[255];
   memset(szTemp, 0, 255);
   lstrcat(szTemp, "c:\\Data");
   CDialog::DlgDirList(szTemp, IDC_LISTBOX, NULL, DDL_EXCLUSIVE | DDL_DIRECTORY);
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
   //화일명 얻기
CString Path_Log="C:\\WaterSensor성능검사기\\Data\\";
CString ss=""; CString tt="";

tt="*.mdb";
ss =Path_Log+"*.mdb";

char szTemp[255];
memset(szTemp, 0, 255);
lstrcat(szTemp, ss);
CDialog::DlgDirList(szTemp, IDC_SLOG_LIST, NULL, NULL);// DDL_EXCLUSIVE | DDL_DIRECTORY);

int nList=0; CString csTmp="";
sLog.SetCurSel(nList);
/*
if(sLog.GetTextLen(nList)>0)
{
sLog.GetText(nList ,csTmp);
if( FileExists(Path_Log+csTmp))
{
ss=LoadReadFile(Path_Log+csTmp);
LogDisplay(ss);
}
}
*/

//==============================================================================
//---다른 Label 콘트롤(Threed32 Panel) Control 상속 얻기 -----------------------

#include "sspnctrl.h"

CSSPNCtrl *Static;
Static = (CSSPNCtrl *)GetDlgItem(IDC_IO_0);
Static->SetBackColor(0x0000ff); //BGR

void CAttachMachineView::Sub_SetDlgItemColor(int nID, COLORREF CColor)
{
CSSPNCtrl *Static;
Static = (CSSPNCtrl *)GetDlgItem(IDC_IO_0);
Static->SetBackColor(CColor);
}

CSSPNCtrl *Static;
Static = (CSSPNCtrl *)GetDlgItem(IDC_EXIT_WAITE_MESSAGE);
Static->ShowWindow(true);

#include "LabelControl.h"
((CLabelControl*)GetDlgItem(nID))->SetBackColor(OK_COLOR);

//---Control 상속 보이기--------------------------------------------------------

CButton *pBtn;
pBtn = (CButton *)GetDlgItem(IDC_CLOSE_BTN);
pBtn->ShowWindow(true);

Static = (CStatic *)GetDlgItem(IDC_CAM_NAME);
Static->ShowWindow(true);

//---Control 이벤트--------------------------------------------------------
.h
//{{AFX_MSG(CImageViewView)
afx_msg bool OnClickImageView(UINT nID);
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
.cpp
BEGIN_MESSAGE_MAP(CImageViewView, CFormView)
//{{AFX_MSG_MAP(CImageViewView)
ON_COMMAND_RANGE(IDC_IMG_VIEW1, IDC_IMG_VIEW4, OnClickImageView)
END_MESSAGE_MAP()

bool CImageViewView::OnClickImageView(UINT nID)
{
CString csTmp;
csTmp.Format("%d",nID);
AfxMessageBox(csTmp);
return true;
}

#define OK_COLOR RGB(100,150,255)
#define NG_COLOR RGB(235,60,60)
COLORREF clLime;

//--Inage List
BOOL bRetValue = FALSE;
HICON hIcon = NULL;
// m_CurLibType = m_SelLibrary = m_SleLibType = LINE2RECT;

SetIcon(m_hIcon, TRUE);
SetIcon(m_hIcon, FALSE);

// Create image list
bRetValue = m_ImageList.Create(80, 80, ILC_COLOR32 | ILC_MASK, 5, 1);
ASSERT(bRetValue == TRUE);

// Add some icons
hIcon = AfxGetApp()->LoadIcon(IDI_ICON_MARK);
m_ImageList.Add(hIcon);

m_lbxListBox.SetImageList(&m_ImageList);

//--CShadeButton------------------------------------------------------
#include "ShadeButtonST.h"

.h --
CShadeButtonST m_btnXYOrg;

..cpp
DDX_Control(pDX,IDC_BTN_XYORG,m_btnXYOrg); //IDC_BTN_XYORG 푸시 버튼

..OnInitDialog()
//COLORREF crBtnColor;
//crBtnColor = ::GetSysColor(COLOR_ACTIVEBORDER) + RGB(100, 50, 50);
m_btnXYOrg.SetShade(CShadeButtonST::SHS_HBUMP);

//-------
m_btnXYOrg.SetShade(CShadeButtonST::SHS_HSHADE);
m_btnXYOrg.Invalidate();
m_btnXYOrg.SetShade(CShadeButtonST::SHS_HSHADE,8,10,30,RGB(100,55,0));

//--CLabelControl--------------------------------------------------

CLabelControl *pLabel;
for(int i=0; i<MAX_ONE_BD-2; i++)//0-5 Label1 - Label6
{
pLabel = (CLabelControl *)GetDlgItem(IDC_LABEL1+i);
pLabel->SetEnabled(FALSE);
}
//Label7 ID가 순서대로가 아님
pLabel = (CLabelControl *)GetDlgItem(IDC_LABEL7);
pLabel->SetEnabled(FALSE);

CComboBox *pcbo;
pcbo = (CComboBox *)GetDlgItem(IDC_COMBO_SELECT_AXIS);
m_SelectAxisNo = pcbo->SetCurSel(0);

pcbo = (CComboBox *)GetDlgItem(IDC_COMBO_SELECT_MODE);
m_SelectAxisMode= pcbo->SetCurSel(0);
pcbo->EnableWindow(false);

CStatic *Static;
Static = (CStatic *)GetDlgItem(IDC_STATIC_AXIS_MODE);
Static->EnableWindow(false);//Static->ShowWindow(false);

CButton *pchk;
pchk = (CButton *)GetDlgItem(IDC_RADIO_MMCBOARD1);
pchk->SetCheck(TRUE);

// Axis One Select LED Status
m_ledOpSelect1.SetValue(false); m_ledOpSelect2.SetValue(false);m_ledOpSelect3.SetValue(true);

/*------Combo Box---------------------------------------------------*/

CComboBox *pcbo2;
pcbo2 = (CComboBox *)GetDlgItem(IDC_COMBO_SELECT_MODE);
m_SelectAxisMode = pcbo2->SetCurSel(0);

/*------이벤트 얻기---------------------------------------------------*/

BOOL CManualMotorPage::PreTranslateMessage(MSG* pMsg)
{
// TODO: Add your specialized code here and/or call the base class
int ret;
CLabelControl *plbl;
if(pMsg->message == WM_LBUTTONDOWN){
for(int i=0;i<MAX_AXIS;i++){

plbl = (CLabelControl *)GetDlgItem(IDC_LBL_AXIS_X+i);
if(pMsg->hwnd == plbl->m_hWnd){

return TRUE;
}
}
}
}
return CPropertyPage::PreTranslateMessage(pMsg);
}

/*------Icon---------------------------------------------------*/

HICON m_hIconOnOff[2];

m_hIconOnOff[0] = AfxGetApp()->LoadIcon(IDI_OFF);
m_hIconOnOff[1] = AfxGetApp()->LoadIcon(IDI_ON);

CStatic *icon;

icon = (CStatic *)GetDlgItem(IDC_PIC_LED1);
icon->SetIcon(m_hIconOnOff[0]);

/*------Button Enable-----------------------------------------------------*/

CButton *opBtn;
opBtn=(CButton *)GetDlgItem(IDC_BTN_START);
opBtn->EnableWindow(FALSE);
CCommandButton *origBtn;
origBtn=(CCommandButton *)GetDlgItem(IDC_CMD_ORIG_START);
origBtn->SetEnabled(FALSE);

/*------Microsoft Form2.0 Check Box Set------------------------------------*/

// void SetValue(VARIANT* newValue);
void SetValue( BOOL newValue);
// VARIANT GetValue();
BOOL GetValue();
void CMdcCheckBox::SetValue(BOOL newValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}
BOOL CMdcCheckBox::GetValue()
{
BOOL result;
InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}

CMdcCheckBox *pchk;
pchk = (CMdcCheckBox *)GetDlgItem(IDC_CHECKBOX1);
pchk->SetValue(true);

CMdcCheckBox *pchk;
pchk = (CMdcCheckBox *)GetDlgItem(IDC_CHECKBOX1);
if(pchk->GetValue())AfxMessageBox("on");
else AfxMessageBox("off");

/*------Radio Button Set---------------------------------------------------*/

CButton *pchk;
pchk = (CButton *)GetDlgItem(IDC_RADIO_NONE);
pchk->SetCheck(FALSE);
pchk = (CButton *)GetDlgItem(IDC_RADIO_SPLIT);
pchk->SetCheck(TRUE);
/*------------------------------------------------------------------------*/

/*------어레이 이벤트 발생 설정 ------------------------------------------*/
..h
protected:
//}}AFX_MSG
afx_msg void OnChangeTray(UINT nID);
DECLARE_MESSAGE_MAP()

..cpp
BEGIN_MESSAGE_MAP(CPreMountDataPage, CPropertyPage)
//}}AFX_MSG_MAP
ON_COMMAND_RANGE(IDC_RADIO_TRAY1, IDC_RADIO_TRAY4, OnChangeTray)
END_MESSAGE_MAP()

void CPreMountDataPage::OnChangeTray( UINT nID )
{
CLabelControl *label;
UpdateData(TRUE);
m_nTrayNo = nID - IDC_RADIO_TRAY1;
}

/*------Gride Scroll-----------------------------------------------------*/
m_MSFlexGrid.SetScrollTrack(true);

/*------Icon 불러오기-----------------------------------------------------*/

IDC_PIC_LED1 : Picture Properties, Type -Icon

HICON m_hIconOnOff[2];

m_hIconOnOff[0] = AfxGetApp()->LoadIcon(IDI_OFF);
m_hIconOnOff[1] = AfxGetApp()->LoadIcon(IDI_ON);

CStatic *icon;
for(int i=0; i<9; i++) {
icon = (CStatic *)GetDlgItem(IDC_PIC_LED1 + i);
icon->SetIcon(m_hIconOnOff[0]);
}

/*------다중 콘트롤 ID 지정 및 얻기----------------------------------------*/

DeviceCheckView.h 화일

//}}AFX_MSG
DECLARE_MESSAGE_MAP()
afx_msg void OnChangeIoNo( UINT nID );
//-----

DeviceCheckView.cpp 화일

void CDeviceCheckView::DoDataExchange(CDataExchange* pDX)
{
CFormView::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CDeviceCheckView)
DDX_Radio(pDX, IDC_IONO1, m_nioNo);
//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CDeviceCheckView, CFormView)
//{{AFX_MSG_MAP(CDeviceCheckView)
ON_WM_TIMER()
//}}AFX_MSG_MAP
ON_COMMAND_RANGE(IDC_IONO1, IDC_IONO6, OnChangeIoNo)
END_MESSAGE_MAP()

void CDeviceCheckView::OnChangeIoNo( UINT nID )
{
m_nioNo = nID - IDC_IONO1;
}

/*------콘트롤 ID 지정 및 얻기---------------------------------------------*/
//--------------------------------------------------------------------------
ON_EVENT(CIODisplay, IDC_OUT_T0, -600 /* Click */, OnClickOutBtn, VTS_NONE)
ON_EVENT(CIODisplay, IDC_OUT_T1, -600 /* Click */, OnClickOutBtn, VTS_NONE)
ON_EVENT(CIODisplay, IDC_OUT_T2, -600 /* Click */, OnClickOutBtn, VTS_NONE)

void CIODisplay::OnClickOutBtn()
{
int id = GetFocus()->GetDlgCtrlID() - IDC_OUT_T0;
}
//--------------------------------------------------------------------------

/*------상속받아 콘트롤변수지정---------------------------------------------*/
#include "xShadeButton.h"
#include "SXButton.h"
DDX_Control(pDX, IDC_ESTOP, m_EStop);
m_EStop.SetIcon( IDI_ESTOP, 32, 32 );
m_EStop.SetImagePos( CPoint ( 2, SXBUTTON_CENTER ) );
m_EStop.SetTextPos( CPoint ( 28, SXBUTTON_CENTER ) );
m_EStop.SetFont(&m_sFont);

/*------상속받아 콘트롤 설정 ---------------------------------------------*/
#include "EditEx.h"
CEditEx m_CmdPos[2];
m_CmdPos[0].SubclassDlgItem(IDC_CMD_POS0, this);
m_CmdPos[0].bkColor( BLACK );
m_CmdPos[0].textColor( YELLOW );
m_CmdPos[0].setFont( 10, FW_ULTRABOLD, DEFAULT_PITCH | FF_DONTCARE, _T("궁서"));
m_CmdPos[0].SetWindowText("0.000");

SetDlgItemDouble(IDC_CMD_POS0, cmd_pos[0]);

// 지정한 컨트롤에 값을 보여준다.
void CCAMCFS20Dlg::SetDlgItemDouble(int nID, double value)
{
CString sTemp;
sTemp.Format("%.3f", value);
GetDlgItem(nID)->SetWindowText(sTemp);
}

// 지정한 컨트롤에서 값을 읽어온다.
double CCAMCFS20Dlg::GetDlgItemDouble(int nID)
{
double dRet;
CString sTemp;
GetDlgItem(nID)->GetWindowText(sTemp);
dRet = atof((LPCTSTR)sTemp);

return dRet;
}

/*------EnableWindow--------------------------------------------------------*/
EnableWindow(GetDlgItem(m_hDlg,IDC_BTN_START),FALSE);
EnableWindow(GetDlgItem(m_hDlg,IDC_BTN_STOP),TRUE);

char szBuf[256];
SetDlgItemText(m_hDlg, IDC_MSG, "Server Running");
GetDlgItemText(m_hDlg,IDC_LISTEN_EDIT,szBuf,256);

int iPort = atoi(szBuf);
memset(szBuf,0,256);

/*------EDIT CONTROL--------------------------------------------------------*/
void CWinDlg::WriteText(char* szData)
{
HWND hWndOutput;
int iChar;

hWndOutput = GetDlgItem(m_hDlg, IDC_EDIT_BOARD);
iChar = SendMessage(hWndOutput, EM_GETLIMITTEXT, 0, 0);
SendMessage(hWndOutput, EM_SETSEL, iChar, iChar);
SendMessage(hWndOutput, EM_REPLACESEL, FALSE, (LPARAM)szData);
SendMessage(hWndOutput, EM_REPLACESEL, FALSE, (LPARAM)"\r\n");
}

/*------Control Key--------------------------------------------------------*/
#define VK_NUMLOCK 0x90
#define VK_SCROLL 0x91

KeyCode=GetKeyState(VK_CONTROL);
if((KeyCode==CONTROLKEY1)||(KeyCode==CONTROLKEY2)){bConKey=TRUE;}

/*------Read Only----------------------------------------------------------*/
m_FileSaveAsButton[nCh].EnableWindow(FALSE);
m_ItemSelectCombo[nCh].EnableWindow(nMode);
m_SetRevCheckBox[nCh].EnableWindow(nMode);
m_TestViasstatic[nCh].SetReadOnly(nMode);

/*------Slider------------------------------------------------------------*/

m_SpotTopSlider.GetPos();//일반
// m_SpotLeftSlider.SetRange(0, 1024);//일반
m_SpotLeftSlider.SetValue(140); //NI 콘트롤

void CGraphResultPage3::OnPointerValueChangedSpotBottomSlider(long Pointer, VARIANT FAR* Value)
{
// TODO: Add your control notification handler code here
int nData=0;
nData = CNiVariant(Value);m_nSpotBottomLimit=nData;
}

/*------Message------------------------------------------------------------*/

// MessageBox(NULL,buf,title,MB_OK|MB_ICONEXCLAMATION);

// if (MessageBox("Module Aging Program Quit? ", " OLED Module Aging Program",
// /*MB_ICONQUESTION*/MB_ICONSTOP | MB_OKCANCEL) == IDOK) {
// OnClose();
// PostQuitMessage(0);
// }

RedrawWindow();//Invalidate(FALSE);

/*------ 콘트롤 Bmp-------------------------------------------------------------------*/
CBitmap m_ButtonBmp1;
m_ButtonBmp1.LoadBitmap(IDB_SAVEBUTTONBMP);
m_FileSaveAsButton[0].SetBitmap(m_ButtonBmp1);
RedrawWindow();//Invalidate(FALSE);

/*------ 콘트롤 Enable----------------------------------------------------------------*/
m_ccEdit1.SetReadOnly(TRUE);
m_ccButton1.EnableWindow(TRUE);

m_ccModeCheck1.ShowWindow(SW_SHOW);
m_ccModeCheck2.ShowWindow(SW_HIDE);
/*------------------------------------------------------------------------------------*/
/*------CT 콘트롤 제어----------------------------------------------------------------*/
m_cttPosition11.SetBackColor(RGB(255,0,0));
m_cttPosition11.SetForeColor(RGB(255,0,0));
m_cttPosition11.SetCaption("-120.000");
m_cttPosition11.ShowWindow(FALSE);

/*------NI 콘트롤 숨김----------------------------------------------------------------*/

m_nctlTestButton1.ShowWindow(FALSE);//숨김

/*------NI Graph----------------------------------------------------------------*/

m_ResultLineGraph1.GetAxes().Item(3.0).GetTicks().SetMajorTickColor(White);
m_ResultLineGraph1.GetPlots().Item(2.0).SetLineColor(White);
m_ResultLineGraph1.GetAxes().Item(1).GetLabels().SetColor(White);

m_ResultLineGraph1.GetAxes().Item(1).AutoScaleNow();
m_ResultLineGraph1.GetAxes().Item(2).AutoScaleNow();

m_ResultLineGraph1.GetAxes().Item(1).SetMinMax(m_GraphScaleMin_x,m_GraphScaleMax_x);
m_ResultLineGraph1.GetAxes().Item(2).SetMinMax(m_GraphScaleMin_y,m_GraphScaleMax_y);

//==================================================================================
/*------DlgList [..][]------------------------------------------------------------*/
char szTemp[255];
   memset(szTemp, 0, 255);
   lstrcat(szTemp, "c:\\Data");
   CDialog::DlgDirList(szTemp, IDC_LISTBOX, NULL, DDL_EXCLUSIVE | DDL_DIRECTORY);

/*----------------------------------List Box Text 얻기----------------------------*/
//=================================================================================
CString strTmp="";
int nListNo=m_ccName.GetCurSel();

if(m_ccName.GetTextLen(nListNo)>0)
{
m_ccName.GetText(nListNo,strTmp);
}

m_ccModuleMeasureList.InsertString(nListNo,csFind);

nListNo=m_ccImageList.GetCurSel();

CString csFind;m_ccImageList.GetText(nListNo,csFind);
nListNo=m_ccModuleMeasureList.GetCurSel();
m_ccModuleMeasureList.DeleteString(nListNo);
m_ccModuleMeasureList.InsertString(nListNo,csFind);

int nListMax=flBox.GetCount();
csTmp.Format("%d",nListMax); AfxMessageBox(csTmp);

//==================================================================================

/*----------------------------------Multi Edit 한줄씩 얻기----------------------------*/
CString ReadData; CString strTmp="";
GetDlgItemText(IDC_INSTRUCT_EDIT, ReadData);
int index=0; int length=0;
char chBuf[2];

length = ReadData.GetLength();
int nListCount=0;

CString csLineData[CHMAX];
CString csBuf=_T("");

for(int i=0; i<length; i++)
{
csBuf=ReadData.Mid(i,1);
if(csBuf=="\n")
{
csBuf="";
nListCount++;
}
else
{
if(csBuf!="\r")
{
chBuf[0]=csBuf.GetAt(0);
chBuf[1]='\0';
csLineData[nListCount]+=chBuf;
}
}
}

for(int n=0; n<nListCount+1; n++)
AfxMessageBox(csLineData[n]);

/*----------------------------------콘트롤 생성-------------------------------------*/
// CComboBox m_pComboBox[CHMAX];
// CEdit m_pEditBox[CHMAX];
// CListBox m_pListBox[CHMAX];
// CButton m_pButton[CHMAX];

WS_THICKFRAME 콘트롤 크기 가변

RECT ovlScrRect;
m_Display.GetWindowRect(&ovlScrRect);
::CopyRect(&OverlayClientRect,&ovlScrRect);
ScreenToClient(&OverlayClientRect);

pVision->OutputOverlay(GetDC()->m_hDC,&ovlScrRect);
UpdateOverlayWindow();

/* CStatic *m_static;
m_static = new CStatic;
m_static->Create(_T("스태틱"),
WS_VISIBLE | SS_CENTER,
CRect(10,10,210,40),
this,
ID_SAMPLE_STATIC1);
*/

//리스트 박스 만들기
RECT rect1={10,100,200,200};
m_pListBox.Create(WS_CHILD | WS_VISIBLE | LBS_STANDARD,rect1,this,200);
m_pListBox.ShowWindow(SW_SHOW);
//데이터 삽입
m_pListBox.AddString("data1");
m_pListBox.AddString("data2");
m_pListBox.AddString("data3");

//에디터 박스 만들기
RECT rect2={210,10,400,100};
m_pEditBox.Create(
WS_CHILD | WS_VISIBLE |
ES_MULTILINE //여러 라인 입력
| ES_AUTOHSCROLL | ES_AUTOVSCROLL| //자동 수직,수평 스크롤
WS_BORDER |WS_VSCROLL,//외곽선과 수직 수크롤바 설정
rect2,this,300);
m_pEditBox.ShowWindow(SW_SHOW);

//콤보박스 만들기
RECT rect3={210,200,400,300};//콤보박스 출력 위치
//윈도우 만들기
m_pComboBox.Create(WS_CHILD | WS_VISIBLE|CBS_DROPDOWN ,rect3,this,400);
m_pComboBox.ShowWindow(SW_SHOW);
//콤보박스에 데이터를 넣는다.
m_pComboBox.AddString("cdata1");
m_pComboBox.AddString("cdata2");
m_pComboBox.AddString("cdata3");

/*------KeyBoadData------------------------------------------------------------------*/

void CTESTView::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags)
{
// TODO: Add your message handler code here and/or call default

CString csText=_T("");

csText=nChar;
AfxMessageBox(csText);

CFormView::OnChar(nChar, nRepCnt, nFlags);
}

/*------SendDlgItemMessage------------------------------------------------------------*/
SendDlgItemMessage(IDC_STATIC_WLREM, WM_SETTEXT,0,(LPARAM)(LPSTR)"DATA NONE");

/*-------라디오버튼-------Radio button------------------------------------------------*/
//-------------------------------------------------------------------------------------

tmModel.PCBType = (rbSata.GetCheck()?0:1);
tmModel.Rotate = (rbRetn.GetCheck()?false:true);
tmModel.ScrewCheck = (rbNChk.GetCheck()?false:true);
tmModel.ScrewType = (rbTyp1.GetCheck()?0:1);

m_Select11.SetCheck(TRUE);
m_Select11.SetCheck(FALSE);

m_ccModeCheck3.SetWindowText("Photo(uA)");

radio button
변수 생성시 Gruop 지정

0 : on
-1 : off

CNiPlot3D::PlotStyles style=m_Graph3D.GetPlots().Item(1).GetStyle();
m_Point.SetCheck((style == CNiPlot3D::PlotStyles::Point)? 1 : 0);
m_Line.SetCheck((style == CNiPlot3D::PlotStyles::Line)? 1 : 0);
m_LinePoint.SetCheck((style == CNiPlot3D::PlotStyles::LinePoint)? 1 : 0);

/*------------List Box 변수 선언 대입------------------------------------------------*/

CListBox m_ListBox[4];

m_ListBox[0].SubclassDlgItem(IDC_LIST1, this);
m_ListBox[1].SubclassDlgItem(IDC_LIST2, this);
m_ListBox[2].SubclassDlgItem(IDC_LIST3, this);
m_ListBox[3].SubclassDlgItem(IDC_LIST4, this);

m_ListBox[i].EnableWindow(FALSE);
m_ListBox[port-1].AddString(m_strReceived[port-1]);
m_ListBox[port-1].SetSel(m_ListBox[port-1].GetCount()-1, TRUE);

m_ListBox[0].ResetContent();//clear

m_ccModuleMeasureList.InsertString(nListNo,csFind);
//---List Control 빈문자 에러방지---------------------------------------------------
if(m_ccName.GetCount()>0)
{
m_ccName.SetCurSel(m_nListCurrentNo);

if(m_ccName.GetTextLen(m_ccName.GetCurSel())>0)
{
m_ccName.GetText(m_ccName.GetCurSel(),strTmp);
m_csName=strTmp;
}
else
{
m_csName=_T("");
}

strTmp.Format("%d / %d", m_nListCurrentNo, m_nListMaxCount);
SetDlgItemText(IDC_PAGEMODEL, strTmp);
}
// m_ccModule_A_JobList.SetItemHeight(nListMaxCount,LISTHIGH2);//넓게 표시

/*----------------------------Check Box On/Off제어---------------------------------*/

m_ccCheck.SetCheck(TRUE);//ON
m_ccCheck.SetCheck(FALSE);//OFF

/*----------------------------------커서 활성-------------------------------------*/

m_clbName.SetFocus();

/*----------------------------------콘트롤 보이기 숨기기--------------------------*/
m_TestButton.ShowWindow(SW_HIDE);//(FALSE)
m_TestButton.ShowWindow(SW_SHOW);//(TRUE)

/*------------콘트롤 생성--------------------------------------------------------*/
public:
CListBox m_pListBox;

RECT rect={10,100,200,200};

m_pListBox.Create(WS_CHILD|WS_VISIBLE|LBS_STANDARD,rect,this,200);
m_pListBox.ShowWindow(SW_SHOW);
m_pListBox.AddString("data1");
m_pListBox.AddString("data2");
m_pListBox.AddString("data3");

// m_ccName.GetText(m_ccName.GetCurSel(),strTmp);

/*------------콤보BOX Text제어--------------------------------------------------*/

CString csTmp;
int nNo=m_ccPalletSelect.GetCurSel();
m_ccPalletSelect.GetLBText(nNo,csTmp);
AfxMessageBox(csTmp);

for(i=0; i<10; i++)
{
m_ccCombo.DeleteString(i);
csText.Format("%dH:",i);
m_ccCombo.InsertString(i,csText);
}

/*------List Control-------------------------------------------------------------*/
CString csTmp;
m_ccNameList.AddString("DATA 1");

m_ccNameList.SetCurSel(0);
m_ccNameList.GetText(m_ccNameList.GetCurSel(),csTmp);

if(m_cliItemName.GetTextLen(m_cliItemName.GetCurSel())>0)
{
m_cliItemName.GetText(m_cliItemName.GetCurSel(),csTmp);
m_csItemName=csTmp;
}

for(i=m_ccName.GetCount()-1;i>=0;i--)
{m_ccName.DeleteString(i);}

if(m_cliItemName.GetCount()>0)
{
if(m_cliItemName.GetTextLen(m_nCurrentModelNo-1)>0)
{
m_cliItemName.GetText(m_nCurrentModelNo-1,strTmp);
}

SearchModelItemName(strTmp, false);
}

/*--------------------Edit-> 리스트Box로 사용-----------------------------------*/
void CFOOLPROOFView::Status_display(CString sdisplay)
{
//Edit -Control
if ( m_ComDisplay.GetLineCount() > 5)
{
m_ComDisplay.SetSel(0, -1);
m_ComDisplay.Clear();
}

sdisplay+="\r\n";
m_ComDisplay.ReplaceSel(sdisplay);

/*--------------------Edit-> 커서 생성-----------------------------------------*/
m_clbEdit.SetFocus();

}

//-------------Edit->GetWindowText----------------------------------------------------//
//-----------------------------------------------------------------------------------//
//--unsigned char-> CString , unsigned char-> char----------------------------------

int Length= m_ccEdit1.GetWindowTextLength();
unsigned char *temp = NULL;
temp = new unsigned char [Length];

char temp2[2]; CString csText;
m_ccEdit1.GetWindowText((LPSTR)temp,255);

for(int i=0; i<Length; i++)
{
temp2[0]=temp[i]; temp2[1]='\0';
csText+=(LPSTR)temp2;
}

AfxMessageBox(csText);

//----------------------------------------------------
char temp[255];
for(int i=0; i<255; i++) temp[i]='\0';

GetDlgItemText(IDC_EDIT1,(LPSTR)temp,255);
GetDlgItemText(IDC_EDIT1,(char*)temp,255);
CString csText=(LPSTR)temp;
AfxMessageBox(csText);

//-----------------------------------------------------------------------------------//
/*-------------Control에 고유번호 부여 호출-----------------------------------*/
CString Buf;
CString data;
CString BufSET;

int No=1001; /*Resource.h -#define IDC_EDIT 1001 */
int No2=1004;

data="A1입니다";
SetDlgItemText(No,data);

GetDlgItemText(No2,BufSET);
AfxMessageBox(BufSET);

UpdateData(FALSE);
/*----------------콘트롤에서 직접 text 얻기----------------------------------*/
GetDlgItemText(IDC_SELECT_NAME_SCHOOL_YEAR1, csName);
SetDlgItemText(IDC_PAGEMODEL, strText);

//===========================================
CString strRX, strRY;

CStatic *pRX, *pRY;
pRX = (CStatic *)GetDlgItem(IDC_LBL_RESULTX);
pRY = (CStatic *)GetDlgItem(IDC_LBL_RESULTY);
pRX->GetWindowText(strRX);
pRY->GetWindowText(strRY);
/*------------------------FluxGrid 텍스트 중앙위치---------------------------*/
m_GridData.SetCellAlignment(4);

/*-------------------StatusBar, 상태바---------------------------------------*/
void CMainFrame::DisplayMessage(CPoint point)
{
CString msg;
msg.Format("마우스 위치 : (%d, %d)",
point.x, point.y);
m_wndStatusBar.SetWindowText(msg);

CMainFrame *pFrame = (CMainFrame *)AfxGetMainWnd();
CRect rc;
pFrame->m_wndStatusBar.GetItemRect (0, rc);

pFrame->m_wndStatusBar.SetWindowText(csMsg);
}

/*-------------------ProgressBar----------------------------------------------*/

// ProgressBar표시를 위한 부분
CMainFrame *pFrame = (CMainFrame *)AfxGetMainWnd();
pFrame->m_pProgressBar.SetRange(0, height-tHeight);
pFrame->m_pProgressBar.SetStep(1);
CRect rc;
pFrame->pStatusBar->GetItemRect (0, rc);
pFrame->m_pProgressBar.MoveWindow(&rc);

pFrame->m_pProgressBar.StepIt();

//---------------------------------------------------------------------------*/

void CColorView::OnMouseMove(UINT nFlags, CPoint point)
{
//#include "MainFrm.h"
CMainFrame *pWnd = (CMainFrame*) AfxGetMainWnd();
pWnd->DisplayMessage(point);
CView::OnMouseMove(nFlags, point)
}

/*------------------------------SPIN Button 범위 지정--------------------*/

1-12 까지 범위지정
void CDBdeleteDlg::OnDeltaposMonthStartSpin(NMHDR* pNMHDR, LRESULT* pResult)
{
NM_UPDOWN* pNMUpDown = (NM_UPDOWN*)pNMHDR;
// TODO: Add your control notification handler code here
UpdateData(TRUE);
pNMUpDown->iPos = 0;
m_MonthStartEdit -= (pNMUpDown->iDelta);
if (m_MonthStartEdit<1)
{
m_MonthStartEdit = 1;
}
else if (m_MonthStartEdit>12)
{
m_MonthStartEdit = 1;
}

UpdateData(FALSE);

*pResult = 0;
}
/*------------------------------콘트롤 화면 확장 --------------------*/

void CModel::ExpandyaContract()
{
CRect rcDlg, rcMarker;
GetWindowRect(rcDlg);

if (!m_bExpanded)
{
m_nExpandedWidth = rcDlg.Width();
m_Devide.GetWindowRect(rcMarker);
m_nNormalWidth = (rcMarker.right - rcDlg.left);
rcDlg.SetRect(rcDlg.left, rcDlg.top,    rcDlg.left + m_nNormalWidth+12,
rcDlg.top + rcDlg.Height());
HWND hWndChild = ::GetDlgItem(m_hWnd, IDC_STATIC_DEVIDE);

while (hWndChild != NULL)
{
hWndChild = ::GetNextWindow(hWndChild, GW_HWNDNEXT);
::EnableWindow(hWndChild, m_bExpanded);
}
}

else
{
rcDlg.SetRect( rcDlg.left, rcDlg.top,    rcDlg.left + + m_nExpandedWidth,
rcDlg.top + rcDlg.Height() );
HWND hWndChild = ::GetDlgItem(m_hWnd, IDC_STATIC_DEVIDE);

while (hWndChild != NULL)
{
hWndChild = ::GetNextWindow(hWndChild, GW_HWNDNEXT);
::EnableWindow(hWndChild, m_bExpanded);
}

}

MoveWindow(rcDlg, TRUE);

m_bExpanded = !m_bExpanded;

/*--------------------------------------------------------------------------------------*/
//////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////// - HDC 얻기 - ////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------*/

CMainFrame *pFrame= (CMainFrame*)AfxGetMainWnd();ASSERT(pFrame);
pFrame->m_flagTemplate = TRUE;

CRect rect;rect.left=0;rect.right=100;rect.top=0;rect.bottom=200;

CDC *pDC; pDC = GetDC();
DrawRect(pDC, rect, RGB(0,0,255), 2);

CClientDC pDC(this);
DrawRect(&pDC, rect, RGB(0,0,255), 2);

HWND hParent = ::GetParent(m_hWnd);

CMainFrame* pWnd = (CMainFrame*)AfxGetApp()->m_pMainWnd;
HDC hDC = GetDC(pWnd->m_hWnd);

CDC *pDC; pDC = GetDC();
EraseBkgnd(pDC,m_CamRect,m_DisRect);

CMainFrame *pFrame = (CMainFrame *)AfxGetMainWnd();
CDC *pDC =pFrame->GetDC();

StretchDIBits(pDC->GetSafeHdc(),20,20,width,height,
0, 0,width, height, m_ColorGetImg, (LPBITMAPINFO)&dibHi, DIB_RGB_COLORS, SRCCOPY);

CPaintDC dc(this); // device context for painting
int width=m_CamRect.right; int height=m_CamRect.bottom;
// TODO: Add your message handler code here
CPaintDC dcView(GetDlgItem(IDC_IMG_HISTO_VIEW));

CRect rect;
GetDlgItem(IDC_IMG_HISTO_VIEW)->GetClientRect(&rect);
StretchDIBits(dcView.m_hDC,rect.left,rect.top,rect.right,rect.bottom, 0, 0,
width, height, m_pTestBitmap, &m_pBitmapInfo, BI_RGB, SRCCOPY);

CRect rect;
GetDlgItem(IDC_IMG_HISTO_VIEW)->GetWindowRect(&rect);
ScreenToClient(rect);
InvalidateRect(&rect, FALSE);

CMainFrame *pFrame = (CMainFrame *)AfxGetMainWnd();
//CChildFrame *pFrame = (CChildFrame *)AfxGetMainWnd();

// CPaintDC *pDC;
CDC *pDC =pFrame->GetDC();

CVisionSysView* pView =( CVisionSysView* )((CMainFrame*)AfxGetApp()->m_pMainWnd)->GetActiveView();
CVisionSysDoc *pDoc=pView->GetDocument();
CMainFrame *pFrame = (CMainFrame *)AfxGetMainWnd();
// CDC *pDC =pFrame->GetDC();
CDC *pDC =pView->GetDC();

/*-------------- HDC 얻기------------------------------------------------------------*/

CWnd *pWnd = GetDlgItem(IDC_CAMERA_VIEW);

void CGraphResultPage3::DrawBitmap()
{
if (m_buf==NULL) return;

CRect rect;
GetDlgItem(IDC_IMG_HISTO_VIEW)->GetWindowRect(&rect);
ScreenToClient(rect);
InvalidateRect(&rect, FALSE);
}

void CGraphResultPage3::OnPaint()
{
CPaintDC dc(this); // device context for painting

// TODO: Add your message handler code here
if (m_buf==NULL) return;

BYTE *tmp;
// DWORD-align for display
tmp = JpegFile::MakeDwordAlignedBuf(m_buf,m_width,m_height,&m_widthDW);
// set up a DIB
BITMAPINFOHEADER bmiHeader;
bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bmiHeader.biWidth = m_width; bmiHeader.biHeight = m_height;
bmiHeader.biPlanes = 1; bmiHeader.biBitCount = 24;bmiHeader.biCompression = BI_RGB;
bmiHeader.biSizeImage = 0; bmiHeader.biXPelsPerMeter = 0;
bmiHeader.biYPelsPerMeter = 0;bmiHeader.biClrUsed = 0;
bmiHeader.biClrImportant = 0;// CRect rect;

int width=bmiHeader.biWidth; int height=bmiHeader.biHeight;

CPaintDC dcView(GetDlgItem(IDC_IMG_HISTO_VIEW));
dcView.SetStretchBltMode(STRETCH_DELETESCANS);

CRect rect;
GetDlgItem(IDC_IMG_HISTO_VIEW)->GetClientRect(&rect);
StretchDIBits(dcView.m_hDC,rect.left,rect.top,rect.right,rect.bottom,
0, 0,width, height, tmp, (LPBITMAPINFO)&bmiHeader, DIB_RGB_COLORS, SRCCOPY);
delete [] tmp;
// Do not call CPropertyPage::OnPaint() for painting messages
}

/*-------------- HDC 얻기------------------------------------------------------------*/
CDC *theDC = GetDC();

if (theDC!=NULL) {

CRect clientRect;
GetClientRect(clientRect);

// Center It
UINT left = (clientRect.Width() - m_width) / 2;
UINT top = (clientRect.Height() - m_height) / 2;

// a 24-bit DIB is DWORD-aligned, vertically flipped and
// has Red and Blue bytes swapped. we already did the
// RGB->BGR and the flip when we read the images, now do
// the DWORD-align

BYTE *tmp;
// DWORD-align for display
tmp = JpegFile::MakeDwordAlignedBuf(m_buf,
   m_width,
   m_height,
   &m_widthDW);
// set up a DIB
BITMAPINFOHEADER bmiHeader;
bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bmiHeader.biWidth = m_width;
bmiHeader.biHeight = m_height; bmiHeader.biPlanes = 1;
bmiHeader.biBitCount = 24;
bmiHeader.biCompression = BI_RGB;
bmiHeader.biSizeImage = 0;
bmiHeader.biXPelsPerMeter = 0;
bmiHeader.biYPelsPerMeter = 0;
bmiHeader.biClrUsed = 0;
bmiHeader.biClrImportant = 0;

//---------------------------------------------
theDC->SetStretchBltMode(STRETCH_DELETESCANS);
//---------------------------------------------
// now blast it to the CDC passed in.
// lines returns the number of lines actually displayed

int lines = StretchDIBits(theDC->m_hDC,
BMP_START_EDGE_X1,BMP_START_EDGE_Y1,
512,
384,
0,0,
bmiHeader.biWidth,
bmiHeader.biHeight,
tmp,
(LPBITMAPINFO)&bmiHeader,
DIB_RGB_COLORS,
SRCCOPY);

delete [] tmp;

CString info;
info.Format("(%d x %d)", m_width, m_height);
theDC->SetBkMode(TRANSPARENT);
theDC->SetTextColor(RGB(0,0,0));
theDC->TextOut(10,5, info);

ReleaseDC(dc);

/*-------------- 다일로그/Propet 꽉찬 화면출력 화면-----------------------------------------*/

int CSETDlg::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if (CDialog::OnCreate(lpCreateStruct) == -1)
return -1;

// TODO: Add your specialized creation code here
ShowWindow(SW_SHOWMAXIMIZED);///화면 확대
UpdateWindow();
return 0;
}

/*-------------- Dialog를 메인화면으로 사용-----------------------------------------*/

#include "commtestDlg.h"

BOOL CCommtestApp::InitInstance()
{
// Standard initialization
// If you are not using these features and wish to reduce the size
// of your final executable, you should remove from the following
// the specific initialization routines you do not need.

#ifdef _AFXDLL
Enable3dControls(); // Call this when using MFC in a shared DLL
#else
Enable3dControlsStatic(); // Call this when linking to MFC statically
#endif

CCommtestDlg dlg;
m_pMainWnd = &dlg;
dlg.DoModal();

// Since the dialog has been closed, return FALSE so that we exit the
// application, rather than start the application's message pump.
return FALSE;
}
/*----------------------------------------------------------------------------------*/
MainFrame *pFrame=(CMainFrame*)AfxGetMainWnd();
CChildFrame *pChild=(CChildFrame*)pFrame->GetActiveFrame();
CWinColorDoc *pDoc=(CWinColorDoc*)pChild->GetActiveDocument();
CWinColorView *pView=(CWinColorView*)pChild->GetActiveView();
/*-------------- View 에서 App 얻기------------------------------------------------*/

CSECKLineDVM2App* pApp = (CSECKLineDVM2App*)AfxGetApp();
pApp->SetSerialInfo();

/*-------------- Doc 에서 View 얻기------------------------------------------------*/
CServerNetWorkView *pView=(CServerNetWorkView *)((CMainFrame *)AfxGetMainWnd())->GetActiveView ();
pView->Status_display(lpszMessage);

/*-------------- View에서 Doc 얻기------------------------------------------------*/
CSECKLineDVM2Doc* pDoc = GetDocument();

pDoc->
/*--------------메인프레임에서 View, Doc 얻기-------------------------------------*/
CSECKLineDVM2View* pView =
(CSECKLineDVM2View* )((CMainFrame*)AfxGetApp()->m_pMainWnd)->GetActiveView();

pView->

CCSECKLineDVM2MultiDoc *pDoc;
pDoc=pView->GetDocument();

pDoc->

/*--------------다일로그에서 View, MainFrame, Doc 얻기---------------------------*/
..Dlg.h화일에 참조선언
#include "SECKLineDVM2MultiDoc.h"

..Dlg.cpp화일에 참조선언
#include "CSECKLineDVM2MultiView.h"
#include "MainFrm.h"

CSECKLineDVM2MultiView *pView=(CSECKLineDVM2MultiView *)((CMainFrame *)AfxGetMainWnd())->GetActiveView ();
pView->

CMainFrame* pFrame;
pFrame = (CMainFrame*)AfxGetApp()->m_pMainWnd;

pFrame->

CSECKLineDVM2View* pView =( CSECKLineDVM2View* )((CMainFrame*)AfxGetApp()->m_pMainWnd)->GetActiveView();
CSECKLineDVM2Doc *pDoc;
pDoc=pView->GetDocument();

pDoc->

/*----------------------------다일로그 호출 종료----------------------------------*/
CProgressDlg Dlg;
Dlg.Create();
Dlg.DestroyWindow();

//--------------
EndDialog(IDOK);
CDialog::OnCancel();
EndDialog(IDCANCEL);
//--------------

/*------------------------MessageBox 선택-----------------------------------------*/
if (AfxMessageBox("모델코드를 찾지 못했습니다.!\n모델을 입력 하시겠습니까?.", MB_YESNO) == IDYES)
{
}
else
{
return;
}

/*-------------화면갱신----------------------------------------------------------*/

Invalidate(TRUE);
RedrawWindow();

/*-------------------------------------------------------------------------------*/

/*------------타이틀 제목 없애기-------------------------------------------------*/
BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
if( !CFrameWnd::PreCreateWindow(cs) )
return FALSE;
// TODO: Modify the Window class or styles here by modifying
// the CREATESTRUCT cs
cs.style^=FWS_ADDTOTITLE; //제목 없음 없에기
return TRUE;

cs.style = WS_SYSMENU | WS_CAPTION | WS_MINIMIZEBOX | WS_MAXIMIZE;
cs.lpszName = " WASS-2000 Scanning System";
cs.x = cs.y = 0;
cs.cx = rct.right;
cs.cy = rct.bottom;

}

/*----------------------전체 화면 출력 위치조정------------------------------*/
cs.x=200; cs.y=200; cs.cx=400; cs.cy=400;

/*----------------------다일로그 디스플레이 위치 변경------------------------*/
CExpansionDlg1* g_pExpansion = NULL;

if(!g_pExpansion)
{
g_pExpansion = new CExpansionDlg1(this);
g_pExpansion->MoveWindow(50,387,354,320,true);//x,y,with,high
Invalidate(TRUE);
}

/*------------------프로그램 종료--------------------------------------------*/
윈도우 "x" 종료 (도큐먼트에 설정)

void CMainFrame::OnClose()
{
// TODO: Add your message handler code here and/or call default

if (MessageBox("프로그램을 종료 하시겠습니까? ", " 재고관리프로그램",
/*MB_ICONQUESTION*/ MB_ICONSTOP | MB_OKCANCEL) == IDOK) {
PostQuitMessage(0);
CFrameWnd::OnClose();
}
}

BOOL CScrubDoc::SaveModified()
{
// TODO: Add your specialized code here and/or call the base class
if(AfxMessageBox("프로그램을 종료하시겠습니까?",MB_ICONQUESTION|MB_YESNO)==IDYES)
{
OnClose();
PostQuitMessage(0);
//((CMainFrame*)AfxGetApp()->m_pMainWnd)->SendMessage(WM_CLOSE,0,0);

}
else
{
return 0;
}

/* CMainFrame* m_pMainWnd;
CMainWidowCloseDoc* pDataDoc = GetDocument();

if(IDOK==AfxMessageBox("프로그램을 종료하시겠습니까?",MB_OKCANCEL))

m_pMainWnd->OnClose;
pDataDoc->OnCloseDocument();
*/ return CDocument::SaveModified();
}
{
if(AfxMessageBox("프로그램을 종료하시겠습니까?",MB_ICONQUESTION|MB_YESNO)==IDYES)
{
OnClose();
PostQuitMessage(0);
}
else
{
return;
}
}

/*--------------------프로그램 종료-------------------------------------------*/
::ExitProcess(-1);

/*--------------------프린트다일로그 않보이고 바로 출력하기-------------------*/
BOOL CManagementView::OnPreparePrinting(CPrintInfo* pInfo)
{
// default preparation
pInfo->m_bDirect=TRUE;
return DoPreparePrinting(pInfo);
}
/*---------------------------다일로그 호출-----------------------------------*/
CMyGraphDemoDlg dlg;
int nResponse = dlg.DoModal();
if (nResponse == IDOK)
{
// TODO: Place code here to handle when the dialog is
// dismissed with OK
}
else if (nResponse == IDCANCEL)
{
// TODO: Place code here to handle when the dialog is
// dismissed with Cancel
}

/*--------------------------------------------------------------------------------------*/
//////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////// - Windows 제 어 - ////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------*/

/*-----------------------------------------------------------------------------------*/
/*-------------- 다일로그 크기조절 ---------------------------------------*/
/*-----------------------------------------------------------------------------------*/

SetWindowText("Image View");
MoveWindow(50, 50,400,300); //x위치, y위치, x Size, y Size

/*-----------------------------------------------------------------------------------*/
/*-------------- 윈도우 항상 위에 활성 ---------------------------------------*/
/*-----------------------------------------------------------------------------------*/
BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
cs.dwExStyle = WS_EX_TOPMOST;
}

/*-----------------------------------------------------------------------------------*/
/*-------------- Menu Bar를 지우기 ---------------------------------------*/
/*-----------------------------------------------------------------------------------*/

CMenu* pMenu = new CMenu;
pMenu->Attach(cs.hMenu);
pMenu->DestroyMenu();
cs.hMenu = NULL;
delete pMenu;

/*-----------------------------------------------------------------------------------*/
/*-------------- 화면 갱신 ---------------------------------------*/
/*-----------------------------------------------------------------------------------*/

CStatic m_PcbImageView;
CRect m_rectLargeCanvas;

m_PcbImageView.GetWindowRect(&m_rectLargeCanvas);
ScreenToClient(&m_rectLargeCanvas);
InvalidateRect(m_rectLargeCanvas,FALSE);
//===============================================

Invalidate(TRUE);Invalidate(false);
RedrawWindow();
UpdateAllViews(FALSE);
UpdateData(FALSE);

/*------Hot Key------------------------------------------------------------*/
//--------------------------------------------------------------------------
BOOL CBroadView::PreTranslateMessage(MSG* pMsg)
{
// TODO: Add your specialized code here and/or call the base class
if (pMsg->message==MM_MCINOTIFY) {
if (pMsg->wParam==MCI_NOTIFY_SUCCESSFUL) {
StopWav();
}
}
if (pMsg->message==MY_MSG_FIRE_OFF) {
FireOff();
}
if (pMsg->message==WM_KEYDOWN) {
if (GetAsyncKeyState(VK_F1)&0x8000) {
if (GetAsyncKeyState(VK_F5)&0x8000) {
if (GetAsyncKeyState(VK_F9)&0x8000) {
if (m_SetupBtn.IsWindowVisible()==FALSE) {
FuncBtnShow(SW_SHOW);
}
}
}
}

// 2007.2.15
if (GetAsyncKeyState(VK_F6)&0x8000){m_bPingViewChk=TRUE;Invalidate(FALSE);SetTimer(REDRAW_TIMER,2000,NULL);}//RedrawWindow();

}

return CFormView::PreTranslateMessage(pMsg);
}
/*-------------- 메인프레임 상속 받아 다일로그 호출-----------------------------------------*/
//--------------------------------------------------------------------------------------------
void ResultShowDlgBar(CString str)
{
CMainFrame *pFrame = (CMainFrame *)AfxGetMainWnd();
CRect rect;
pFrame->GetWindowRect(&rect);

if (!pFrame->m_ResultShowBar.IsWindowVisible())
{
pFrame->DockControlBar(&pFrame->m_ResultShowBar);
pFrame->m_ResultShowBar.ShowWindow(SW_SHOW);
pFrame->FloatControlBar(&pFrame->m_ResultShowBar,CPoint(rect.right-324,rect.bottom-125));
}

}

/*-----------------------------------------------------------------------------------*/
/*-------------- Extern File에서 다일로그제어 ---------------------------------------*/
/*-----------------------------------------------------------------------------------*/
#include "TestDlg.h"
CTestDlg *TestDlg;
TestDlg=NULL;

if(TestDlg->GetSafeHwnd() == NULL)
{
TestDlg= new CTestDlg;
TestDlg->Create(IDD_TESTDIALOG1);
//manu_Swstatus = MENU_MANUAL;//3
}
TestDlg->ShowWindow(FALSE);
// TestDlg->SetDlgItemText(IDC_DLGSTATIC,"TEST 2006.12");
TestDlg->m_csData="Dlg Text 2006";

if(TestDlg->GetSafeHwnd() != NULL) TestDlg->ShowWindow(true);

if(TestDlg->GetSafeHwnd() != NULL)
{
CString csTmp;
TestDlg->GetDlgItemText(IDC_DLGSTATIC,csTmp);
AfxMessageBox(csTmp);
}

//============================================================
void ResultShowDlgBar(CString str)
{
CMainFrame *pFrame = (CMainFrame *)AfxGetMainWnd();
CRect rect;
pFrame->GetWindowRect(&rect);

CEdit *pEdit = (CEdit *)pFrame->m_ResultShowBar.GetDlgItem(IDC_RESULTSHOW);
int nLength = pEdit->GetWindowTextLength();

if(nLength<10000) pEdit->SetSel(nLength, nLength);
else pEdit->SetSel(nLength-10000, nLength);
pEdit->ReplaceSel(str);
pFrame->RecalcLayout();
}
/*-----------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------*/
/*-------------- 다일로그 확장-------------------------------------------------------*/

int m_nNormalWidth;
int m_nExpandedWidth;
BOOL m_bExpanded;

   void CExpandDlgDlg::ExpandyaContract()
   {
CRect rcDlg, rcMarker;
GetWindowRect(rcDlg);

if (!m_bExpanded)
{
m_nExpandedWidth = rcDlg.Width();
m_Devide.GetWindowRect(rcMarker);
m_nNormalWidth = (rcMarker.right - rcDlg.left);
rcDlg.SetRect(rcDlg.left, rcDlg.top,    rcDlg.left + m_nNormalWidth+12,
rcDlg.top + rcDlg.Height());
HWND hWndChild = ::GetDlgItem(m_hWnd, IDC_STATIC_DEVIDE);

while (hWndChild != NULL)
{
hWndChild = ::GetNextWindow(hWndChild, GW_HWNDNEXT);
::EnableWindow(hWndChild, m_bExpanded);
}

}

else
{
rcDlg.SetRect( rcDlg.left, rcDlg.top,    rcDlg.left + + m_nExpandedWidth,
rcDlg.top + rcDlg.Height() );
HWND hWndChild = ::GetDlgItem(m_hWnd, IDC_STATIC_DEVIDE);

while (hWndChild != NULL)
{
hWndChild = ::GetNextWindow(hWndChild, GW_HWNDNEXT);
::EnableWindow(hWndChild, m_bExpanded);
}

}

MoveWindow(rcDlg, TRUE);

m_bExpanded = !m_bExpanded;

}

/*-----------------------------------------------------------------------------------*/
/*-------------- 투명 다일로그-------------------------------------------------------*/
#define WS_EX_LAYERED 0x00080000
#define LWA_COLORKEY 1 // Use color as the transparency color.
#define LWA_ALPHA 2 // Use bAlpha to determine the opacity of the layer

typedef BOOL (WINAPI *lpfn) (HWND hWnd, COLORREF cr, BYTE bAlpha, DWORD dwFlags);
lpfn g_pSetLayeredWindowAttributes;

HMODULE hUser32 = GetModuleHandle(_T("USER32.DLL"));
g_pSetLayeredWindowAttributes = (lpfn)GetProcAddress(hUser32, "SetLayeredWindowAttributes");
   HWND m_hCurrWnd;    // Handle to the window over which the mouse was last present
m_hCurrWnd=*this;
   if (g_pSetLayeredWindowAttributes)
   {
      ::SetWindowLong(m_hCurrWnd, GWL_EXSTYLE, GetWindowLong(m_hCurrWnd, GWL_EXSTYLE) | WS_EX_LAYERED);
      g_pSetLayeredWindowAttributes(m_hCurrWnd, 50, 100, LWA_ALPHA);
}
/*-----------------------------------------------------------------------------------*/
/*-------------- Windows 이벤트------------------------------------------------------*/
#define define WSA_ASYNC    (WM_USER+1)
//.h-----------------------------------
protected:
   //{{AFX_MSG(CHDDINSPView)
   afx_msg LONG UDPOnReceive(UINT,LONG);

//.cpp----------------------------------
BEGIN_MESSAGE_MAP(CHDDINSPView, CFormView)
//{{AFX_MSG_MAP(CHDDINSPView)
//}}AFX_MSG_MAP
ON_MESSAGE(WSA_ASYNC,UDPOnReceive)

LONG CHDDINSPView::UDPOnReceive(UINT wParam, LONG lParam)
{
}

/*-----------------------------------------------------------------------------------*/
/*-------------- 스레드에서 변수 참조------------------------------------------------*/

UINT RepeatThread(LPVOID pFuncData)
{
CCAMCFS20Dlg *pParent = (CCAMCFS20Dlg *)pFuncData;
INT16 nAxis;
double dDistance, dVelocity, dAccel;

nAxis = pParent->m_nAxis;
dDistance = pParent->GetDlgItemDouble(IDC_DISTANCE);
dVelocity = pParent->GetDlgItemDouble(IDC_VELOCITY);
dAccel = pParent->GetDlgItemDouble(IDC_ACCELERATION);
pParent->bRepeatFlag = TRUE;
}

void CWinColorView::OnDraw(CDC* pDC)
{
CWinColorDoc* pDoc = GetDocument();
ASSERT_VALID(pDoc);

// TODO: add draw code for native data here
if(pDoc->m_InImg==NULL) return;

height = pDoc->dibHi.biHeight;
width = pDoc->dibHi.biWidth;
rwsize = WIDTHBYTES(pDoc->dibHi.biBitCount*pDoc->dibHi.biWidth);
BmInfo->bmiHeader = pDoc->dibHi;

SetDIBitsToDevice(pDC->GetSafeHdc(),0,0,width,height,
0,0,0,height,pDoc->m_InImg,BmInfo, DIB_RGB_COLORS);
}

/*--------------------------------------------------------------------------------------*/
//////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////// - 기타 정리 - ///////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------*/

//------프로그램 폴더안에 include화일 참조 선언 -----------------------------------------//
#include "../include/PortInclude.h"

//---------------------------------------------------------------------------------------//

//---시간 계산---------------------------------------------------------------------------//
double m_lStartTimeOneChipCycle = GetCurrentTime();
double m_lEndTimeOneChipCycle = GetCurrentTime();
double m_OneCycleTime=(m_lEndTimeOneChipCycle - m_lStartTimeOneChipCycle) * 0.001;
//---------------------------------------------------------------------------------------//

/*----------------------------------시간 얻기-------------------------------------*/
COleDateTime ccTestTime;
CString strTmp;

ccTestTime=COleDateTime::GetCurrentTime();
// strTmp=ccTestTime.Format("%I:%M:%S %p");
strTmp=ccTestTime.Format("%I:%M:%S");
m_clbTime.SetCaption(strTmp);

int nTime;
COleDateTime odtDate=COleDateTime::GetCurrentTime();
nTime=odtDate.GetYear();
nTime=odtDate.GetMonth();
nTime=odtDate.GetDay();
nTime=odtDate.GetHour();
nTime=odtDate.GetMinute();
nTime=odtDate.GetSecond();

SYSTEMTIME SystemTime, SystemTime2;
GetSystemTime( &SystemTime);

GetSystemTime( &SystemTime2);
TRACE("JOG MINUS Time Value = %d \n", SystemTime2.wMilliseconds - SystemTime.wMilliseconds);
//---------------------------------------------------------------------------------------//

/* 선언부 */
#define PI 3.1415926535
#include <math.h>
#define RADIUS 150

// 1. 영역구함

CRect rect;
GetClientRect(rect);

// 2. 이미지 중간점 구함

int m_nCenterX = rect.Width() / 2; // Center X point
int m_nCenterY = rect.Height()/ 2; // Center Y point

// 3. 반지름

int nHalf = RADIUS; // 반지름

// 4. 계산할 각도 구함

int m_nAngle = 0;
m_nAngle = 360 / m_nRingNum; // m_nRingNum <-- 점의 갯

// 5. 저장할 점 선언

CPoint *pt;
for ( int i = 0; i < m_nRingNum ; i++)

{
int nAxisX = 0;
int nAxisY = 0;

if( i == 0)
{
nAxisX = (int)( cos(360*(PI / 180)) * nHalf ); // X point
nAxisY = (int)( sin(360*(PI / 180)) * nHalf ); // Y point
}
else

{
nAxisX    = (int)(    cos((m_nAngle*i)*(PI / 180)) * nHalf    );    // X point
nAxisY    = (int)(    sin((m_nAngle*i)*(PI / 180)) * nHalf    );    // Y point
}
// 6. 구한 점 저장

pt[i].x = nAxisX;
pt[i].y = nAxisY
}

/*--------------------------------------------------------------------------------------*/
//////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////// - 다른프로그램 실행 - /////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------*/

/*------인터넷사이트 실행------------------------------------------------------------*/
WinExec("C:\\Program Files\\Internet Explorer\\IEXPLORE.EXE www.taeyang.com",SW_SHOW);

WinExec("C:\\YeTools\\CpComSys\\CpPrc.exe",SW_SHOWMINIMIZED);

/*------응용프로그램 실행------------------------------------------------------------*/
h. 헤더파일 선언 PROCESS_INFORMATION m_pi; //다른 프로그램 자동 실행및 종료를 위한

STARTUPINFO StartupInfo = {0};
StartupInfo.cb = sizeof(STARTUPINFO);
PROCESS_INFORMATION ProcessInfo;

StartupInfo.dwFlags = STARTF_USESHOWWINDOW;
StartupInfo.wShowWindow = SW_HIDE;//안보이기 SW_SHOWMINIMIZED-최소화

if(!::CreateProcess(NULL, "C:\\YeTools\\CpComSys\\DLL\\CpPrc.exe",
//if(!::CreateProcess(NULL, "DataCPK.exe",
NULL, NULL, FALSE, 0, NULL, NULL, &StartupInfo, &ProcessInfo))
{
AfxMessageBox("C:\\YeTools\\CpComSys\\CpPrc.exe 실행 화일을 찾을 수 없습니다.");
}
m_pi = ProcessInfo;

// 종료------Close------------------------
HANDLE Killprocess;
CString szKillProgramName;
szKillProgramName = "C:\\YeTools\\CpComSys\\CpPrc.exe";//종료할 프로그램 위칭르 넣으 시요..
Killprocess = OpenProcess(PROCESS_TERMINATE,0,m_pi.dwProcessId);
TerminateProcess(Killprocess, (unsigned)-1);

C:\\Program Files\\Amfis1130\\SigmaTV.exe
/*
CloseHandle(m_pi.hProcess);
CloseHandle(m_pi.hThread);
LPSTR gAppName = "C:\\YeTools\\CpComSys\\CpPrc.exe";
if (FindWindow(gAppName, NULL)) {
PostQuitMessage(0);
}
*/

/*------NOTE PAD 실행------------------------------------------------------------*/
char csNote[128];
strcpy(csNote,"c:\\Windows\\NOTEPAD ");
strcat(csNote,filename);
WinExec(csNote,SW_SHOW);

//------CString에 저장 후 메모장으로 보기------------------------------------------
m_csDisplay="";m_bShowDisplay=true;
NotePadDisplay();

void Status_display(CString sdisplay)
{
if(m_bShowDisplay){m_csDisplay+=sdisplay+"\n"; if(m_csDisplay.GetLength()>=65550)m_csDisplay=""; }
}
void NotePadDisplay(void)
{
FILE *fp; CString Contents, datename, filename;
filename="test.txt";
if ((fp = fopen(filename,"w+")) == NULL) {
AfxMessageBox("File Open Error.");
fclose(fp);
return ;}

Contents.Insert(Contents.GetLength(),m_csDisplay);
fwrite(Contents,1,Contents.GetLength(),fp);
fclose(fp);

char csNote[128];
strcpy(csNote,"c:\\Windows\\NOTEPAD ");
strcat(csNote,filename);
WinExec(csNote,SW_SHOW);

strcpy(csNote,"c:\\WINNT\\NOTEPAD ");
strcat(csNote,filename);
WinExec(csNote,SW_SHOW);
}

/*------실행화일 디렉토리 구하기--- -------------------------------------------------------*/
//--------SetCurrentDirectory----------------------------------------------------------------
if( mDAT.tot < 1 ) return;
int stat;
char *str;
CString fname;
DATE_INF day;
str = new char[MAX_PATH+10];
::GetCurrentDirectory(MAX_PATH+1,str);
uiGetSysDate(&day);
fname.Format(_T("DOC\\%s%04d%02d%02d.TXT"),
//-----------------------------------------------------------
(char *)(LPCTSTR)mDAT.pid,day.yy%100,day.mo,day.dd);
//-----------------------------------------------------------
CFileDialog dlg(FALSE,"DOC",fname,OFN_HIDEREADONLY,"프린트화일 (*.TXT)|*.TXT");
stat = dlg.DoModal();
::SetCurrentDirectory(str);
delete str;
if( stat != IDOK ) return;
fname = dlg.GetPathName(); ApSaveSeekDataInfor(fname,mDAT);

char *str;
CString fname;
str = new char[_MAX_PATH+1];
::GetCurrentDirectory(_MAX_PATH+1,str);

AfxMessageBox((LPCTSTR)(char *)str);

//////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////// - 화 일 - /////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////

//======================================================================================
/*------파일 다일로그-----------------------------------------------------------------*/
//======================================================================================

//==============화일 다일로그 PATH 지정 sprintf (CString으로 지정이 않되는 경우)=============

CString csModelFile="C:\\AttachMachine\\Model\\MODEL1.txt";
char szBuf[1024];sprintf(szBuf,csModelFile);

//===============화일 Load 다일로그==========================================================
void CAttachMachineView::OnClickFileLoadBtn()
{
// TODO: Add your control notification handler code here
CFileDialog filedlg( TRUE,// TRUE : FileOpen, FALSE :FileClose
_T("ini"), // 디폴트 확장자
//_T("C:\\AttachMachine\\EquipSys\\*.*"), // 디폴트 파일명 --마지막\\*.*
_T("C:\\AttachMachine\\EquipSys\\Test.ini"), // 디폴트 파일명 --현재 사용 파일을 제시
OFN_ALLOWMULTISELECT | OFN_FILEMUSTEXIST| OFN_SHOWHELP,
// OPENFILENAME
// OFN_CREATEPROMPT
//"텍스트 파일 (*.txt) | *.txt |데이타 파일 (*.dat; *.hex) | *.dat; *.hex|모든 파일 (*.*) | *.* ||",
"File Load Data INI Files (*.ini)|*.ini||",
// 필터
// 부모 윈도우
NULL
);

if(filedlg.DoModal()==IDOK)
{
CString szFileDir=filedlg.GetPathName();
SEQ.csSpecFileName=szFileDir;
FileData_DataSysGet(szFileDir,FILE_SPEC);
Sub_SpecDataDisplay();
}
}

//================새로운 이름으로 저장 =====================================================
void CAttachMachineView::OnClickFileNewSaveBtn()
{
// TODO: Add your control notification handler code here
CString szFileName=""; CString csFileName="";
CString szFileDir="";
CString csTmp=""; CString csCh=""; CString csLoad="";
//CFileDialog filedlg(FALSE,_T(""),_T(csTmp),OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT,//저장
//CFileDialog filedlg(FALSE,_T(""),_T("C:\\AttachMachine\\Model\\*.*"),OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT,//저장
CFileDialog filedlg(FALSE,_T(""),_T("C:\\AttachMachine\\Model\\Test.ini"),OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT,//저장,현재 사용 파일을 제시

"Save AS Data INI Files (*.ini)|*.ini||",NULL);//"files (*.*)",NULL);
if (filedlg.DoModal()==IDOK)
{
szFileDir=filedlg.GetPathName(); //AfxMessageBox(szFileDir);//전체 화일+확장자까지
if(Sub_SpecDataFileSave(szFileDir))
{
SEQ.csSpecFileName=szFileDir;
}
else
AfxMessageBox("화일로 저장 하지 못했습니다.");
}
}

/*------파일열기 다일로그------------------------------------------------------------*/
void CFileDlgDlg::OnOpenFile()
{
// TODO: Add your control notification handler code here
CFileDialog dialog( TRUE,// TRUE : FileOpen, FALSE :FileClose
_T("txt"), // 디폴트 확장자
_T("C:\\Data\\*.*"), // 디폴트 파일명 --마지막\\*.*
OFN_ALLOWMULTISELECT | OFN_FILEMUSTEXIST| OFN_SHOWHELP,
// OPENFILENAME
// OFN_CREATEPROMPT
"텍스트 파일 (*.txt) | *.txt |데이타 파일 (*.dat; *.hex) | *.dat; *.hex|모든 파일 (*.*) | *.* ||",
// 필터
// 부모 윈도우
NULL
);

dialog.DoModal();
}

//---------------------------------------------------------------
CString InitialDir=Path_Image;// AfxMessageBox(Path_Model);
InitialDir+="*.*";

CString Title = "SET IMAGE LOAD";
//-------------------
LPSTR File = InitialDir.GetBuffer(InitialDir.GetLength()*2); //*char

CFileDialog ImgDlg(TRUE,_T(Title),_T(InitialDir),OFN_ALLOWMULTISELECT | OFN_FILEMUSTEXIST| OFN_SHOWHELP,
// CFileDialog ImgDlg(TRUE,_T(Title),File,OFN_ALLOWMULTISELECT | OFN_FILEMUSTEXIST| OFN_SHOWHELP,
"Image files (*.jpg)|*.jpg||",NULL);

if (ImgDlg.DoModal()==IDOK)
{
// tmModel.SetImage = ExtractFileName(ImgDlg->FileName);
// dpSname->CaptionFalse = tmModel.SetImage;
}
//---------------------------------------------------------------

void CFileDlgDlg::OnSaveFile()
{
// TODO: Add your control notification handler code here
CFileDialog dialog( FALSE,// TRUE : FileOpen,// FALSE :FileClose
_T("txt"), // 디폴트 확장자
_T("C:\\Data\\Untitled.txt"), // 디폴트 파일명
OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY,
// OPENFILENAME
// OFN_CREATEPROMPT
"텍스트 파일 (*.txt) | *.txt |데이타 파일 (*.dat; *.hex) | *.dat; *.hex|모든 파일 (*.*) | *.* ||",
// 필터
// 부모 윈도우
NULL
);
dialog.DoModal();
}
//===파일 읽기/저장 다일로그 ========================================================

CString szFileName=""; CString csFileName="";
CString szFileDir="";

CString csTmp=""; CString csCh=""; CString csLoad="";

// CFileDialog filedlg(TRUE,_T(""),_T(csTmp),OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT,//열기
CFileDialog filedlg(FALSE,_T(""),_T(csTmp),OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT,//저장
"Save AS Excel CSV Files (*.csv)|*.csv||",NULL);//"files (*.*)",NULL);

if (filedlg.DoModal()==IDOK)
{
szFileDir=filedlg.GetPathName(); AfxMessageBox(szFileDir);//전체 화일+확장자까지
szFileName=filedlg.GetFileTitle(); AfxMessageBox(szFileName);//입력 화일명만
szFileName=filedlg.GetFileName(); AfxMessageBox(szFileName);//입력 화일과 확장자 까지

//화일명 뺀 화일 Dir
int index1=0; int index2=0; int nMode=0;
index1=szFileDir.GetLength(); index2=szFileName.GetLength();
csTmp=szFileDir.Mid(0,(index1-index2));

szFileName=csTmp; AfxMessageBox(szFileName);
//_mkdir(szFileName);
}

//===읽기========================================================
//---------------------------------------------------------------
csFileDir=filedlg.GetPathName(); //전체 디렉토리+화일명+확장자
csFileName=filedlg.GetFileName();//화일명+확장자
//---------------------------------------------------------------
CString strFilter;
strFilter.LoadString(AFX_IDS_PICTUREFILTER);

CString strTitle;
strTitle.LoadString(AFX_IDS_PICTUREBROWSETITLE);

CFileDialog fdlg(TRUE, NULL, NULL,
OFN_FILEMUSTEXIST |
OFN_HIDEREADONLY |
OFN_PATHMUSTEXIST,
strFilter);

fdlg.m_ofn.lpstrTitle = strTitle;

int nResult = fdlg.DoModal();
SetFocus();

if (nResult != IDOK)
return;

CString strPath = fdlg.GetPathName();
//---------------------------------------------------
CString csFileName="";
CString csFileDir="";
CString csOpenDir; csOpenDir=CSProgramDir+CSFileSpecDataDir+CSDriveDataFileName+"\\";

CFileDialog filedlg(TRUE,_T("*.INI"),_T(csOpenDir),OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT,
"INI files (*.ini)|*.ini||",NULL);

if (filedlg.DoModal()==IDOK)
{
csFileDir=filedlg.GetPathName();
CString csTmp;CString csBuf; CString csImage;
if(csFileDir.GetLength()>0)
{
UpdateData(TRUE);
CString csDriveName=csFileDir;
CString filename = csDriveName;//+".ini";
FileData_UpdateCommandData(filename);
CommandDataUpdateDisplay();
UpdateData(FALSE);
}
}

//------------------------------------------------------------------
CString szFileName;

CFileDialog filedlg(TRUE,"bmp",NULL,OFN_FILEMUSTEXIST,
"BMP files (*.bmp)|*.bmp||",NULL);
// if (freezeMode==FREEZE_BITMAP)
{
if (filedlg.DoModal()==IDOK)
{
szFileName=filedlg.GetPathName();
szFileName=filedlg.GetFileName();
}
}

//-----------------------------------------------------------
int result;
result=filedlg.DoModal();

switch(result)
{
case IDOK:
szFileName=filedlg.GetPathName();
break;
}
return;

/=======================================================================================
// 화일
//======================================================================================

//==============화일 GetPrivateProfileString==================================================
char Retemp[256];
char Lotemp[256];
char Filetemp[2048];
char Postemp[256];

//상대 주소 -PLC
GetPrivateProfileString("CONFIG","REMOTE_ADDR","192.168.001.1",Retemp,256,".\\config.ini");
int iRePort = GetPrivateProfileInt("CONFIG","REMOTE_PORT",20000,".\\config.ini");
//현재 주소 -PC
GetPrivateProfileString("CONFIG","LOCAL_ADDR","192.168.001.200",Lotemp,256,".\\config.ini");
int iLoPort = GetPrivateProfileInt("CONFIG","LOCAL_PORT",20001,".\\config.ini");

// 작업모델 화일 Dir
GetPrivateProfileString("FILE","FILENAME","DataSpec.ini",Filetemp,2048,".\\config.ini");

CSFileSpecFileName=Filetemp;
FileData_DataSysGet(CSFileSpecFileName,FILE_SPEC);

// 카메라 X 위치 옵셋
GetPrivateProfileString("AXIS","CAM_POS_X","20",Postemp,256,".\\config.ini");
m_fCamOffsetPos_X=(float)atof((LPCSTR)Postemp);

// 카메라 Y 위치 옵셋
GetPrivateProfileString("AXIS","CAM_POS_Y","20",Postemp,256,".\\config.ini");
m_fCamOffsetPos_Y=(float)atof((LPCSTR)Postemp);

//==============화일 WritePrivateProfileString==================================================
char temp[256];
char Filetemp[2048];

memset(Filetemp, 0, 2048);
lstrcat(Filetemp, SEQ.csSpecFileName);

WritePrivateProfileString("FILE","FILENAME",Filetemp,CSProgramDir+"\\config.ini");

GetDlgItemText(IDC_LISTEN_EDIT,temp,256);
WritePrivateProfileString("CONFIG","LISTEN_PORT",temp,CSProgramDir+"\\config.ini");

//=======================================================================================
FILE *inn;
int i;
CString fstr = SysDir;
fstr += "\\calibration.rsl";

if( (inn= fopen(fstr,"r") ) != NULL )
{
for(i=0;i<7;i++)
fscanf(inn,"%lf",&m_Calib.Val[i]);
fclose(inn);
}
else
AfxMessageBox("File could not be opened.",MB_OK,0);

//=======================================================================================
FILE *inn;
CString fstr = SysDir;
fstr += "\\rotate.rsl";

if( (inn= fopen(fstr,"w") ) != NULL )
{
fprintf( inn, "%lf %lf %lf %lf\n",m_Rotate.a,m_Rotate.b,m_Rotate.c,m_Rotate.d);
fclose(inn);
}
else
AfxMessageBox("File could not be opened.",MB_OK,0);

//===============화일 복사===============================================================

sFileName=strSelectedPath + "\\" + "Pcb.dat";
tFileName=strBackUpPath + "\\" +"Pcb.dat";
CopyFile(sFileName, tFileName , false);

//===============확장자 검색=============================================================

fileName=fileDlg.GetPathName();
CString ext=fileName.Right(4);

if (!ext.CompareNoCase(".JPG"))
{
// AX_LoadJPG(fileName);
// SetDlgItemText(IDC_FILEDIR_STATIC, fileName);
}

if (!ext.CompareNoCase(".BMP"))
{
LoadBMPToSet(fileName);
// SetDlgItemText(IDC_FILEDIR_STATIC, fileName);
}

//=======================================================================================

FILE *fp;

fp=fopen(fileName,"rb");
if (fp==NULL) {
CString msg;
msg="Can't open file for reading :\n"+fileName;
m_errorText=msg;
return NULL;
}
else
{
if (fread((void *)(pixel),1,3,fp)==3)
{
*(outBuf+ADDr)=pixel[2]; // r
*(outBuf+ADDg)=pixel[1]; // g
*(outBuf+ADDb)=pixel[0];
}
}
fclose(fp);

//=====================================================================================

HFILE fi;

CString Contents=csData; CString csfilename="";
// csfilename=CSFileTestDataDir+csFileName;
csfilename =FileData_TestFileDirChk(csFileName, nMode, nCh);
fi=_lopen(csfilename,OF_READWRITE);
int len;
len=_lwrite(fi,(LPCSTR)m_csTestFileData[nCh],strlen(m_csTestFileData[nCh]));
_lclose(fi);

/*------파일 -------------------------------------------------------*/
CString csfilename=_T(""); CString Contents=_T("");

if(nCh>=CHMAX) return Contents;
// filename = CSFileTestDataDir+csFileName;
csfilename =FileData_TestFileDirChk(csFileName, FILE_CSV, nCh);

CFile file(csfilename,CFile::modeReadWrite|CFile::shareExclusive);
// CFile file("C:\\Polaronix\\Data\\Ch01.csv",CFile::modeReadWrite |CFile::shareExclusive);
DWORD filesize=file.GetLength();
char *buf=new char[filesize+1];

file.Read(buf,filesize);
file.Close();

buf[filesize]=NULL;
Contents=LPCSTR(buf); delete buf;
return Contents;

/*------파일 -------------------------------------------------------*/
CString csData="";
char* pFileName = "C:\\Polaronix\\Data\\Ch01.csv";
CStdioFile file;
if( !file.Open( pFileName,
// | CFile::modeWrite | CFile::typeText ) ) {
CFile::modeRead | CFile::typeText ) ) {
}
file.ReadString(csData);
AfxMessageBox(csData);
file.Close();

/*------파일 Open--------------------------------------------------*/
csBmpFile=_T("Bin\\bmp3_96.bin");

CFile *aFile;
try
{
aFile=new CFile(csBmpFile,CFile::modeCreate | CFile::modeNoTruncate | CFile::modeReadWrite | CFile::shareDenyNone);
}
catch(CFileException *e)
{
e->Delete();
}
aFile->Abort(); //파일 닫기 실한 경우 예외 발생 않함
// aFile->Close();
// delete aFile;

CString csBmpFile;
csBmpFile=_T("Bin\\bmp1_128.bin");

CFile *aFile;
try
{
// UINT readByte;
aFile=new CFile(csBmpFile,CFile::modeNoTruncate|CFile::modeReadWrite|CFile::shareDenyNone);

if(m_ZoomSize_X==96)
{
aFile->Write(temp2,12288);
}
else
{
aFile->Write(temp2,24576);
}
}
catch(CFileException *e)
{
e->Delete();
}

aFile->Abort(); //파일 닫기 실패한 경우 예외 발생 않함
// aFile->Close();
// delete aFile;

/*------파일 Open--------------------------------------------------*/

HFILE fi;
fi=_lopen("Bin\\bmp.bin",OF_READWRITE);

int len;
len=_lwrite(fi,(LPCSTR)temp1,strlen(temp1));

_lclose(fi);

FILE *fp;
filename="Bin\\bmp.bin";

if ((fp = fopen(filename,"w+")) == NULL) {
AfxMessageBox("File Open Error.");
fclose(fp);
return ;
}
// Contents.Insert(Contents.GetLength(),
// Contents.Format(csBmp);
fwrite(Contents,1,Contents.GetLength(),fp);
fclose(fp);

/*------파일 Open--------------------------------------------------*/
#SETUP$
DF34257
CAS124T0
AS1234DF
SDFG4321
#ENDEQ$

void CSBottleView::FileDataUpdate(int nMode)
{
CString csItemNameSelectFileName=_T("EquipSys\\ItemNameSelect.ini");

__int16 length, exist;
char str[200];
int index=0;
int nCount=0;

FILE *fp ;
CString filename=_T("");
CString ReadData=_T("");
CString strTmp=_T("");
BOOL bFileCheck=false;
BOOL bFileCheck2=false;

m_csModelItemName[1]=_T("");
m_csModelItemName[2]=_T("");
m_csModelItemName[3]=_T("");
m_csModelItemName[4]=_T("");

if(nMode==ITEMNAME)
filename = csItemNameSelectFileName;
else return;

exist = access(filename,0);

if (!exist && (fp = fopen(filename,"rt")) != NULL) {
while (!feof(fp)) {
ReadData.Empty();
if ( fgets(str, 200, fp) != NULL) { // error Return NULL
ReadData.Format("%s", str);
length = ReadData.GetLength();

if(bFileCheck2==false)
{
index = ReadData.Find("#SETUP$");
if(index>=0){bFileCheck=true; index=0; }
else{AfxMessageBox("설정 데이타가 없습니다 !"); break;}
}

index = ReadData.Find("\t");
if(index>=0)
{
ReadData.Format("%s", ReadData.Mid(0 , length-2));
}
else
{
ReadData.Format("%s", ReadData.Mid(0 , length-1));
}

if(ReadData=="#ENDEQ$"){break;}

if(bFileCheck)
{
if(bFileCheck2)
{
if(nCount>=60){AfxMessageBox("저장된 데이타가 너무많습니다");break;}

if(nCount==0)
{m_csModelItemName[1]=ReadData;}
else if(nCount==1)
{m_csModelItemName[2]=ReadData;}
else if(nCount==2)
{m_csModelItemName[3]=ReadData;}
else if(nCount==3)
{m_csModelItemName[4]=ReadData;}
nCount++;
}
}
bFileCheck2=true;
}
}
/// fclose(fp);

} else {
AfxMessageBox("설정데이타가 없습니다! ItemNameSelect.data 화일이 없습니다."); return;//return 않하면 프로그램 에러
}
fclose(fp);

UpdateData(FALSE);
}

/*------파일 Open--------------------------------------------------*/

FILE *fpRobot;
CString str;

fpRobot = fopen("robot.txt", "rw+");
fprintf(fpRobot, "%s", str);
fclose( fpRobot );

/*------파일 생성 및 NotePad로 실행--------------------------------------------------*/
FILE *fp;
CString Contents, datename, filename;

filename="test.txt";

if ((fp = fopen(filename,"w+")) == NULL) {
AfxMessageBox("File Open Error.");
fclose(fp);
return ;
}

Contents.Format("\r\n=== FILE INFORMATION ===\r\n");
Contents.Insert(Contents.GetLength(),"\r\nDATE & TIME\t");
Contents.Insert(Contents.GetLength(),datename);

Contents.Insert(Contents.GetLength(),"\r\nOPERATOR\t");

Contents.Insert(Contents.GetLength(),"\r\n\r\nFile Name\t");
Contents.Insert(Contents.GetLength(),filename);
Contents.Insert(Contents.GetLength(),"\r\n\r\n");

Contents.Insert(Contents.GetLength(),"=== ERROR LISTS ===\r\n\r\n");

Contents.Insert(Contents.GetLength(),
" ERR TIME\tCODE\tERROR MESSAGE \tOPERATORr\n\r\n");

fwrite(Contents,1,Contents.GetLength(),fp);
fclose(fp);

char csNote[128];
strcpy(csNote,"c:\\Windows\\NOTEPAD ");
strcat(csNote,filename);
WinExec(csNote,SW_SHOW);

/*----------------다른 폴더에서 파일copy 후 다른이름으로 저장 -------------*/
SHFILEOPSTRUCT sfo;
memset(&sfo,0,sizeof(sfo));
sfo.wFunc = FO_COPY;
sfo.pFrom = _T("C:\\Aatool\\equip1.dat\0");
sfo.pTo = _T("C:\\DATA\\suho.dat\0");
/* sfo.wFunc = FO_RENAME;
sfo.pFrom = _T("C:\\DATA\\equip1.dat\0");
sfo.pTo = _T("C:\\DATA\\ok.dat\0");
*/
SHFileOperation(&sfo);

/*----------------여러 화일 삭제 -----------------------------------------------------------*/
SHFILEOPSTRUCT sfo;
memset(&sfo,0,sizeof(sfo));
sfo.wFunc = FO_DELETE;
sfo.fFlags =OFN_SHOWHELP; //메시지 창 뛰우지 않음
sfo.pFrom = _T("Bmp\\*.*");
SHFileOperation(&sfo);

/*------------------------------화일삭제--DeleteFile---------------------------------------*/

UpdateData(TRUE);
CCPKView* pView =( CCPKView* )((CMainFrame*)AfxGetApp()->m_pMainWnd)->GetActiveView();

CCPKDoc *pDoc;
pDoc=pView->GetDocument();

int year,month;
year=month=0;
year=2001;
month=5;

if(AfxMessageBox(" ''Are You Sure ! DataBase delete ?'' ",MB_ICONQUESTION|MB_YESNO)==IDYES)
{
pDoc->DeleteDB(year,month);
}
else
{
return;
}

void CCPKDoc::DeleteDB(int year, int month)
{
CString csFile;

csFile.Format("DATA\\CPK%4d%02d.mdb", year, month);
DeleteFile((LPCTSTR)csFile);

csFile.Format("DATA\\CPK%4d%02d.ldb", year, month);
DeleteFile((LPCTSTR)csFile);
}

SHFILEOPSTRUCT sfo;
memset(&sfo,0,sizeof(sfo));
sfo.wFunc = FO_DELETE;
sfo.pFrom = _T("C:\\DATA\\200101.mdb\0");
SHFileOperation(&sfo);

/*----------------------------------Windows 레지스트리에 저장-----------------------*/
void CPSRecorderView::INI_Get()
{
char buff[1024];
CString m_csTmpString;
m_csTmpString = "NONE";
GetPrivateProfileString("TIME", "TESTTIME1", m_csTmpString.operator const char * (), (LPTSTR)buff, 20, "SAET32.INI");
m_fTestTime1= (float)atof((LPCSTR)buff);
}

void CPSRecorderView::INI_Write()
{
CString m_csTmpString;
m_csTmpString = "NONE";
m_csTmpString.Format("%0.1f", m_fTestTime1);
WritePrivateProfileString("TIME", "TESTTIME1", m_csTmpString.operator LPCTSTR(), "SAET32.INI");
}

/*----------------------------------BMP File저장-------------------------------------*/
void CCoilView::OnSaveimg() {
CFileDialog filedlg(FALSE,"bmp",NULL,OFN_OVERWRITEPROMPT,
"BMP files (*.bmp)|*.bmp||",this);
if (filedlg.DoModal()!=IDOK)
return;
CColorBmpFile bmp;
bmp.OpenWrite(filedlg.GetPathName(),640,480);
for (int y=479; y>=0; y-=2) {
BYTE rbuffer[640],gbuffer[640],bbuffer[640];
Data->GetLine(y,rbuffer,gbuffer,bbuffer);
bmp.WriteLineUpward(rbuffer,gbuffer,bbuffer);
bmp.WriteLineUpward(rbuffer,gbuffer,bbuffer);
}
bmp.Close();
m_strMessage = "저장되었습니다.";
UpdateData(FALSE);
}

/*----------------------------------goto-------------------------------------*/
goto fail;

fail:
MessageBox(NULL,"에러 입니다.","오류",MB_OK);
return FALSE;

/*--------------------------------------------------------------------------------------*/
//////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////// - 이미지 - ////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------*/

#define WIDTHBYTES(bits) ((DWORD)(((bits)+31) & (~31)) / 8)
#define WIDTHBYTES(bits) (((bits) + 31) / 32 * 4)

//======Center부터 검색 ======================================================================================
//===CenterSearch===========================
int x2=0, y2=0;
int half_x=width/2; int half_y=height/2;
float direct_y=-1; float direct_x=-1;
int Cnt_y1=0;int Cnt_y2=0;
int Cnt_x1=0;int Cnt_x2=0;
//==========================================

for(y=0; y<height-tHeight; y++)
{
//=====CenterSearch===================================
Cnt_y1++;
if(Cnt_y1>=2){Cnt_y1=0;Cnt_y2++;}
if(direct_y==1)direct_y=float(-1); else direct_y=1;
y2=int( half_y + (Cnt_y2* direct_y) );
Cnt_x1=0; Cnt_x2=0; direct_x=-1;
//===================================================
for(x=0; x<width-tWidth; x++)
{
//=====CenterSearch================================
Cnt_x1++;
if(Cnt_x1>=2){Cnt_x1=0;Cnt_x2++;}
if(direct_x==1)direct_x=float(-1); else direct_x=1;
x2=int( half_x + (Cnt_x2* direct_x) );
//=================================================

pDC.SetPixel(x2+100,y2+100,RGB(255,0,0));

}
}
//==========================================================================================================
void ReadArrayToPointBit24(BYTE * OutImg, unsigned char BufImg[768][1024], UINT width, UINT height)
{
CVisionSysView* pView =( CVisionSysView* )((CMainFrame*)AfxGetApp()->m_pMainWnd)->GetActiveView();
CDC *pDC =pView->GetDC();
//GrayImage =width*3;
//Dispay Image= ((24*width)+31)/32*4), ((DWORD)(((bits)+31) & (~31)) / 8)
//if(BufImg==NULL) return;
int x,y; int y2=0;
int nBit=0; nBit=24;

int rwsize = WIDTHBYTES(nBit*width);

int ADDr=0,ADDg=0,ADDb=0;
if(BufImg!=NULL)
{
for(y=0; y<nHeight; y++)
{
for(x=0; x<nWidth; x++)
{
y2=((height-1)-y);//-1 은 첫줄이 않나옴, y가 0일경우 문제
// y2=y;//-1 은 첫줄이 않나옴, y가 0일경우 문제

ADDr=(y2*rwsize)+(3*x)+2;
ADDg=(y2*rwsize)+(3*x)+1;
ADDb=(y2*rwsize)+(3*x)+0;

// BufRevImg[ADDr]=BufImg[y][x];
// BufRevImg[ADDg]=BufImg[y][x];
// BufRevImg[ADDb]=BufImg[y][x];
*(OutImg+ADDr)=BufImg[y][x];
*(OutImg+ADDg)=BufImg[y][x];
*(OutImg+ADDb)=BufImg[y][x];
// pDC->SetPixel(x+400,y,RGB(BufImg[ADDr],BufImg[ADDg],BufImg[ADDb]));
// pDC->SetPixel(x+400,y,RGB(BufImg[y][x],BufImg[y][x],BufImg[y][x]));
}
}
}
}

//==========================================================================================================
void CVisionSysView::OnDraw(CDC* pDC)
{
// TODO: Add your specialized code here and/or call the base class
CVisionSysDoc* pDoc = GetDocument();
ASSERT_VALID(pDoc);
CMainFrame *pFrame= (CMainFrame*)AfxGetMainWnd();
ASSERT(pFrame);

/// return;
int height=m_height;int width=m_width; int Bit=m_Bit;
int rwsize = WIDTHBYTES(Bit*width);
BITMAPINFOHEADER bmiHeader;
bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bmiHeader.biWidth = width; bmiHeader.biHeight = height;
bmiHeader.biPlanes = 1;
bmiHeader.biBitCount = Bit;
bmiHeader.biCompression = BI_RGB;
bmiHeader.biSizeImage = rwsize*height;//0;
bmiHeader.biXPelsPerMeter = 0;
bmiHeader.biYPelsPerMeter = 0;bmiHeader.biClrUsed = 0;
bmiHeader.biClrImportant = 0;// CRect rect;
CRect rect;

//=================================================================
//--Open Gray Image--
if(m_ColorGetImg!=NULL)//COLOR_IMAGE, SPOT_IMAGE, AUOT_IMAGE
{
/// CPaintDC dcView(GetDlgItem(IDC_IMG_VIEW));
/// dcView.SetStretchBltMode(STRETCH_DELETESCANS);
/// GetDlgItem(IDC_IMG_VIEW)->GetClientRect(&rect);

// StretchDIBits(dcView.m_hDC,rect.left,rect.top,rect.right,rect.bottom,
/// StretchDIBits(dcView.m_hDC,rect.left,rect.top,width,height,
// StretchDIBits(pDC->GetSafeHdc(),20,20,width,height,
// 0, 0,width, height, m_ColorGetImg, (LPBITMAPINFO)&dibHi, DIB_RGB_COLORS, SRCCOPY);
/// 0, 0,width, height, m_GrayImg, (LPBITMAPINFO)&bmiHeader, DIB_RGB_COLORS, SRCCOPY);

// SetDIBitsToDevice(pDC->GetSafeHdc(),0,0,width,height,
// 0,0,0,height,m_GrayImg,(LPBITMAPINFO)&bmiHeader, DIB_RGB_COLORS);
// DibDraw(pDC,0,0,height,width,m_ColorGetImg,24);
if(m_GrayImg!=NULL)DibDraw(pDC,0,0,height,width,m_GrayImg,Bit);
// DibDrawReverse(pDC,0,0,height,width,m_GrayImg,24);
}
//=================================================================
if(m_OutImg!=NULL)//이미지 가감 처리영상
{
int Add=640;
DibDrawArrayToBit24(pDC,0+Add,0,height,width,m_OutImg,24);
}
//=================================================================
// 마우스 드레그-템플레이트 정합을 위한 부분
if(m_flagMouse==TRUE)
{
//pDC->DrawEdge(&m_RectTrack,EDGE_ETCHED,BF_RECT);
DrawRect(pDC, m_RectTrack, RGB(0,0,255), 2);
}
if(pFrame->m_flagTemplate==TRUE) // template가 설정되어 있는 경우
{
if(m_TempImg!=NULL)
{
DibDrawBit8(pDC,width+40,0,tHeight,tWidth,m_TempImg,24);
rect.left=width+40; rect.top=0;
rect.right=rect.left+tWidth; rect.bottom=rect.top+tHeight;
DrawRect(pDC, rect, RGB(255,0,0), 2);
}
}
//==================================================================
//--이미지 검색 결과
if(!(m_MatchPos.right==0 && m_MatchPos.bottom==0))
{
if(m_bImageSearch)
{
// pDC->DrawEdge(&m_MatchPos,EDGE_BUMP,BF_RECT);
DrawRect(pDC, m_MatchPos, RGB(255,0,0), 2);
m_bImageSearch=FALSE;
}
}
//==================================================================
CClientDC pDC(this);

int width=m_width;int height=m_height;
if(m_ColorGetImg!=NULL)//COLOR_IMAGE, SPOT_IMAGE, AUOT_IMAGE
{
// CPaintDC dcView(GetDlgItem(IDC_IMG_VIEW));
// dcView.SetStretchBltMode(STRETCH_DELETESCANS);
// GetDlgItem(IDC_IMG_VIEW)->GetClientRect(&rect);
// StretchDIBits(dcView.m_hDC,rect.left,rect.top,rect.right,rect.bottom,
// StretchDIBits(dcView.m_hDC,rect.left,rect.top,width,height,
// 0, 0,width, height, m_ColorGetImg, (LPBITMAPINFO)&bmiHeader, DIB_RGB_COLORS, SRCCOPY);
StretchDIBits(pDC.GetSafeHdc(),20,20,width,height,
0, 0,width, height, m_ColorGetImg, (LPBITMAPINFO)&dibHi, DIB_RGB_COLORS, SRCCOPY);

// SetDIBitsToDevice(pDC->GetSafeHdc(),0,0,width,height,
// 0,0,0,height,m_ColorGetImg,(LPBITMAPINFO)&bmiHeader, DIB_RGB_COLORS);
}

//---------BMP File Save------------------------------------------------------------------------
//BMP File Save
int ImageMaxNo=1;
BITMAPINFOHEADER dibHi;
BITMAPFILEHEADER dibHf;/// CClientDC pDC(this);
int ADD1=0; int ADD2=0; int ADD3=0;
int x=0; int y=0; int y2=0;
int WidthLineSize=WIDTHBYTES(24*width);
int WidthLineSize2=WIDTHBYTES(8*width);
unsigned char *BmpOutImg=NULL;
BmpOutImg = new unsigned char [(height*ImageMaxNo)*(width*24)*3];

BmpOutImg =buf;

for(y=0; y<height*ImageMaxNo; y++) //BMP 화일로 저장 하기위해 거꾸로 저장
{
y2=((height*ImageMaxNo)-y);//-1 중요(최종 한줄 표현)
for(x=0; x<width; x++)
{
ADD1=(y2*WidthLineSize)+(3*x)+2;
ADD2=(y2*WidthLineSize)+(3*x)+1;
ADD3=(y2*WidthLineSize)+(3*x)+0;

BmpOutImg[(y2*WidthLineSize)+(3*x)+2]=buf[(y*WidthLineSize)+(3*x)+2];
BmpOutImg[(y2*WidthLineSize)+(3*x)+1]=buf[(y*WidthLineSize)+(3*x)+1];
BmpOutImg[(y2*WidthLineSize)+(3*x)+0]=buf[(y*WidthLineSize)+(3*x)+0];
// pDC->SetPixel(x+500,y,RGB(BmpOutImg[ADD1],BmpOutImg[ADD2],BmpOutImg[ADD3]));
}
}

DWORD dwBitsSize = sizeof(BITMAPINFOHEADER)+sizeof(RGBQUAD)*256+WidthLineSize*height*sizeof(char);

dibHi.biSize=40;
dibHi.biWidth=width;
dibHi.biHeight=height*ImageMaxNo;
dibHi.biPlanes=1;
dibHi.biBitCount =24;
dibHi.biCompression=BI_RGB;
dibHi.biSizeImage = 3*WidthLineSize*(height*ImageMaxNo);
dibHi.biXPelsPerMeter=0;
dibHi.biYPelsPerMeter=0;
dibHi.biClrUsed = dibHi.biClrImportant =0;

dibHf.bfType=0x4D42;
dibHf.bfSize = dwBitsSize+sizeof(BITMAPFILEHEADER); // 전체파일 크기
if(dibHi.biBitCount==24) dibHf.bfSize -= sizeof(RGBQUAD)*256; // no pallette
dibHf.bfOffBits = dibHf.bfSize - WidthLineSize*height*sizeof(char);
dibHf.bfReserved1=dibHf.bfReserved2=0;

FILE *outfile2;
CString csFile; csFile.Format("C:\\Data\\D1_Project\\두오텍\\VisionSys\\bmp\\spec.bmp");
outfile2 = fopen(csFile,"wb");

fwrite(&dibHf,sizeof(char),sizeof(BITMAPFILEHEADER),outfile2);
fwrite(&dibHi,sizeof(char),sizeof(BITMAPINFOHEADER),outfile2);
fwrite(BmpOutImg,sizeof(char),3*WidthLineSize*dibHi.biHeight,outfile2);
// fwrite(buf,sizeof(char),3*WidthLineSize*dibHi.biHeight,outfile2);
fclose(outfile2);
if(BmpOutImg) delete []BmpOutImg;

//------------------------------------------------------------------------------------------------------------------------
void CNG::OnPaint()
{
CPaintDC pDC(this); // device context for painting

// TODO: Add your message handler code here
if (m_ColorImg==NULL) return;

int height=m_height;int width=m_width;
int rwsize = WIDTHBYTES(24*width);

BITMAPINFOHEADER bmiHeader;
bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bmiHeader.biWidth = width; bmiHeader.biHeight = height;
bmiHeader.biPlanes = 1; bmiHeader.biBitCount = 24;bmiHeader.biCompression = BI_RGB;
bmiHeader.biSizeImage = rwsize*height;//0;
bmiHeader.biXPelsPerMeter = 0;
bmiHeader.biYPelsPerMeter = 0;bmiHeader.biClrUsed = 0;
bmiHeader.biClrImportant = 0;// CRect rect;

CRect rect;

if(m_ColorImg!=NULL)//COLOR_IMAGE, SPOT_IMAGE, AUOT_IMAGE
{
CPaintDC dcView(GetDlgItem(IDC_IMAGE1));
dcView.SetStretchBltMode(STRETCH_DELETESCANS);
GetDlgItem(IDC_IMAGE1)->GetClientRect(&rect);

StretchDIBits(dcView.m_hDC,rect.left,rect.top,rect.right,rect.bottom,
// StretchDIBits(dcView.m_hDC,rect.left,rect.top,width,height,
// StretchDIBits(pDC->GetSafeHdc(),20,20,width,height,
// 0, 0,width, height, m_ColorGetImg, (LPBITMAPINFO)&dibHi, DIB_RGB_COLORS, SRCCOPY);
0, 0,width, height, m_ColorImg, (LPBITMAPINFO)&bmiHeader, DIB_RGB_COLORS, SRCCOPY);

// SetDIBitsToDevice(pDC.GetSafeHdc(),0,0,width,height,
// 0,0,0,height,m_ColorGetImg,(LPBITMAPINFO)&bmiHeader, DIB_RGB_COLORS);
}
// Do not call CDialog::OnPaint() for painting messages
}

//-----------------------------------------------------------------------------------------------------------------------
void DibDraw(CDC *pDC, int px, int py, int height, int width, BYTE *BufImg, int Bit)
{
int x,y; int y2=0;
int nBit=0; nBit=Bit;
int rwsize = WIDTHBYTES(nBit*width);//(((8*width)+31)/32*4); // 4바이트의 배수여야 함
BITMAPINFO *BmInfo;
BmInfo = (BITMAPINFO*)malloc(sizeof(BITMAPINFO)+256*sizeof(RGBQUAD));

BmInfo->bmiHeader.biBitCount=nBit;
BmInfo->bmiHeader.biClrImportant=256;//0
BmInfo->bmiHeader.biClrUsed=256;//0
BmInfo->bmiHeader.biCompression=BI_RGB;//0

BmInfo->bmiHeader.biHeight = height;
BmInfo->bmiHeader.biPlanes=1;
BmInfo->bmiHeader.biSize=40;//=sizeof(BITMAPINFOHEADER);

if(nBit==24)
BmInfo->bmiHeader.biSizeImage=rwsize*height*3;
else
BmInfo->bmiHeader.biSizeImage=rwsize*height;

BmInfo->bmiHeader.biWidth =width;
BmInfo->bmiHeader.biXPelsPerMeter=0;
BmInfo->bmiHeader.biYPelsPerMeter=0;

for(x=0; x<256; x++) // Palette number is 256
{
BmInfo->bmiColors[x].rgbRed= BmInfo->bmiColors[x].rgbGreen = BmInfo->bmiColors[x].rgbBlue = x;
BmInfo->bmiColors[x].rgbReserved = 0;
}

if(nBit==24)
{
int ADDr=0,ADDg=0,ADDb=0;
int ADDr2=0,ADDg2=0,ADDb2=0;
unsigned char *BufRevImg = new unsigned char [(width*24)*height*3];
/*
if(BufImg!=NULL)
{
for(y=0; y<height; y++)
{
for(x=0; x<width; x++)
{
y2=((height-1)-y);//-1 은 첫줄이 않나옴, y가 0일경우 문제
ADDr=(y*rwsize)+(3*x)+2;
ADDg=(y*rwsize)+(3*x)+1;
ADDb=(y*rwsize)+(3*x)+0;

ADDr2=(y2*rwsize)+(3*x)+2;
ADDg2=(y2*rwsize)+(3*x)+1;
ADDb2=(y2*rwsize)+(3*x)+0;

BufRevImg[ADDr]=BufImg[ADDr2];
BufRevImg[ADDg]=BufImg[ADDg2];
BufRevImg[ADDb]=BufImg[ADDb2];
// pDC->SetPixel(x+400,y,RGB(BufImg[ADDr],BufImg[ADDg],BufImg[ADDb]));
}
}
}
*/
int ImgSize=(width*24)*height*3;//int ImgSize=(width*8)*height;//8
memcpy(BufRevImg,BufImg,ImgSize);
// SetDIBitsToDevice(pDC->GetSafeHdc(),px,py,width,height,
// 0,0,0,height,BufImg,(LPBITMAPINFO)&dibHi, DIB_RGB_COLORS);
// SetDIBitsToDevice(pDC->GetSafeHdc(),px,py,width,height,
// 0,0,0,height,BufImg,BmInfo, DIB_RGB_COLORS);
SetDIBitsToDevice(pDC->GetSafeHdc(),px,py,width,height,
0,0,0,height,BufRevImg,BmInfo, DIB_RGB_COLORS);
delete []BufRevImg;
}
else
{
unsigned char *BufRevImg = new unsigned char [height*rwsize];
int index1,index2=0;
for(y=0; y<height; y++)
{
index1 = y*rwsize;
index2 = (height-y-1)*width;
// index2 = y*width;
for(x=0; x<width; x++)
{
BufRevImg[index1+x]=BufImg[index2+x];
// pDC->SetPixel(j,i,RGB(BufImg[index2+x],BufImg[index2+x],BufImg[index2+x]));
}
}

SetDIBitsToDevice(pDC->GetSafeHdc(),px,py,width,height,
0,0,0,height,BufRevImg,BmInfo, DIB_RGB_COLORS);
delete []BufRevImg;
}

}
//-----------------------------------------------------------------------------------------------------------------------
void CNG::AX_LoadJPG(CString fileName)
{
UINT width=427; UINT height=601;

if (m_ColorGetImg!=NULL) {delete [] m_ColorGetImg;m_ColorGetImg=NULL;}
if (m_ColorImg!=NULL) {delete [] m_ColorImg;m_ColorImg=NULL;}
m_ColorImg = new unsigned char [(width*24)*height*3];

// read to buffer tmp
m_ColorGetImg=JpegFile::JpegFileToRGB(fileName, &width, &height);
//CString csTmp; csTmp.Format("%d, %d",width, height); AfxMessageBox(csTmp);
//-------------------------------------------------------
if(m_ColorGetImg==NULL){return;}
//-------------------------------------------------------
JpegFile::BGRFromRGB(m_ColorGetImg, width, height);
// vertical flip for display
JpegFile::VertFlipBuf(m_ColorGetImg, width * 3, height);
m_width=width; m_height=height;

int y=0;
int x=0;
int ADD1,ADD2,ADD3;
int SUM1,SUM2,SUM3;

#define WIDTHBYTES2(bits) (float((bits) / float(32)) * 4)

float rwsize=WIDTHBYTES2(24*(width));//이미지 Size홀수 문제
int rwsize2=WIDTHBYTES(24*(width));

for(y=0; y<int(height); y++)
{
for(x=0; x<int(width); x++)
{
ADD1=int((y*rwsize)+(3*x)+2);
ADD2=int((y*rwsize)+(3*x)+1);
ADD3=int((y*rwsize)+(3*x)+0);

SUM1=int((y*rwsize2)+(3*x)+2);
SUM2=int((y*rwsize2)+(3*x)+1);
SUM3=int((y*rwsize2)+(3*x)+0);

m_ColorImg[SUM1]=m_ColorGetImg[ADD1];
m_ColorImg[SUM2]=m_ColorGetImg[ADD2];
m_ColorImg[SUM3]=m_ColorGetImg[ADD3];

//pDC.SetPixel(nX,nY,RGB(m_ColorImg[SUM1],m_ColorImg[SUM2],m_ColorImg[SUM3]));
}

}
}
//--------------------------------------------------------------------------------------------

/*--------------------------------------------------------------------------------------*/
//////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////// - POINT - /////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------*/

//======MEMCPY 생성=======================================================================

unsigned char *OutImg = NULL;
// OutImg = new unsigned char [(nWidth*Bit)*nHeight*3];
OutImg = (unsigned char*)calloc(nWidth*Bit*nHeight*3,sizeof(char));

BYTE *outBuf=NULL;

long bufsize = (long)w * 3 * (long)h;
outBuf=(BYTE *) new BYTE [bufsize];

outBuf=NULL;
outBuf = new unsigned char [bufsize]; //dibHi.biSizeImage
// outBuf=(BYTE *) new BYTE [bufsize];

//======MEMCPY============================================================================

int ImgSize=(width*24)*height*3;//24
// int ImgSize=(width*8)*height;//8

memcpy(BufImg,BufImg2,ImgSize);

//======unsigned char,UINT * nWidth=======================================================

UINT * nWidth, UINT * nHeight
BYTE * BufImg;
BufImg=NULL;
BufImg = new unsigned char [ImgSize]; //dibHi.biSizeImage

*nHeight = NULL;
*nWidth = NULL;

*nHeight=height;
*nWidth=width;

CVisionSysView* pView =( CVisionSysView* )((CMainFrame*)AfxGetApp()->m_pMainWnd)->GetActiveView();
CDC *pDC =pView->GetDC();
//----------------------------------
int rwsize = WIDTHBYTES(24*width);
int ADDr,ADDg,ADDb;
//----------------------------------
int x=0; int y=0;
for(y=0; y<height; y++)
{
for(x=0; x<width; x++)
{
ADDr=(y*rwsize)+(3*x)+2;
ADDg=(y*rwsize)+(3*x)+1;
ADDb=(y*rwsize)+(3*x)+0;

*(BufImg+ADDr)=BufImg2[ADDr]; // r
*(BufImg+ADDg)=BufImg2[ADDg]; // g
*(BufImg+ADDb)=BufImg2[ADDb]; // b

pDC->SetPixel(x+400,y,RGB(BufImg[ADDr],BufImg[ADDg],BufImg[ADDb]));
//pDC->SetPixel(col,row,RGB(pixel[2],pixel[1],pixel[0]));
}
}

/*--------------------------------------------------------------------------------------*/
//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////// - 함 수 - /////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------*/

int (*StepFunc_1[])(void) =
{
iCall_ChipTakeOff, iCall_LaserMeasure,
iCall_MarkRecMove, iCall_AllMarkRec,
iCall_AllBadRec, iCall_TargetMarkRec,
iCall_XYMovAbsorb1, iCall_XYMovAbsorb2,
iCall_NzlAbsorbOp1, iCall_NzlAbsorbOp2,
iCall_XYMountMov1, iCall_XYMountMov2,
iCall_NzlMountOp1,    iCall_NzlMountOp2,
iCall_AlignMoveXY1, iCall_AlignMoveXY2,
iCall_InspectMoveXY1, iCall_InspectMoveXY2,
iCall_AlignRecogOP1,    iCall_AlignRecogOP2,
iCall_InspectRecogOP1, iCall_InspectRecogOP2,
iCall_NzlFocusReset1, iCall_NzlFocusReset2
};

if ((*StepFunc_1[index])() == NG) // 실행 error이면
TaskStatus1.iError = TaskStatus1.iNum; // main분기 data
else // 실행성공이면
TaskStatus1.iError = OK;

extern int iCall_LaserMeasure(void);

/*--------------------------------------------------------------------------------------*/
//////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////// - 문 자 - /////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------*/

//8888888888888888888888888888888888888888888888888888888888888
//--------데이타 형 -----------------------------
short int, int -2(15) ~ 2(15)-1 -32768~32767

long int -2(31) ~ 2(31)-1 -2147483648 ~ 2147483647

unsigned short int 0 ~2(15)-1 0 ~ 65535
unsigned int

unsigned long int 0 ~2(32)-1 0 ~ 4294967295

float 10(-79) ~ 10(75)

char -128 ~ 127
unsigned char 0 ~ 255

//------------------------------------------------------
char 8
int 16
short 16
long 32
float 32
double 64
//-----------------------------------------------------
UINT-unsigned int
BYTE -unsigned char
LPSTR -char
(LPSTR) char*
LPTSTR -unsigned short
LPCTSTR -CString
//--------------------------
BOOL A Boolean value.
BSTR A 32-bit character pointer.
BYTE An 8-bit integer that is not signed.
COLORREF A 32-bit value used as a color value.
DWORD A 32-bit unsigned integer or the address of a segment and its associated offset.
LONG A 32-bit signed integer.
LPARAM A 32-bit value passed as a parameter to a window procedure or callback function.
LPCSTR A 32-bit pointer to a constant character string.
LPSTR A 32-bit pointer to a character string.
LPCTSTR A 32-bit pointer to a constant character string that is portable for Unicode and DBCS.
LPTSTR A 32-bit pointer to a character string that is portable for Unicode and DBCS.
LPVOID A 32-bit pointer to an unspecified type.
LRESULT A 32-bit value returned from a window procedure or callback function
UINT A 16-bit unsigned integer on Windows versions 3.0 and 3.1; a 32-bit unsigned integer on Win32.
WNDPROC A 32-bit pointer to a window procedure.
WORD A 16-bit unsigned integer.
WPARAM A value passed as a parameter to a window procedure or callback function: 16 bits on Windows versions 3.0 and 3.1; 32 bits on Win32.
Data types unique to the Microsoft Foundation Class Library include the following:
POSITION A value used to denote the position of an element in a collection; used by MFC collection classes.
LPCRECT A 32-bit pointer to a constant (nonmodifiable) RECT structure.

//888888888888888888888888888888888888888888888888888888888888888888888888888

_CRTIMP int __cdecl abs(int);
_CRTIMP double __cdecl acos(double);
_CRTIMP double __cdecl asin(double);
_CRTIMP double __cdecl atan(double);
_CRTIMP double __cdecl atan2(double, double);
_CRTIMP double __cdecl cos(double);
_CRTIMP double __cdecl cosh(double);
_CRTIMP double __cdecl exp(double);
_CRTIMP double __cdecl fabs(double);
_CRTIMP double __cdecl fmod(double, double);
_CRTIMP long __cdecl labs(long);
_CRTIMP double __cdecl log(double);
_CRTIMP double __cdecl log10(double);
_CRTIMP double __cdecl pow(double, double);
_CRTIMP double __cdecl sin(double);
_CRTIMP double __cdecl sinh(double);
_CRTIMP double __cdecl tan(double);
_CRTIMP double __cdecl tanh(double);
_CRTIMP double __cdecl sqrt(double);

double hypot(double x,double y);직삼각형의 사변 길이
double sqrt(double x);x의 제곱근
double pow(double x,double y);xy. x의 y승
double log(double x);자연 대수
double log10(double x);상용 대수
double exp(double x);자연 대수 exp

//=============================================================
/*---------------------- 형 변형 ----------------------------*/
//=============================================================

//---------------
double "%.1e"
long int "%ld"
//---------------

/*---------------------- Char 문자로 변경----------------------------*/
DWORD dData
char Data[33] = "\0";
ultoa(dData, Data, 10);
CString sRtn = Data;

CString csText;
char buff[40];
csText=((LPCSTR)buff);

//---메모리할당 삭제----------------------------------
CString str;
char *cstr=NULL;str = new char[_MAX_PATH+1];
::GetCurrentDirectory(_MAX_PATH+1,cstr);
str=(LPCTSTR)(char *)cstr;
if(cstr)delete[] cstr;
return str;
//-----------------------------------------------------

char *str;
CString Path_App =(LPCTSTR)(char *)str;
//-----------------------------------------------------------
(char *)(LPCTSTR)mDAT.pid,day.yy%100,day.mo,day.dd);
//-----------------------------------------------------------

//-----------------------------------
(LPCTSTR)(char *)
//-----------------------------------

/*---------------------- lstrcpy----------------------------*/
CString m_strSend;
BYTE temp[2000];
lstrcpy((LPSTR)temp,(LPSTR)m_strSend.operator const char*());

/*---------------------- sprintf----------------------------*/

char buff[100];
int nData=100;
sprintf(buff, "%d", nData);

/*---------------------- int--------------------------------*/
int a=111;
sprintf(temp,"%d",a);

char buff[40];
int nData;
nData=(int)atoi((LPCSTR)buff);

///////////////////////////////
short number;
CString str;
char buffer[20];
if (number > 0) {
_itoa(number,buffer,10);
str += buffer;
}
str += "\r"; //CR

/*-------------------문자-> float 변경------------------------*/

CString csTmp;
float fHum;
fHum = (float)atof((LPCSTR)csTmp);

*-------------------float-> 문자 변경------------------------*/
float fData=(float) 12.345;
CString csText;
csText.Format("%.3f",fData);

/*-------------------문자-> long 변경------------------------------*/
long lngBuf = ::atol(strBuf);

/*------------------- long-> 문자 변경-----------------------------*/
long lData=1123;
CString csTmp; csTmp.Format("%ld",lData);

*-------------------double-> 문자 변경------------------------------*/
   CString csText;
   double dData;
   csText.Format("%-13.2f",dData);

/*--------------------일정문자 삭제--------------------------------*/
CString csRead;
csRead.Delete(5,1);
위치,갯수
/*------------------일정문자 추출-----------------------------------*/
CString InString;
CString csTemp = InString.Mid(index+1,6);
위치 , 크기

/*------------float 반올림------------------------------------------*/
#define Cut(A) (float)((long int) (((A)+.05) * 10))/10;

float Test1=(float)2.374826;
float Test2;
Test2=Cut(Test1);
csTest.Format("%.6f",Test2);
m_nisFM1LCoolRpmDecision.SetOffText(csTest);

/*------HEX and 비교구문-------------------------------------------*/
int test1=0;
test1 |=0x4000;
test1 |=0x02;

if (test1 & 0x4000)
{
if ((test1 & 2)==0)
{
AfxMessageBox("!0x02");
}
else
{
AfxMessageBox("0x02");
}
}
else
{
AfxMessageBox("!0x4000");
}
/*------------상위 4비트만 추출 -----------------------------------*/
BYTE m_nInHorseTmp;
BYTE Intemp;
m_nInHorseTmp=0X7f;
// m_nInHorseTmp |= 0X0f;
m_nInHorseTmp &= 0Xf0;
Intemp=m_nInHorseTmp/16;

m_TEST.Format("%d",Intemp);

UpdateData(FALSE);

/*------------------------핵사값-> 십진수-------------------------*/
int no;
CString n,m_NoData ;
char buf[4]; buf[0]='0';buf[1]='A';buf[2]='2';buf[3]='B';
char data[4];
for(int s=0; s<4; s++)
{
data[s] = buf[i];
}
no=AscHextoAscDec(data);
n.Format("%d",no);
m_NoData = n;
/*-----------------------AscHextoAscDec----------------------------*/
int CFileTestView::AscHextoAscDec(char hexnum[])
{
/* int dec;
dec = (int)hex-48;
if(dec>9)
dec=dec-7;
return dec;
*/
int i=0;
int Num[4],Sum;

for(i=0; i<4; i++)
{
if(hexnum[i]>0x40)
Num[i]=hexnum[i]-'A'+10;
else
Num[i]=hexnum[i]-'0';
}
Sum=Num[0]*16*16*16 + Num[1]*16*16 + Num[2]*16 + Num[3];

return Sum;
}
/*---------------------- 십진수-> 핵사------------------*/
int NUM;
CString m_NoData;
NUM=162; ///핵사값=A2
BYTE temp[3];
temp[0] = HextoAsc(NUM/16);
temp[1] = HextoAsc(NUM%16);
temp[2] = '\0';
m_NoData=temp;
/*-----------------------HextoAsc-----------------------*/
BYTE CFileTestView::HextoAsc(BYTE hexnum)
{
unsigned char hex[] = { "0123456789ABCDEF" };
unsigned char ascnum;
ascnum = hex[hexnum%16];
return ascnum;
}
/*-----------------ASC-> 정수변환-----------------------*/
int NanBangData;
TCHAR NanBang[5];
NanBang[0] = pDoc->m_RsrBuf[9];
NanBang[1] = pDoc->m_RsrBuf[10];
NanBang[2] = pDoc->m_RsrBuf[11];
NanBang[3] = pDoc->m_RsrBuf[12];
NanBang[4] = '\0';
NanBangData = atoi(NanBang);
/*--------------------Format----------------------------*/

int NO[4];
CString n;
NO=0x31;
n.Format("%d%d%d%d",NO[0],NO[0],NO[0],NO[0]);
no=atoi(n);
m_NoData = n;
if(no==2100){m_NoData="aa";}
else{m_NoData ="bb";}
/*--------------------- strcat---------------------------*/
char string[80];
char temp2[20];
strcpy( string, "Hello world from " );
strcat( string, "1 " );
strcat( string, "2 " );
strcat( string, "!" );

sprintf(temp2,"%s\n",string);
AfxMessageBox(temp2);

/*-----------------strok----------------------------------*/

char seps[] = ","; char *token; char string[250];
///*** Establish string and get the first token:
strcpy( string, ReadData); token = strtok(string, seps );

char string[] = " 1 2 \n3,4,,,,,,end";
char s

eps[] = " ,\t\n";
//char seps[] = ",";
char *token;

//----------------------------------------------------
char *data;
char szBuf[1024];

CString InString="OK11,123,250,125";
sprintf(szBuf,InString);

data = strtok(szBuf,",");
AfxMessageBox(data);

data = strtok(NULL,",");
AfxMessageBox(data);

data = strtok(NULL,",");
AfxMessageBox(data);

data = strtok(NULL,",");
AfxMessageBox(data);
//------------------------------------------

char string[] = "IMAGE1,IMAGE2,IMAGE3,IMAGE11,IMAGE4,IMAGE20";
//char seps[] = " ,\t\n";
char seps[] = ",";
char *token;

////////*** Establish string and get the first token:
token = strtok( string, seps );
char temp2[20];
while( token != NULL )
{
   //////*** While there are tokens in "string"
sprintf(temp2,"%s",token);
AfxMessageBox(temp2);
   ///////*** Get next token:
   token = strtok( NULL, seps );
}
/*--------------------strlen--------------------------------*/
char temp2[20];
char buffer[61] = "How";
int len;
len = strlen( buffer );
   // sprintf(temp2,"%d",len);
sprintf(temp2,"%s",buffer);
AfxMessageBox(temp2);
/*---------------------- int--------------------------------*/
int a=111;
sprintf(temp,"%d",a);

/*------------문자 위치(길이) 결과 얻어내기------------------------------------*/

InString="12345678+000 END";
index = InString.Find("END");//END의 위치 값 0 ~ END 정수 값

csText.Format("%d",index);
AfxMessageBox(csText);

index = InString.Find("+");
m_csTmpString=InString.Left(index+2);//index 위치+2 까지 문자 얻음
AfxMessageBox(m_csTmpString);

/*-----------지정 위치 문자 얻어 내기 --String.GetAt(n)--------------------------------------*/

int Length2 = NamBangDataBuf.GetLength();
for(int n = 0; n < Length2; n++)
{
buf2[n] = NamBangDataBuf.GetAt(n);
}
buf2[n] = '\0';

n 위치의 문자를 얻어냄
/*--------------------------------------------------------------
index = InString.Find("+");//15
while(index>=0)
{
m_csTmpString=InString.Left(index+2);//"+"위치 + 2 위치 문자얻음 "," 까지
InString =InString.Right(InString.GetLength()-index-2); //전체에서 LEFT뺀 나머지 문자
OneChar = m_csTmpString.GetAt(0); //0
index = m_csTmpString.Find("N"); //4

WAV[0] = m_csTmpString.GetAt(index-4); //V
WAV[1]=NULL;
// csText.Format("%d",nI);
// AfxMessageBox(csText);
OneChar = m_csTmpString.GetAt(index-1); //3번 위치의 "1" 얻음
tmp[0]=OneChar;
tmp[1]=NULL; //temp= "1";
nI=atoi(tmp);

/*--------------------------대문자로 바꿈--------------------------------*/
CString Buf1;
Buf1="abcdef";
Buf1.MakeUpper();

AfxMessageBox(Buf1);
/*-------------------------일부 문자 뽑아 내기--------------------------*/
CString csTmp,InString;

InString="#SNDATAok-aa#END";

csTmp=FindData(InString, "#SN",'#');

AfxMessageBox(csTmp);

결과=DATAok-aa

CString CSECSystemView::FindData(CString csData, CString csFind, TCHAR OneChar)
{
int length,index,index2;
CString csTmp,csTmpData;

index = csData.Find(csFind);//MODEL_INFO
length = csFind.GetLength();

csTmpData=csData.Right(csData.GetLength() - index - 1);
index2 = csTmpData.Find(OneChar);//MODEL_INFO
csTmp = csData.Mid(length+index,index2+1-length);
// csData.Format("index=%d",index2);
if((index < 0)||(index2 < 0)) return _T("");
else return csTmp;
}
/*------------------------핵사값-> 십진수-------------------------*/
int no;
CString n,m_NoData ;
char buf[4]; buf[0]='0';buf[1]='A';buf[2]='2';buf[3]='B';
char data[4];
for(int s=0; s<4; s++)
{
data[s] = buf[i];
}
no=AscHextoAscDec(data);
n.Format("%d",no);
m_NoData = n;

//-------------------------------------------------------------------//
BYTE CHexAscChangeView::AsctoHex(BYTE ascnum)
{
unsigned char hex[] = { "0123456789ABCDEF" };
unsigned char i=0;

do
{
if(hex[i] == ascnum)
{
return i;
}
i++;
}while(i<16);
return 0;
}

/*-----------------------AscHextoAscDec----------------------------*/
int CFileTestView::AscHextoAscDec(char hexnum[])
{
/* int dec;
dec = (int)hex-48;
if(dec>9)
dec=dec-7;
return dec;
*/
int i=0;
int Num[4],Sum;

for(i=0; i<4; i++)
{
if(hexnum[i]>0x40)
Num[i]=hexnum[i]-'A'+10;
else
Num[i]=hexnum[i]-'0';
}
Sum=Num[0]*16*16*16 + Num[1]*16*16 + Num[2]*16 + Num[3];

return Sum;
}
/*---------------------- 십진수-> 핵사-------------------*/
int NUM;
CString m_NoData;
NUM=162; ///핵사값=A2
BYTE temp[3];
temp[0] = HextoAsc(NUM/16);
temp[1] = HextoAsc(NUM%16);
temp[2] = '\0';
m_NoData=temp;
/*-----------------------HextoAsc-----------------------*/
BYTE CFileTestView::HextoAsc(BYTE hexnum)
{
unsigned char hex[] = { "0123456789ABCDEF" };
unsigned char ascnum;
ascnum = hex[hexnum%16];
return ascnum;
}
/*-----------------ASC-> 정수변환-----------------------*/
int NanBangData;
TCHAR NanBang[5];
NanBang[0] = pDoc->m_RsrBuf[9];
NanBang[1] = pDoc->m_RsrBuf[10];
NanBang[2] = pDoc->m_RsrBuf[11];
NanBang[3] = pDoc->m_RsrBuf[12];
NanBang[4] = '\0';
NanBangData = atoi(NanBang);
/*--------------------Format----------------------------*/

sprintf(temp2,"%s\n",string);
AfxMessageBox(temp2);

/*-----------------strok----------------------------------*/
char string[] = " 1 2 \n3,4,,,,,,end";
char seps[] = " ,\t\n";
//char seps[] = ",";
char *token;

   ////////*** Establish string and get the first token:
   token = strtok( string, seps );
   char temp2[20];
   while( token != NULL )
   {
//////*** While there are tokens in "string"
sprintf(temp2,"%s",token);
AfxMessageBox(temp2);
///////*** Get next token:
token = strtok( NULL, seps );
   }
/*--------------------strlen--------------------------------*/
   char temp2[20];
   char buffer[61] = "How";
   int len;
   len = strlen( buffer );
// sprintf(temp2,"%d",len);
   sprintf(temp2,"%s",buffer);
   AfxMessageBox(temp2);

Measure_r= hypot(fPoint_x,fPoint_y);
Measure_r=sqrt(fPoint_x*fPoint_x+fPoint_y*fPoint_y);

//---CString To Byte (unsigned char)------------------------------------------
BYTE c_str(CString str, int n)
{
BYTE cDt;
int nSize=0;
nSize=str.GetLength();
if(nSize>=n)
{
cDt= str.GetAt(n);
}
return cDt;
}

//------------------------------------------------------------------------------
CString str;
BYTE temp;
for(int i=0; i<6; i++)
{
str.Format("%d : ",i);
if(c_str(name,i)=='3')
AfxMessageBox(str+"ok");
else
AfxMessageBox(str);
}
//------------------------------------------------------------------------------
//char 문자변형 !!!!!!!!!!!!!!!!!!!!
BYTE temp[2];

temp[0]=(c_str(name,i);
temp[1]='\0';

str=(LPSTR)temp;
AfxMessageBox(str);

/*---------------------------------------------------------*/
/*----------------------HEX 8BIT 문자표현----------------------------------------*/

CString CSECKLineDVM2View::Hext8BitAsctoChange(int CheckSum)
{
CString csHiBit,csLowBit,csResult;
char HiBit;
char LowBit;

HiBit=(CheckSum & 0xf0)/16;
LowBit=CheckSum & 0x0f;

csHiBit=HextoAsc(HiBit);
csLowBit=HextoAsc(LowBit);

csResult=csHiBit+csLowBit;
return csResult;
}

BYTE CModuleAgingView::HextoAsc(BYTE hexnum)
{
unsigned char hex[] = { "0123456789ABCDEF" };
unsigned char ascnum;

int nBuf=0;

nBuf=hexnum%16;
if((nBuf>=0)&&(nBuf<=15))
{
ascnum = hex[hexnum%16];
}
else
{
ascnum =0;
}
return ascnum;
}
/*----------------------HEX 분할 표현----------------------------------------*/

long dAddress=4294967295; //FF FF FF FF

NAddress[3]=long((lAddress&0xff000000)>>24);
NAddress[2]=long((lAddress&0x00ff0000)>>16);
NAddress[1]=long((lAddress&0x0000ff00)>>8);
NAddress[0]=long(lAddress&0x000000ff);

unsigned char Command[]={NAddress[3],NAddress[2],NAddress[1],NAddress[0]}; //81-Command, 00 08- Data Size 8Byte
pFrame->m_serial[PORT_MODULE_A-1].Write(Command,4);
/*----------------------HEX 232전송----------------------------------------*/

unsigned char *BinOutImg;
BinOutImg = NULL; //변경전 Image file size
BinOutImg = new unsigned char [3*WidthLineSize*(PaletteSize_y*ImageMaxNo)];

Data[0]=int(BinOutImg[index+0]);
unsigned char Buf1[]={Data[0]};
pFrame->m_serial[port-1].Write(Buf1,1);

Data[1]=int(BinOutImg[index+1]);
unsigned char Buf2[]={Data[1]};
pFrame->m_serial[port-1].Write(Buf2,1);

/*----------------------String Table 얻기----------------------------------------*/
CString strTemp;
if (strTemp.LoadString(IDS_SERVERRESET))

/*----------------------한글 폰트 얻기 / 출력------------------------------------*/

const char KoreanFont_MOUM_A1[14][3] = {
"각","간","갇","갈","감","갑","갓","강","갖","갗",
"갘","같","갚","갛",
};
CString csData;

BYTE temp[3];
temp[0] = KoreanFont_MOUM_A1[1][0];
temp[1] = KoreanFont_MOUM_A1[1][1];
temp[2] = '\0';

csData=temp;
AfxMessageBox(csData);

/*----------------------사이즈가 수시변동 끝 네자리 얻기------------------------*/

CString strTmp=_T("");
CString strTmp2=_T("");
CString csData="EX-4A21";
int nLotSize=0;

strTmp=csData;

if(strTmp.GetLength()>0)
{
nLotSize=strTmp.GetLength();

if(nLotSize>=4)
{
for(int i=nLotSize-4; i<nLotSize; i++)
{
strTmp2+=strTmp.Mid(i,1);
}
}
}

if(strTmp2.GetLength()==4)
{
AfxMessageBox(strTmp2);
}
/*---------------------- Delete------------------------*/
CString csRead;
int nNo;
csRead.Delete(nNo,1);
//=============================================================
//=============================================================

//====입력 문자중 숫자만 체크=================================
bool AsctoHexChk(CString csNo)
{
if(csNo=="")return false;
int Length = csNo.GetLength();
if(Length<=0)return false;
BYTE No;
bool chk=true;

for(int i=0; i<Length; i++)
{
No=csNo.GetAt(i);
if(!AsctoHex(No))chk=false;
}
return chk;
}

bool AsctoHex(BYTE ascnum)
{
unsigned char hex[] = { "0123456789." };
unsigned char i=0;
bool Chk=false;
do
{
if(hex[i] == ascnum)
{
Chk=true; break;
}
i++;
}while(i<11);
return Chk;
}

//====한정 문자 메세지 ==========================================
const char BOARD1[MAX_BD][10]= {
"DZ1","DX1","DY1","DZ2","DX2","DY2","FX1","FY1",};
CLabelControl *pLabel;
for(int i=0; i<MAX_BD; i++)
{
pLabel = (CLabelControl *)GetDlgItem(IDC_LBL_AXIS_X+i);
pLabel->SetWindowText(LPTSTR(BOARD1[i]));
}

//====리스트 사용하기============================================
typedef struct {
CString MarkID;
int MarkNo;
int Registered;
int iLight[3];
} MARKDATA_RECORD;

CList<MARKDATA_RECORD, MARKDATA_RECORD&> m_list;
void CMarkData::Load()
{
Clear();

MARKDATA_RECORD rec;
CString strSection;
CIniFile iniFile("C:\\MountData\\MarkData\\Mark.lib");
int count = iniFile.ReadInt("Mark Library", "Count");
for (int i=1; i<=count; i++) {
strSection.Format("Mark #%02d", i);
rec.MarkID = iniFile.ReadString(strSection, "Mark ID");

m_list.AddTail(rec);
}
}
void CMarkData::Save()
{
MARKDATA_RECORD rec;
POSITION pos;
CString strSection;
int count = GetCount();
CIniFile iniFile("C:\\MountData\\MarkData\\Mark.lib");
iniFile.WriteInt("Mark Library", "Count", count);
for (int i=0; i<count; i++) {
pos = m_list.FindIndex(i);
rec = m_list.GetAt(pos);
iniFile.WriteDouble(strSection, "OuterDiameter", rec.OuterDiameter);
}
}
void CMarkData::Clear()
{
m_list.RemoveAll();
}
MARKDATA_RECORD CMarkData::GetData(int index)
{
ASSERT(index > 0 && index <= m_list.GetCount());
POSITION pos = m_list.FindIndex(index-1);
MARKDATA_RECORD rec = m_list.GetAt(pos);
return rec;
}
bool CMarkData::InsertBlankData(int index)
{
ASSERT(index > 0 && index <= m_list.GetCount()+1);
MARKDATA_RECORD rec;
rec.MarkID.Empty();
rec.MarkNo = 0;
rec.Registered = 0;
rec.iLight[0] = 1;
rec.iLight[1] = 1;
rec.iLight[2] = 1;
if (index > m_list.GetCount()) {
m_list.AddTail(rec);
}
else {
POSITION pos = m_list.FindIndex(index-1);
m_list.InsertBefore(pos, rec);
}
return true;
}

//___________________________________________________________________________

void CMarkData::DeleteData(int index)
{
if (index < 0 || index > m_list.GetCount()) return;
POSITION pos = m_list.FindIndex(index-1);
m_list.RemoveAt(pos);
}
//===========================================================================
//===========================================================================

void CMarkData::SetData(int index, MARKDATA_RECORD rec)
{
ASSERT(index > 0 && index <= m_list.GetCount());
POSITION pos = m_list.FindIndex(index-1);
m_list.SetAt(pos, rec);
}

//====struct=================================================================

//typedef struct tagBLOBDATA { short ltx, lty, rbx, rby; int n, pc; float cx, cy, r, g, b, u02, u20, u11, m, v; } BLOBDATA;

//---------------------------------------------------------------------------
//====Point Reutn============================================================
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

BYTE * BMPFile::LoadBMP(CString fileName,UINT *width, UINT *height)
{
BYTE *outBuf=NULL;
long bufsize = (long)w * 3 * (long)h;
outBuf=(BYTE *) new BYTE [bufsize];

for (int col=0;col<w;col++)
{
long offset = col * 3;
char pixel[3];
if (fread((void *)(pixel),1,3,fp)==3)
{
// we swap red and blue here
*(outBuf + rowOffset + offset + 0)=pixel[2]; // r
*(outBuf + rowOffset + offset + 1)=pixel[1]; // g
*(outBuf + rowOffset + offset + 2)=pixel[0]; // b
}
}

int w;
int h;
*width=w;
*height=h;
return outBuf;
}

//===========================================================================
BYTE * BMPFile::LoadBMP(CString fileName,
UINT *width,
UINT *height)
{
BITMAP inBM;

BYTE m1,m2;
long filesize;
short res1,res2;
long pixoff;
long bmisize;
long compression;
unsigned long sizeimage;
long xscale, yscale;
long colors;
long impcol;

BYTE *outBuf=NULL;

// for safety
*width=0; *height=0;

// init
m_errorText="OK";
m_bytesRead=0;

FILE *fp;

fp=fopen(fileName,"rb");
if (fp==NULL) {
CString msg;
msg="Can't open file for reading :\n"+fileName;
m_errorText=msg;
return NULL;
} else {
long rc;
rc=fread((BYTE *)&(m1),1,1,fp); m_bytesRead+=1;
if (rc==-1) {m_errorText="Read Error!"; fclose(fp); return NULL;}

rc=fread((BYTE *)&(m2),1,1,fp); m_bytesRead+=1;
if (rc==-1) m_errorText="Read Error!";
if ((m1!='B') || (m2!='M')) {
m_errorText="Not a valid BMP File";
fclose(fp);
return NULL;
}

////////////////////////////////////////////////////////////////////////////
//
// read a ton of header stuff

rc=fread((long *)&(filesize),4,1,fp); m_bytesRead+=4;
if (rc!=1) {m_errorText="Read Error!"; fclose(fp); return NULL;}

rc=fread((int *)&(res1),2,1,fp); m_bytesRead+=2;
if (rc!=1) {m_errorText="Read Error!"; fclose(fp); return NULL;}

rc=fread((int *)&(res2),2,1,fp); m_bytesRead+=2;
if (rc!=1) {m_errorText="Read Error!"; fclose(fp); return NULL;}

rc=fread((long *)&(pixoff),4,1,fp); m_bytesRead+=4;
if (rc!=1) {m_errorText="Read Error!"; fclose(fp); return NULL;}

rc=fread((long *)&(bmisize),4,1,fp); m_bytesRead+=4;
if (rc!=1) {m_errorText="Read Error!"; fclose(fp); return NULL;}

rc=fread((long *)&(inBM.bmWidth),4,1,fp); m_bytesRead+=4;
if (rc!=1) {m_errorText="Read Error!"; fclose(fp); return NULL;}

rc=fread((long *)&(inBM.bmHeight),4,1,fp); m_bytesRead+=4;
if (rc!=1) {m_errorText="Read Error!"; fclose(fp); return NULL;}

rc=fread((int *)&(inBM.bmPlanes),2,1,fp); m_bytesRead+=2;
if (rc!=1) {m_errorText="Read Error!"; fclose(fp); return NULL;}

rc=fread((int *)&(inBM.bmBitsPixel),2,1,fp); m_bytesRead+=2;
if (rc!=1) {m_errorText="Read Error!"; fclose(fp); return NULL;}

rc=fread((long *)&(compression),4,1,fp); m_bytesRead+=4;
if (rc!=1) {m_errorText="Read Error!"; fclose(fp); return NULL;}

rc=fread((long *)&(sizeimage),4,1,fp); m_bytesRead+=4;
if (rc!=1) {m_errorText="Read Error!"; fclose(fp); return NULL;}

rc=fread((long *)&(xscale),4,1,fp); m_bytesRead+=4;
if (rc!=1) {m_errorText="Read Error!"; fclose(fp); return NULL;}

rc=fread((long *)&(yscale),4,1,fp); m_bytesRead+=4;
if (rc!=1) {m_errorText="Read Error!"; fclose(fp); return NULL;}

rc=fread((long *)&(colors),4,1,fp); m_bytesRead+=4;
if (rc!=1) {m_errorText="Read Error!"; fclose(fp); return NULL;}

rc=fread((long *)&(impcol),4,1,fp); m_bytesRead+=4;
if (rc!=1) {m_errorText="Read Error!"; fclose(fp); return NULL;}

////////////////////////////////////////////////////////////////////////////
// i don't do RLE files

if (compression!=BI_RGB) {
   m_errorText="This is a compressed file.";
   fclose(fp);
   return NULL;
   }

if (colors == 0) {
colors = 1 << inBM.bmBitsPixel;
}

////////////////////////////////////////////////////////////////////////////
// read colormap

RGBQUAD *colormap = NULL;

switch (inBM.bmBitsPixel) {
case 24:
break;
// read pallete
case 1:
case 4:
case 8:
colormap = new RGBQUAD[colors];
if (colormap==NULL) {
fclose(fp);
m_errorText="Out of memory";
return NULL;
}

int i;
for (i=0;i<colors;i++) {
BYTE r,g,b, dummy;

rc=fread((BYTE *)&(b),1,1,fp);
m_bytesRead++;
if (rc!=1) {
m_errorText="Read Error!";
delete [] colormap;
fclose(fp);
return NULL;
}

rc=fread((BYTE *)&(g),1,1,fp);
m_bytesRead++;
if (rc!=1) {
m_errorText="Read Error!";
delete [] colormap;
fclose(fp);
return NULL;
}

rc=fread((BYTE *)&(r),1,1,fp);
m_bytesRead++;
if (rc!=1) {
m_errorText="Read Error!";
delete [] colormap;
fclose(fp);
return NULL;
}

rc=fread((BYTE *)&(dummy),1,1,fp);
m_bytesRead++;
if (rc!=1) {
m_errorText="Read Error!";
delete [] colormap;
fclose(fp);
return NULL;
}

colormap[i].rgbRed=r;
colormap[i].rgbGreen=g;
colormap[i].rgbBlue=b;
}
break;
}

if ((long)m_bytesRead>pixoff) {
fclose(fp);
m_errorText="Corrupt palette";
delete [] colormap;
fclose(fp);
return NULL;
}

while ((long)m_bytesRead<pixoff) {
char dummy;
fread(&dummy,1,1,fp);
m_bytesRead++;
}

int w=inBM.bmWidth;
int h=inBM.bmHeight;

// set the output params
*width=w;
*height=h;

long row_size = w * 3;

long bufsize = (long)w * 3 * (long)h;

////////////////////////////////////////////////////////////////////////////
// alloc our buffer

outBuf=(BYTE *) new BYTE [bufsize];
if (outBuf==NULL) {
m_errorText="Memory alloc Failed";
} else {

////////////////////////////////////////////////////////////////////////////
// read it

long row=0;
long rowOffset=0;

// read rows in reverse order
for (row=inBM.bmHeight-1;row>=0;row--) {

// which row are we working on?
rowOffset=(long unsigned)row*row_size;

if (inBM.bmBitsPixel==24) {

for (int col=0;col<w;col++) {
long offset = col * 3;
char pixel[3];

if (fread((void *)(pixel),1,3,fp)==3) {
// we swap red and blue here
*(outBuf + rowOffset + offset + 0)=pixel[2]; // r
*(outBuf + rowOffset + offset + 1)=pixel[1]; // g
*(outBuf + rowOffset + offset + 2)=pixel[0]; // b
}

}

m_bytesRead+=row_size;

// read DWORD padding
while ((m_bytesRead-pixoff)&3) {
char dummy;
if (fread(&dummy,1,1,fp)!=1) {
m_errorText="Read Error";
delete [] outBuf;
fclose(fp);
return NULL;
}

m_bytesRead++;
}

} else { // 1, 4, or 8 bit image

////////////////////////////////////////////////////////////////
// pixels are packed as 1 , 4 or 8 bit vals. need to unpack them

int bit_count = 0;
UINT mask = (1 << inBM.bmBitsPixel) - 1;

BYTE inbyte=0;

for (int col=0;col<w;col++) {

int pix=0;

// if we need another byte
if (bit_count <= 0) {
bit_count = 8;
if (fread(&inbyte,1,1,fp)!=1) {
m_errorText="Read Error";
delete [] outBuf;
delete [] colormap;
fclose(fp);
return NULL;
}
m_bytesRead++;
}

// keep track of where we are in the bytes
bit_count -= inBM.bmBitsPixel;
pix = ( inbyte >> bit_count) & mask;

// lookup the color from the colormap - stuff it in our buffer
// swap red and blue
*(outBuf + rowOffset + col * 3 + 2) = colormap[pix].rgbBlue;
*(outBuf + rowOffset + col * 3 + 1) = colormap[pix].rgbGreen;
*(outBuf + rowOffset + col * 3 + 0) = colormap[pix].rgbRed;
}

// read DWORD padding
while ((m_bytesRead-pixoff)&3) {
char dummy;
if (fread(&dummy,1,1,fp)!=1) {
m_errorText="Read Error";
delete [] outBuf;
if (colormap)
delete [] colormap;
fclose(fp);
return NULL;
}
m_bytesRead++;
}
}
}

}

if (colormap) {
delete [] colormap;
}

fclose(fp);

}

return outBuf;
}
//=================================================================================================================

BYTE* CMemFile::Alloc(DWORD nBytes)
{
return (BYTE*)malloc((UINT)nBytes);
}

BYTE *buf = JpegFile::JpegFileToRGB(....);
delete [] buf;

BYTE * JpegFile::JpegFileToRGB(CString fileName, UINT *width, UINT *height)
{
*width=0;
*height=0;

BYTE *dataBuf;
dataBuf=(BYTE *)new BYTE[width * 3 * height];
if (dataBuf==NULL) {
return NULL;
}

return dataBuf;

}

BYTE * JpegFile::MakeDwordAlignedBuf(BYTE *dataBuf,UINT widthPix,UINT height, UINT *uiOutWidthBytes)
{
////////////////////////////////////////////////////////////
// what's going on here? this certainly means trouble
if (dataBuf==NULL)return NULL;

////////////////////////////////////////////////////////////
// how big is the smallest DWORD-aligned buffer that we can use?
UINT uiWidthBytes;
uiWidthBytes = WIDTHBYTES(widthPix * 24);

DWORD dwNewsize=(DWORD)((DWORD)uiWidthBytes * (DWORD)height);
BYTE *pNew;

////////////////////////////////////////////////////////////
// alloc and open our new buffer
pNew=(BYTE *)new BYTE[dwNewsize];
if (pNew==NULL) {
return NULL;
}

////////////////////////////////////////////////////////////
// copy row-by-row
UINT uiInWidthBytes = widthPix * 3;
UINT uiCount;
for (uiCount=0;uiCount < height;uiCount++) {
BYTE * bpInAdd;
BYTE * bpOutAdd;
ULONG lInOff;
ULONG lOutOff;

lInOff=uiInWidthBytes * uiCount;
lOutOff=uiWidthBytes * uiCount;

bpInAdd= dataBuf + lInOff;
bpOutAdd= pNew + lOutOff;

memcpy(bpOutAdd,bpInAdd,uiInWidthBytes);
}

*uiOutWidthBytes=uiWidthBytes;
return pNew;
}

BOOL JpegFile::VertFlipBuf(BYTE * inbuf,
UINT widthBytes,
UINT height)
{
BYTE *tb1;
BYTE *tb2;

if (inbuf==NULL)
return FALSE;

UINT bufsize;

bufsize=widthBytes;

tb1= (BYTE *)new BYTE[bufsize];
if (tb1==NULL) {
return FALSE;
}

tb2= (BYTE *)new BYTE [bufsize];
if (tb2==NULL) {
delete [] tb1;
return FALSE;
}

UINT row_cnt;
ULONG off1=0;
ULONG off2=0;

for (row_cnt=0;row_cnt<(height+1)/2;row_cnt++) {
off1=row_cnt*bufsize;
off2=((height-1)-row_cnt)*bufsize;

memcpy(tb1,inbuf+off1,bufsize);
memcpy(tb2,inbuf+off2,bufsize);
memcpy(inbuf+off1,tb2,bufsize);
memcpy(inbuf+off2,tb1,bufsize);
}

delete [] tb1;
delete [] tb2;

return TRUE;
}

BOOL JpegFile::MakeGrayScale(BYTE *buf, UINT widthPix, UINT height)
{
if (buf==NULL)
return FALSE;

UINT row,col;
for (row=0;row<height;row++) {
for (col=0;col<widthPix;col++) {
LPBYTE pRed, pGrn, pBlu;
pRed = buf + row * widthPix * 3 + col * 3;
pGrn = buf + row * widthPix * 3 + col * 3 + 1;
pBlu = buf + row * widthPix * 3 + col * 3 + 2;

// luminance
int lum = (int)(.299 * (double)(*pRed) + .587 * (double)(*pGrn) + .114 * (double)(*pBlu));

*pRed = (BYTE)lum;
*pGrn = (BYTE)lum;
*pBlu = (BYTE)lum;
}
}
return TRUE;
}

//============================================================================

//--------Bit 구하기- -----------------------------

typedef struct {
unsigned b0 : 1, b1 : 1, b2 : 1, b3 : 1, b4 : 1, b5 : 1, b6 : 1, b7 : 1;
} byte_bits;

typedef union {
BYTE bByte;
byte_bits bit;
} lsByte;

lsByte bUnivIO;

bUnivIO=(UINT8)250;

#include "Led.h"
CLed m_LedOut0;
DDX_Control(pDX, IDC_LED_OUT0, m_LedOut0);

m_LedOut0.SetStatus( bUnivIO.bit.b0 );
m_LedOut1.SetStatus( bUnivIO.bit.b1 );
m_LedOut2.SetStatus( bUnivIO.bit.b2 );
m_LedOut3.SetStatus( bUnivIO.bit.b3 );
m_LedIn0.SetStatus( bUnivIO.bit.b4 );
m_LedIn1.SetStatus( bUnivIO.bit.b5 );
m_LedIn2.SetStatus( bUnivIO.bit.b6 );
m_LedIn3.SetStatus( bUnivIO.bit.b7 );

int CUDPSock::SendTo(const void* lpBuf, int nBufLen, LPCTSTR lpszHostAddress, int nFlags)
{
sockaddr_in Addr;
memset((char *)&Addr, 0x00, sizeof(Addr));
Addr.sin_family = AF_INET;
Addr.sin_addr.s_addr = inet_addr(lpszHostAddress);
Addr.sin_port = htons(m_iPort);//서버,클라이언트중 port지정한 UDP port로 송수신(내부서버에지정)

char *buf = NULL;
int iSize = lstrlen((char*)lpBuf);

buf = (char*)malloc(iSize);

memcpy(buf,lpBuf,iSize);

//CUDPSock::DATAPACKET DataPacket;
//memcpy(DataPacket.szData, (char*)lpBuf, nBufLen);
//DataPacket.SetCheck();
//int iResult = sendto(m_Sock, (char*)&DataPacket, sizeof(CUDPSock::DATAPACKET), nFlags, (const struct sockaddr *)&Addr, sizeof(Addr));
int iResult = sendto(m_Sock, buf, iSize, nFlags, (const struct sockaddr *)&Addr, sizeof(Addr));
return 0;
}
//---------------------------------------------------------------------------
//-----특정 문자 바꾸기 -----------------------------------
CString PathName.Replace( "\\", "/" );

//-----확장자 바꾸기---------------------------------------
CString ChangeFileExt(CString csFile, CString csExe)
{
CString str;
int Index=0;
char *token;
char szBuf[1024];
char temp2[100];
char seps[] = "\\";
////////*** Establish string and get the first token:

if(csFile.GetLength()>3)printf(szBuf,csFile); else return "";
CString csGetData="";
sprintf(szBuf,csFile);
token = strtok(szBuf,seps);

while( token != NULL )
{
//////*** While there are tokens in "string"
sprintf(temp2,"%s",token);
csGetData=temp2;
///////*** Get next token:
token = strtok( NULL, seps );
}

int index=0;
if(csGetData.GetLength()>1)index = csGetData.Find("."); else return "";
CString csData="";
csData=csGetData.Mid(0,index);// AfxMessageBox(csData);

str=csData+csExe;
return str;
}

//----------------------------------------------------------
CString NewFileName;
char sSource[256]
//찾고자 하는것, 바꾸고자 하는것을 받는다.
strcpy( sSource, m_FileNameBefore.operator LPCTSTR() );
//----------------------------------------------------------

unsigned char *temp = NULL;
temp = new unsigned char [Length];

CString Filename=="C:\\Polaronix\\Back\\Ch01\\*.*";
//-------------------
LPSTR temp = Filename.GetBuffer(Filename.GetLength()*2); //*char

//-------------------
char temp[50];
for(i=0; i<50; i++) temp[i]='\0';
lstrcpy((LPSTR)temp,(LPSTR)Filename.operator const char*());

//--------------------

char temp[50];
int Length = Filename.GetLength();
//for(i=0; i<50; i++) temp[i]='\0';
for(i = 0; i < Length; i++)
{
temp[i] = Filename.GetAt(i);
}
temp[i]= '\0';

AfxMessageBox(temp);

unsigned char Buf1[]={Data[0]};
pFrame->m_serial[port-1].Write(Buf1,1);

//-----------------------------------------------------------------------------------
//------숫자 감소--------------------------------------------------------------------
for (i = 255; i > 0; i--)
//-----------------------------------------------------------------------------------
//--unsigned char-> CString , unsigned char-> char----------------------------------
//-----------------------------------------------------------------------------------

int Length=255;
unsigned char *temp = NULL;
temp = new unsigned char [Length];

char temp2[2]; CString csText;
// m_ccEdit1.GetWindowText((LPSTR)temp,255);

for(int i=0; i<Length; i++)
{
temp2[0]=temp[i]; temp2[1]='\0';
csText+=(LPSTR)temp2;
}

AfxMessageBox(csText);

//-----------------------------------------------------------------------------------
//------숫자 추출--------------------------------------------------------------------

100자리
hundred= (int)(Sum/ 100);
ten= (Sum-(hundred*100))/10;
one=Sum-((hundred*100)+(ten*10));

1000자리
thousand= =(int)(Sum/ 1000);
hundred= (int)(Sum-(thousand*1000))/100;
ten= (Sum-((thousand*1000)+(hundred*100)))/10;
one=Sum-(int)((thousand*1000)+(hundred*100)+(ten*10));

10000자리
tenthousand =(int)(Sum/ 10000);
thousand= (int)(Sum-(tenthousand*10000))/1000;
hundred= (int)(Sum-((tenthousand*10000)+(thousand*1000)+(hundred*100)))/100;
ten= (Sum-((tenthousand*10000)+(thousand*1000)+(hundred*100)))/10;
one=Sum-(int)((tenthousand*10000)+(thousand*1000)+(hundred*100)+(ten*10));

//---char-> CString------------------------------------
char temp[255];
for(int i=0; i<255; i++) temp[i]='\0';

CString csText=(LPSTR)temp;
AfxMessageBox(csText);

//---------------*.* 삭제 처리-------------------------------------------------*/

CString Filename="C:\\Polaronix\\Back\\Ch01\\*.*";
int Length = Filename.GetLength();
char temp[50];

for(i=0; i<50; i++) temp[i]='\0';
lstrcpy((LPSTR)temp,(LPSTR)Filename.operator const char*());

SHFILEOPSTRUCT sfo;
memset(&sfo,0,sizeof(sfo));
sfo.wFunc = FO_DELETE;
sfo.fFlags =OFN_SHOWHELP; //메시지 창 뛰우지 않음

sfo.pFrom=(LPSTR)temp;
SHFileOperation(&sfo);

/* for(i = 0; i < 20; i++)
{
csTmp.Format("%d",temp[i]); AfxMessageBox(csTmp);
}
*/

/*------% 계산------------------------------------------------------------*/
//-------------------------------------------
//-------------------------------------------

0-255 에 대한 100%

// 수량에 대한 % 계산 x(%)
// 255 : 100(%) = 25 : x(%) (25의 %)
// x(%) = (value/255)*100
int value=25;
float fData=float(value)/255;fData=float(fData*100);if(fData<0)fData=0;

// %에 대한 수량 구하기 x(no)
// 255 : 100(%) = x :10(%) (10%에 대한 값)
// x=(10/100)*255

//int value=10;
//float fData=float(value/100);fData=float(fData*255);if(fData<0)fData=0;

fData=float(fData)/100;fData=float(fData*255); //Limit값
fData=Cut(fData); m_threshMin=int(fData);
//-------------------------------------------
//-------------------------------------------

float nData1=0;int nData2=0;

// nData1=nImageTotalSize-(nAddressCount*256);
nData1=nImageTotalSize-nAddressCount;

nData2=int((nData1/nImageTotalSize)*100);
nPercent=int(100-nData2);

strText.Format("Image Download: %d/100",nPercent);//Pallete X Size
SetDlgItemText(IDC_IMAGEDOWNLOADSTATIC_A, strText);

if((nPercent>=0)&&(nPercent<=100))
m_ccModuleAdownloadProgress.SetPos(nPercent);
/*-----------------------------------------------------------------------*/

BOOL AFXAPI AfxVerifyLicFile(HINSTANCE hInstance, LPCTSTR pszLicFileName,
LPCOLESTR pszLicFileContents, UINT cch)
{
// Assume the worst...
BOOL bVerified = FALSE;

// Look for license file in same directory as this DLL.
TCHAR szPathName[_MAX_PATH];
::GetModuleFileName(hInstance, szPathName, _MAX_PATH);
LPTSTR pszFileName = _tcsrchr(szPathName, '\\') + 1;
lstrcpy(pszFileName, pszLicFileName);

#ifndef OLE2ANSI
LPSTR pszKey = NULL;
#endif
LPBYTE pbContent = NULL;

TRY
{
// Open file, read content and compare.

CFile file(szPathName, CFile::modeRead);

if (cch == -1)
#ifdef OLE2ANSI
cch = lstrlen(pszLicFileContents);
#else
cch = wcslen(pszLicFileContents);

pszKey = (char*)_alloca(cch*2 + 1);
cch = _wcstombsz(pszKey, pszLicFileContents, cch*2 + 1);
#endif

if (cch != 0)
{
--cch; // license file won't contain the terminating null char
pbContent = (BYTE*)_alloca(cch);
file.Read(pbContent, cch);

#ifndef OLE2ANSI
if (memcmp(pszKey, pbContent, (size_t)cch) == 0)
#else
if (memcmp(pszLicFileContents, pbContent, (size_t)cch) == 0)
#endif
bVerified = TRUE;
}
}
END_TRY

return bVerified;
}

/*---------------------Hex -> CString------------------------------------------------------*/
void CTestView::OnButton1()
{
// TODO: Add your control notification handler code here
CString csTmp="";
char hexnum=0x7f; //BYTE hexnum=0x01;

csTmp=HextoAsctoString(hexnum);
AfxMessageBox(csTmp);
}

CString CTestView::HextoAsctoString(BYTE hexnum)
{
CString csTmp="0";
unsigned char hex[] = { "0123456789ABCDEF" };

BYTE num;
BYTE temp[3];

num=hexnum/16;
temp[0] = hex[num%16];

num=hexnum%16;
temp[1] =hex[num%16];

temp[2] = '\0';
csTmp=temp;

return csTmp;
}

/*---------------------CString 한줄씩 얻기 ----------------------------------*/
//-----------------------------------------------------------------------------------

//----한줄 얻기--------------------------------
CString csData="1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20";

int MaxRow = MAXROW_TIME+1;
int MaxCol = MAXCOL_TIME;
CString csTmp="";

int nGetCol=1;
if(nMode==MODE_ONTIME)nGetCol=1;if(nMode==MODE_OFFTIME)nGetCol=2;

int nListMaxCount=0;CString csGetData[MAXROW_TIME];
LPTSTR pstr;LPTSTR pstrToken;
TCHAR seps[] =_T(",");
pstr=csData.GetBuffer(0);
pstrToken=_tcstok(pstr,seps);

while(pstrToken !=NULL)
{
if(nListMaxCount<MaxRow){csGetData[nListMaxCount]=pstrToken;AfxMessageBox(csGetData[nListMaxCount],MB_OK);}
pstrToken=_tcstok(NULL,seps);
nListMaxCount++;
}
csData.ReleaseBuffer(-1);

//----여러 줄 얻기------------------------------------

// CString str =_T("First\tSecond Third,Fourth\t Fifth");
CString str =_T("100,200,\n300,45.0\n");
// CString str= m_csTestFileData[0];
CString csdata="";
int nListMaxCount=0;
LPTSTR pstr;
LPTSTR pstrToken;
// TCHAR seps[] =_T("\t, ");
TCHAR seps[] =_T("\n");

pstr=str.GetBuffer(0);

pstrToken=_tcstok(pstr,seps);

while(pstrToken !=NULL)
{
// AfxMessageBox(pstrToken,MB_OK);
pstrToken=_tcstok(NULL,seps);

if(pstrToken!=NULL)
{
char seps[] = ","; char *token; char string[250];
///*** Establish string and get the first token:
strcpy( string, pstrToken); token = strtok(string, seps );
csdata="";csdata=token;
// Data-0
AfxMessageBox(csdata);

int nCount=0;
while( token != NULL )
{
token = strtok( NULL, seps );
csdata="";csdata=token;
//Data-1
if(nCount==0)
AfxMessageBox(csdata);
csdata="";csdata=token;//csdata=csdata+"\n";
//Data-2
if(nCount==1)
AfxMessageBox(csdata);
nCount++;
}
nListMaxCount++;
}
}
str.ReleaseBuffer(-1);
AfxMessageBox(pstr, MB_OK);

//------------@(0x40) MASK-----------------------------------------------------------------
//MASK 0100 0000 0x40
//100 0000 0000 0110 0100 (0100 0000) (0100 0000) (0100 0110) (0100 0100) @@FD
//12300 0011 0000 0000 1100 (0100 0011) (0100 0000) (0100 0000) (0100 1100) C@@L
//-----------------------------------------------------------------------------------------

/*---------------------일정간격의 Board 번호와 Ch 번호 구하기 ----------------------------------*/

int nBoardNo=0;
int nChNo=0;
int nMax= CHMAX/12;
int nChMax=12;
CString csTmp="";

if(m_nTestSendCh<nChMax){nChNo=m_nTestSendCh;} //0-11 12ch
else
{
for(int i=1; i<nMax; i++)
{
nBoardNo=m_nTestSendCh/(12*i);
if(nBoardNo<12)break;
}
nChNo=m_nTestSendCh-(12*nBoardNo);
}

csTmp.Format("No%d, nBoard%d, Ch%d",m_nTestSendCh,nBoardNo,nChNo);
AfxMessageBox(csTmp);

m_nTestSendCh++;

/*----------------------반올림 -----------------------------------------------*/

#define Cut(A) (float)((long int) (((A)+.05) * 10))/10;
#define Cut2(A) (float)((long int) (((A)+.5) * 10))/10;

/*----------------------퍼센트 구하기 ----------------------------------------*/

// 100 : 80(환산 기준치)
// 퍼센트 50 구하기
// (50/100)*80
// (50*0.01)*80

int nPercent=(m_ccChModel[nCh].m_SCROLLPERCENT*0.01)*m_ccChModel[nCh].m_PALETTE_SIZE_X;

100퍼센트

(측정값/기준값)*100

/*--------------------------------------------------------------------------------*/

char temp[80];
lstrcpy((LPSTR)temp,(LPSTR)pDlg->m_strIp.operator const char*());
//-------------------------------------------------------------//

BYTE temp[200];
CString csText="[0](@@,0B)";
lstrcpy((LPSTR)temp,(LPSTR)csText.operator const char*());
//클라이언트에 보낸다.
m_pClientSock->Send(temp,200);

CString csText;
char buff[40];
csText=((LPCSTR)buff);

const char Error_message[4][40] = {
"Comm Data Receive Error    ",
"Image Download Error ",
"MPU Control Error    ",
"Comm Error    ",
};

/*---------------------- COleDateTime------------------------*/
CString csWorkTime;
COleDateTime ccTestTime;
ccTestTime=COleDateTime::GetCurrentTime();
csWorkTime=ccTestTime.Format("%I:%M:%S %p");
ccTestTime.Format("%Y %m %d %H:%M");
//--
COleDateTime tmpDateTime = COleDateTime::GetCurrentTime();
String strTime;

strTime.Format("%4d.%02d.%02d/%02d:%02d:%02d",
tmpDateTime.GetYear(), tmpDateTime.GetMonth(),tmpDateTime.GetDay(),
tmpDateTime.GetHour(),tmpDateTime.GetMinute(), tmpDateTime.GetSecond());
//--
CString strTime;
COleDateTime tmpDateTime = COleDateTime::GetCurrentTime();
strTime.Format("%4d_%02d_%02d_%02d_%02d_%02d_Err.txt",
tmpDateTime.GetYear(), tmpDateTime.GetMonth(),tmpDateTime.GetDay(),
tmpDateTime.GetHour(),tmpDateTime.GetMinute(), tmpDateTime.GetSecond());
m_csErrorFileName=strTime;

//-------------------------------------------------------------------------------------------
int MaxRow = MAXRAW+1;
int MaxCol = MAXCOL;
CString cs=""; CString csTmp="";
int col=3;

if(m_bSendAllCheck){m_bSendAllCheck=FALSE; cs="OK";}
else{m_bSendAllCheck=TRUE;cs="-";}
for (int row = 1; row < MaxRow; row++) {

csTmp=m_GridCtrl.GetItemText(row, 1);
if(csTmp!="")
{
m_GridCtrl.SetItemFormat(row, col, DT_CENTER|DT_VCENTER|DT_SINGLELINE);
m_GridCtrl.SetItemText(row, col, cs);
}
}
m_GridCtrl.Invalidate();
//--------------------------------------------------------------------------------------------
BOOL CXYSystemView::FileDataUpdate_RGB_Percent()
{
__int16 length, exist;
char str[200];
int index=0;
int nListMaxCount=0;

FILE *fp ;
CString filename=_T("");
CString ReadData=_T("");
CString strTmp=_T("");
CString data=_T("");
BOOL bFileCheck=false;
BOOL bFileCheck2=false;

filename = CSRGBPercentFileName;
exist = access(filename,0);

if(bFileCheck2==false)//처움에만 찾기
{
index = ReadData.Find("#SETUP$");
if(index>=0){bFileCheck=true; index=0; }
else{AfxMessageBox("Save Data Not Find!"); break;}
}

index = ReadData.Find("\t");
if(index>=0)
{
ReadData.Format("%s", ReadData.Mid(0 , length-2));
}
else
{
ReadData.Format("%s", ReadData.Mid(0 , length-1));
}

if(ReadData=="#ENDEQ$"){break;}

if(bFileCheck)
{
if(bFileCheck2)
{
if(nListMaxCount>=CHMAX){AfxMessageBox("Posion X Save File Error!!");break;}

if(ReadData!="")
{
// char seps[] = " ,\t\n";
char seps[] = ",";
char *token;
char string[250];
   ////////*** Establish string and get the first token:
   strcpy( string, ReadData);
   token = strtok(string, seps );
   int nCount=0;
while( token != NULL )
{
   ///////*** Get next token:
token = strtok( NULL, seps );
if(nCount==0)
FRGB_Percent_R[nListMaxCount]=atof(token);
if(nCount==1)
FRGB_Percent_G[nListMaxCount]=atof(token);
if(nCount==2)
FRGB_Percent_B[nListMaxCount]=atof(token);
if(nCount==3)
FRGB_Percent_Gray[nListMaxCount]=atof(token);

nCount++;
}
nListMaxCount++;
}
}
}
bFileCheck2=true;//처움에만 찾기
}
}
/// fclose(fp);
} else {
// SendDlgItemMessage(IDC_STATIC_WLREM, WM_SETTEXT,0,(LPARAM)(LPSTR)"DATA NONE");
// AfxMessageBox("File Data Not Find! "+CSCHRunTimeFileName);
FileDataSave_RGB_Percent();
return FALSE;
}
fclose(fp);return TRUE;
}

//-------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------
// 화일 디렉토리중 화일명만 추출하기
//-------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------
CString FileNameGet_token(CString csRead)
{
char *token;
char szBuf[1024];
char seps[] = "\\";
////////*** Establish string and get the first token:
//CString InString="C:\\DMX\\Bmp\\Field_R.bmp";
CString InString=csRead;
if(InString.GetLength()==0)return "";
sprintf(szBuf,InString);

CString csGetData="";
token = strtok(szBuf,seps);

char temp2[20]; int Index=0;
while( token != NULL )
{
//////*** While there are tokens in "string"
sprintf(temp2,"%s",token);
csGetData=temp2;
///////*** Get next token:
token = strtok( NULL, seps );
}

int index=0;
if(csGetData.GetLength()>0)index = csGetData.Find("."); else return "";
CString csData="";
csData=csGetData.Mid(0,index); //AfxMessageBox(csData);
return csData;
}
//---------------------------------------------------------------------------------

/*-------------십진수값 자리분할 각각의 해당 자리수 버퍼에 저장----------------*/

//------------------------------------------
if(Sum>0)
{
hundred= (int)(Sum/ 100);
ten= (Sum-(hundred*100))/10;
one=Sum-((hundred*100)+(ten*10));
}
//------------------------------------------

int i,Sum,thousand,hundred,ten,one,Count;
Sum=thousand=hundred=ten=one=Count=0;

char Rpm[4];
char RpmBuf[4];

for(i=0; i<4; i++)
{
Rpm[i]=0;
RpmBuf[i]=0;
}

Sum=6234;

for(i=0; i<Sum; i++)
{
Count++;
if(Count==10)
{
Count=0;

ten++;
if(ten==10)
{
hundred++;
ten=0;

if(hundred==10)
{
thousand++;
hundred=0;
}
}
}
}

one=Sum-((thousand*1000)+(hundred*100)+(ten*10));

Rpm[0]=thousand;
Rpm[1]=hundred;
Rpm[2]=ten;
Rpm[3]=one;

CString Data;
Data.Format("%d%d%d%d",Rpm[0],Rpm[1],Rpm[2],Rpm[3]);

m_TestEdit=Data;

UpdateData(FALSE);

/*---------------------테스트 모드가 ON 모드만 테스트----------------*/

CString csTmp1,csTmp2;

csTmp1="#";
if(ccModel.nMode1==TRUE)
{
csTmp1+="1";
}
if(ccModel.nMode2==TRUE)
{
csTmp1+="2";
}
if(ccModel.nMode3==TRUE)
{
csTmp1+="3";
}

int index = csTmp1.Find("#");//15
int set[8];

int Length = csTmp1.GetLength();

for(int i=0; i<Length; i++)
{
set[i]=atoi(csTmp1.Mid(index+i,1));
}

for(int n=0; n<Length; n++)
{
TestMode(set[n]);
}

// csTmp2.Format("%d",set[2]);
// AfxMessageBox(csTmp2);

/*--------------------------------------------------------------------------------------*/
//////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////// - 이미지 - ////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------*/

//------MIL LIBRARY------------------------------------------------//
   MIL_ID MilSystem
   MIL_ID MilDisplay

   MIL_ID MilImage, /* Image buffer identifier.*/
MilOverlayImage;    /* Overlay image.    */

/* Restore the model image and display it */
   MbufRestore(SINGLE_MODEL_IMAGE, MilSystem, &MilImage);
   //------------------------------------------------------

// 윈도우 창 디스플레이
///MdispSelect(MilDisplay, MilImage);

   //Picture Box 상속 디스플레이
   Handle[0]= ((CWnd*)GetDlgItem(IDC_CAM1))->GetSafeHwnd();
   MdispSelectWindow(MilDisplay, MilImage, Handle[0]);
   //------------------------------------------------------

//------Gray 변경------------------------------------------------//
float r, g, b, gray;

   r=m_pTestBitmap[ADD1]/255.0f;
   g=m_pTestBitmap[ADD2]/255.0f;
   b=m_pTestBitmap[ADD3]/255.0f;
   RGBToGrayMul(r,g,b,&gray);
   gray= (unsigned char)(gray*255.0);

   //++++++++++++++++++++++++++++
   if(gray > 100)//이미지 검출값
   //++++++++++++++++++++++++++++
   //++++++++++++++++++++++++++++

//----------------------------------------------------------------------------------------
//Image 수평 분할 display
/* CClientDC pDC(this);
int Add_x,Add_y=0;
int DivisionRate= PaletteSize_y*5;

if(m_bPaletteChange)
{
for(y=0; y<PaletteSize_y+8; y++)
{
for(x=0; x<PaletteSize_x+8; x++)
{
// pDC.SetPixel(x+BMP_START_EDGE_X1-10,y+BMP_START_EDGE_Y1-10,RGB(122,123,102));
pDC.SetPixel(x+BMP_START_EDGE_X1-4,y+BMP_START_EDGE_Y1-4,RGB(122,123,102));
}
}
m_bPaletteChange=FALSE;
}
else
{
for(y=0; y<PaletteSize_y*ImageMaxNo; y++)
{
for(x=0; x<PaletteSize_x; x++)
{
if(y<DivisionRate)
{
pDC.SetPixel(x+BMP_START_EDGE_X1,y+BMP_START_EDGE_Y1,RGB(255,255,255));
}
else
{
Add_x= PaletteSize_x*(y/DivisionRate)+(y/DivisionRate)*10;
Add_y=DivisionRate*(y/DivisionRate);

pDC.SetPixel((x+BMP_START_EDGE_X1)+Add_x,(y+BMP_START_EDGE_Y1)-Add_y,RGB(255,255,255));
}
}
}
}

//Image를 다섯개씩 분할 수평으로 디스플레이
for(y=0; y<PaletteSize_y*ImageMaxNo; y++)
{
for(x=0; x<PaletteSize_x; x++)
{
if(y<DivisionRate)
{
pDC.SetPixel(x+BMP_START_EDGE_X1,y+BMP_START_EDGE_Y1,RGB(m_DisplayImg_A[(y*WidthLineSize)+(3*x)+2],m_DisplayImg_A[(y*WidthLineSize)+(3*x)+1],m_DisplayImg_A[(y*WidthLineSize)+(3*x)+0]));
}
else
{
Add_x= PaletteSize_x*(y/DivisionRate)+(y/DivisionRate)*10;
Add_y=DivisionRate*(y/DivisionRate);

pDC.SetPixel((x+BMP_START_EDGE_X1)+Add_x,(y+BMP_START_EDGE_Y1)-Add_y,RGB(m_DisplayImg_A[(y*WidthLineSize)+(3*x)+2],m_DisplayImg_A[(y*WidthLineSize)+(3*x)+1],m_DisplayImg_A[(y*WidthLineSize)+(3*x)+0]));
}
}
}
//-------------------------------------------------------------------------------------------------
*/
/*
//-----------------------------------------------------------------------------------
//Binary File Save
//----------------------------------------------
// R G B    3Byte를 2Byte로 변환
// 00000000 00000000
// 11111    R -5비트 32 256/8
//    111 111    G -6비트 64 256/4
//    11111 B -5비트 32 256/8
//----------------------------------------------
//(128x(96*ImageNo))*2 한 픽셀 표현 2바이트 ,이미지 저장할 파일 사이즈
int ImageFileSize=(PaletteSize_x*(PaletteSize_y*ImageMaxNo)*2);

unsigned char *BinOutImg;
BinOutImg = NULL; //변경전 Image file size
BinOutImg = new unsigned char [3*WidthLineSize*(PaletteSize_y*ImageMaxNo)];

index=0; n=0;

for(y=0; y<PaletteSize_y*ImageMaxNo; y++)
{
for(x=0; x<PaletteSize_x; x++)
{
index=n*2;
BinOutImg[index+0]=(((OutImg[(y*WidthLineSize)+(3*x)+2])/8)<<3)|(((OutImg[(y*WidthLineSize)+(3*x)+1])/4)>>3);
BinOutImg[index+1]=(((OutImg[(y*WidthLineSize)+(3*x)+1])/4)<<5)|(((OutImg[(y*WidthLineSize)+(3*x)+0])/8));
n++;
}
}
FILE *outfile;
CString csImageFile;

csImageFile.Format("C:\\ModuleAging\\Bin\\%d.bin",PaletteSize_x);
outfile = fopen(csImageFile,"wb");

fwrite(BinOutImg,sizeof(char),ImageFileSize,outfile);
fclose(outfile);

if(BinOutImg) delete []BinOutImg;
//-----------------------------------------------------------------------------------
//BMP File Save
unsigned char *BmpOutImg=NULL;
BmpOutImg = new unsigned char [(PaletteSize_y*ImageMaxNo)*(PaletteSize_x*24)*3];

for(y=0; y<PaletteSize_y*ImageMaxNo; y++) //BMP 화일로 저장 하기위해 거꾸로 저장
{
y2=((PaletteSize_y*ImageMaxNo)-y);//-1 중요(최종 한줄 표현)
for(x=0; x<PaletteSize_x; x++)
{
BmpOutImg[(y2*WidthLineSize)+(3*x)+2]=OutImg[(y*WidthLineSize)+(3*x)+2];
BmpOutImg[(y2*WidthLineSize)+(3*x)+1]=OutImg[(y*WidthLineSize)+(3*x)+1];
BmpOutImg[(y2*WidthLineSize)+(3*x)+0]=OutImg[(y*WidthLineSize)+(3*x)+0];
}
}

DWORD dwBitsSize = sizeof(BITMAPINFOHEADER)+sizeof(RGBQUAD)*256+WidthLineSize*PaletteSize_y*sizeof(char);

dibHi.biWidth=PaletteSize_x;
dibHi.biHeight=PaletteSize_y*ImageMaxNo;
dibHi.biBitCount =24;
dibHi.biSizeImage = 3*WidthLineSize*(PaletteSize_y*ImageMaxNo);
dibHi.biClrUsed = dibHi.biClrImportant =0;

dibHf.bfType=0x4D42;
dibHf.bfSize = dwBitsSize+sizeof(BITMAPFILEHEADER); // 전체파일 크기
if(dibHi.biBitCount==24) dibHf.bfSize -= sizeof(RGBQUAD)*256; // no pallette
dibHf.bfOffBits = dibHf.bfSize - WidthLineSize*PaletteSize_y*sizeof(char);
dibHf.bfReserved1=dibHf.bfReserved2=0;

FILE *outfile2;
csImageFile.Format("C:\\ModuleAging\\EquipSys\\%d.bmp",PaletteSize_x);
outfile2 = fopen(csImageFile,"wb");

fwrite(&dibHf,sizeof(char),sizeof(BITMAPFILEHEADER),outfile2);
fwrite(&dibHi,sizeof(char),sizeof(BITMAPINFOHEADER),outfile2);
fwrite(BmpOutImg,sizeof(char),3*WidthLineSize*dibHi.biHeight,outfile2);
fclose(outfile2);
if(BmpOutImg) delete []BmpOutImg;
*/

/*--------------------------------------------------------------------------------------*/
//////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////// - 그래픽 - ////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------*/

CDC memDC;
CBitmap memBmp,*pOldBmp;
memDC.CreateCompatibleDC( &dc );
memBmp.CreateCompatibleBitmap( &dc,m_rectWindow.Width(),m_rectWindow.Height() );
pOldBmp = (CBitmap*)memDC.SelectObject( &memBmp );

if( memDC.GetSafeHdc() != NULL )

{ // memDC에 그린다..

memDC.BitBlt( 0,0,m_rectWindow.Width(),m_rectWindow.Height(),&m_memBackDC, 0,0,SRCCOPY ); // 그리기
memDC.BitBlt(
dc.BitBlt( 0,0, nWidth, nHeight, &memDC, 0, 0, SRCCOPY ); // Main DC에 옮겨 쓰기
}

memDC.SelectObject( pOldBmp );

//######################
http://www.ucancode.net
//######################

//-------------------------------------------------------------------
BOOL Ellipse(int x1, int y1, int x2, int y2);

//-------------------------------------------------------------------
BOOL RoundRect(int x1, int y1, int x2, int y2, int x3, int y3);
BOOL RoundRect(PCRECT lpRect, POINT point);
When this member function executes, the rectangle is drawn from the (x1, y1) to the (x2, y2) points. The corners are rounded by an ellipse whose width would be x3 and the ellipse's height would be x3.
//-------------------------------------------------------------------
BOOL Pie(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4);
BOOL Pie(LPCRECT lpRect, POINT ptStart, POINT ptEnd);
The (x1, y1) point determines the upper-left corner of the rectangle in which the ellipse that represents the pie fits. The (x2, y2) point is the bottom-right corner of the rectangle. These two points can also be combined in a RECT or a CRect variable and passed as the lpRect value.

The (x3, y3) point, that can also supplied as a POINT or CPoint for lpStart argument, specifies the starting corner of the pie in a default counterclockwise direction.

The (x4, y4) point, or ptEnd argument, species the end point of the pie.

To complete the pie, a line is drawn from (x3, y3) to the center and from the center to the (x4, y4) points.
//-------------------------------------------------------------------

To draw an arc, you can use the CDC::Arc() method whose syntax is:

BOOL Arc(int x1, int y1, int x2, int y2,
int x3, int y3, int x4, int y4);
Besides the left (x1, y1) and the right (x2, y2) borders of the rectangle in which the arc would fit, an arc must specify where it starts and where it ends. These additional points are set as the (x3, y3) and (x4, y4) points of the figure. Based on this, the above arc can be illustrated as follows:
//-------------------------------------------------------------------
This method uses the same arguments as Arc(). The difference is that while Arc() starts drawing at (x3, y3), ArcTo() does not inherently control the drawing starting point. It refers to the current point, exactly like the LineTo() (and the PolylineTo()) method. Therefore, if you want to specify where the drawing should start, can call CDC::MoveTo() before ArcTo(). Here is an example:

void CExoView::OnDraw(CDC* pDC)
{
CRect Recto(20, 20, 226, 144);
CPoint Pt1(202, 115);
CPoint Pt2(105, 32);

pDC->MoveTo(207, 155);
pDC->ArcTo(Recto, Pt1, Pt2);
}

//------------------------------------------------------------------------
You may wonder why the arc is drawn to the right side of a vertical line that would cross the center of the ellipse instead of the left. This is because the drawing of an arc is performed from right to left or from bottom to up, in the opposite direction of the clock. This is known as the counterclockwise direction. To control this orientation, the CDC class is equipped with the SetArcDirection() method. Its syntax is:

int SetArcDirection(int nArcDirection);
This method specifies the direction the Arc() method should follow from the starting to the end points. The argument passed as nArcDirection controls this orientation. It can have the following values:

Value Orientation
AD_CLOCKWISE The figure is drawn clockwise
AD_COUNTERCLOCKWISE The figure is drawn counterclockwise

The default value of the direction is AD_COUNTERCLOCKWISE. Therefore, this would be used if you do not specify a direction. Here is an example that uses the same values as above with a different orientation:

void CExoView::OnDraw(CDC* pDC)
{
pDC->SetArcDirection(AD_CLOCKWISE);

pDC->Arc(20, 20, 226, 144, 202, 115, 105, 32);
}
//------------------------------------------------------------------------
You can (also) draw an arc using the CDC::AngleArc() method. Its syntax is:

BOOL AngleArc(int x, int y, int nRadius, float fStartAngle, float fSweepAngle);
This member function draws a line and an arc connected. The arc is based on a circle and not an ellipse. This implies that the arc fits inside a square and not a rectangle. The circle that would be the base of the arc is defined by its center located at C(x, y) with a radius of nRadius. The arc starts at an angle of fStartAngle. The angle is based on the x axis and must be positive. That is, it must range from 0° to 360°. If you want to specify an angle that is below the x axis, such as -15°, use 360º-15°=345°. The last argument, fSweepAngle, is the angular area covered by the arc.

The AngleArc() method does not control where it starts drawing. This means that it starts at the origin, unless a previous call to MoveTo() specified the beginning of the drawing.

Here is an example:

void CExoView::OnDraw(CDC* pDC)
{
pDC->MoveTo(52, 28);
pDC->AngleArc(120, 45, 142, 345, -65);
}

//------십자선 그리기------------------------------------------------//
CClientDC pDC(this);
int CenterX=349;int CenterY=298;
int LineSizeX=0; int LineSizeY=0;

LineSizeX=340;
LineSizeY=260;

CPen penRectBlack(PS_SOLID,1,RGB(0,0,255));
CPen *pOldPen;

pDC.SelectObject(&penRectBlack);
pOldPen = pDC.SelectObject(&penRectBlack);

pDC.MoveTo(CenterX,CenterY-LineSizeY);
pDC.LineTo(CenterX,CenterY+LineSizeY);

pDC.MoveTo(CenterX-LineSizeX,CenterY);
pDC.LineTo(CenterX+LineSizeX,CenterY);

pDC.SelectObject(pOldPen);
penRectBlack.DeleteObject();
}

//------------------------------------------------------------------------

//------삼각형 그리기------------------------------------------------//
//CDraw1Doc* pDoc = GetDocument();
//ASSERT_VALID(pDoc);

CBrush NewBrush(RGB(255, 2, 5));
CBrush *pBrush;

CPoint Pt[3];

CDC *pDC = GetDC();

// Top Triangle
Pt[0] = CPoint(125, 10);
Pt[1] = CPoint( 95, 70);
Pt[2] = CPoint(155, 70);

pBrush = pDC->SelectObject(&NewBrush);
pDC->Polygon(Pt, 3);

// Left Triangle
Pt[0] = CPoint( 80, 80);
Pt[1] = CPoint( 20, 110);
Pt[2] = CPoint( 80, 140);

pDC->Polygon(Pt, 3);

// Bottom Triangle
Pt[0] = CPoint( 95, 155);
Pt[1] = CPoint(125, 215);
Pt[2] = CPoint(155, 155);

pDC->Polygon(Pt, 3);

// Right Triangle
Pt[0] = CPoint(170, 80);
Pt[1] = CPoint(170, 140);
Pt[2] = CPoint(230, 110);

pDC->Polygon(Pt, 3);

pDC->SelectObject(pBrush);

//------사각그리기------------------------------------------------//
CPen penRectBlack(PS_SOLID,1,RGB(255,0,0));
pDC->SelectObject(&penRectBlack);
pDC->MoveTo(m_MatchPos.left,m_MatchPos.top);
pDC->LineTo(m_MatchPos.right,m_MatchPos.top);
pDC->LineTo(m_MatchPos.right,m_MatchPos.bottom);
pDC->LineTo(m_MatchPos.left,m_MatchPos.bottom);
pDC->LineTo(m_MatchPos.left,m_MatchPos.top);

//------Text 출력------------------------------------------------//
CFont *Font,*oldFont;
Font=new CFont;

LOGFONT logFont; int nFontHight=25;
logFont.lfStrikeOut=FALSE;//가운데 선긋기
logFont.lfItalic=TRUE;logFont.lfUnderline=FALSE;
logFont.lfEscapement= 0;logFont.lfHeight=nFontHight;
logFont.lfCharSet=HANGEUL_CHARSET;//ANSI_CHARSET;

// Font->CreatePointFont(240,_T("굴림"));
// Font->GetLogFont(&logFont);
Font->CreateFontIndirect(&logFont);
oldFont=dc.SelectObject(Font);

dc.SetBkMode(TRANSPARENT);//dc.SetTextCharacterExtra(2);//행간격
dc.SetTextColor(RGB(255,0,0));//dc.SetBkColor(RGB(255,0,0));
//---------------------------------------------
nTextLine_x=SpotRect.left;//+((SpotRect.right-SpotRect.left)/2);
nTextLine_y=AddBottom+MAINDIS_START_Y-58-8;
dc.TextOut(nTextLine_x,nTextLine_y-15,csLineSize_x);//x,가로 치수 텍스트

dc.SelectObject(oldFont);delete Font;

Font=new CFont;
logFont.lfEscapement= -900;logFont.lfHeight=nFontHight;
Font->CreateFontIndirect(&logFont);
oldFont=dc.SelectObject(Font);

nTextLine_x=SpotRect.right+16;nTextLine_y=AddBottom+MAINDIS_START_Y-25;
dc.TextOut(nTextLine_x,nTextLine_y-15,csLineSize_y);//y,세로 치수 텍스트
// CRect rect;
// rect.left=nTextLine_x; rect.right=nTextLine_x+30;
// rect.top=nTextLine_y-15;rect.bottom=nTextLine_y+30;
/// dc.DrawText(csLineSize_y,&rect,DT_SINGLELINE|DT_CENTER|DT_VCENTER);//y,세로 치수 텍스트
//---------------------------------------------

dc.SelectObject(oldFont);delete Font;
//dc.SelectObject(oldFont);Font.DeleteObject();
dc.SelectObject(pOldPen);NewPen.DeleteObject();

/*-------------------------------------------------------------------
CFont Font,*oldFont;
LOGFONT logFont;

int m_nFontSize=14;
CString m_strFont="바탕체";
Font.CreateFont(m_nFontSize,m_nFontSize,-900,0,FW_DONTCARE,FALSE,
FALSE,FALSE,DEFAULT_CHARSET,OUT_DEFAULT_PRECIS,
CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,DEFAULT_PITCH,
m_strFont);

oldFont=dc.SelectObject(&Font);
dc.SetBkMode(TRANSPARENT);//dc.SetTextCharacterExtra(2);//행간격
dc.SetTextColor(RGB(255,0,0));//dc.SetBkColor(RGB(255,0,0));
//---------------------------------------------
nTextLine_x=SpotRect.left;//+((SpotRect.right-SpotRect.left)/2);
nTextLine_y=AddBottom+MAINDIS_START_Y-60;
dc.TextOut(nTextLine_x,nTextLine_y-15,csLineSize_x);//x,가로 치수 텍스트
dc.SelectObject(oldFont);Font.DeleteObject();

nTextLine_x=SpotRect.right+6;nTextLine_y=AddBottom+MAINDIS_START_Y-20;
// dc.TextOut(nTextLine_x,nTextLine_y-15,csLineSize_y);//y,세로 치수 텍스트
CRect rect;
rect.left=nTextLine_x; rect.right=nTextLine_x+30;
rect.top=nTextLine_y-15;rect.bottom=nTextLine_y+30;

dc.DrawText(csLineSize_y,&rect,DT_SINGLELINE|DT_CENTER|DT_VCENTER);//y,세로 치수 텍스트
//---------------------------------------------

dc.SelectObject(oldFont);Font.DeleteObject();
dc.SelectObject(pOldPen);NewPen.DeleteObject();

/*--------------------사인파그래프---------------------------*/

for (f=-500;f<2000;f++) {
y=(int)(sin(f*3.14/180)*100);
SetPixel(hdc, (int)f, y,RGB(0,0,0));
}
/*--------------------그래프--------------------------------*/
void CGrapeDlg::OnPaint()
{
CPaintDC dc(this); // device context for painting

// TODO: Add your message handler code here
for(int i=0; i<3; i++)
{
GrapeDrawEX(i);
}
// Do not call CDialog::OnPaint() for painting messages
}

void CGrapeDlg::GrapeDrawEX(int SetNo)
{
CClientDC dc(this);

int xStartPoint;
int yStartPoint;
COLORREF GrapeLineColor;

if(SetNo==0)
{
xStartPoint=32;
yStartPoint=150;
GrapeLineColor= RGB(0,250,250);
}
else if(SetNo==1)
{
xStartPoint=32;
yStartPoint=350;
GrapeLineColor= RGB(0,250,0);
}
else if(SetNo==2)
{
xStartPoint=32;
yStartPoint=550;
GrapeLineColor= RGB(0,0,250);
}
int xExpand=22;/*x시간확장 11 or 22*/
int yExpand=(40/2)+(40/2);/*y온도 범위확장 20 or 40*/
int xLimit=40;/*y_pixel 나누기 단위 20 or 40*/
int yLimit=40/2; /*x_pixel 나누기 단위* 20 or 40*/
int yTatalNo=200/2; /*100 or 200 select*/

int xwidth=960;/*480 or 960*/
int yhigh=200/2;/*100 or 200*/
int width=xwidth+xStartPoint+xExpand; //width,high
int high=yhigh+yStartPoint+yExpand;

int ThermoBufX[24];
int ThermoBuf[24];
ThermoBuf[0]=20;
ThermoBuf[1]=30;
ThermoBuf[2]=40;
ThermoBuf[3]=45;
ThermoBuf[4]=50;
ThermoBuf[5]=40;
ThermoBuf[6]=40;
ThermoBuf[7]=50;
ThermoBuf[8]=50;
ThermoBuf[9]=55;
ThermoBuf[10]=60;
ThermoBuf[11]=70;
ThermoBuf[12]=80;
ThermoBuf[13]=90;
ThermoBuf[14]=100;
ThermoBuf[15]=105;
ThermoBuf[16]=104;
ThermoBuf[17]=100;
ThermoBuf[18]=97;
ThermoBuf[19]=98;
ThermoBuf[20]=100;
ThermoBuf[21]=101;
ThermoBuf[22]=100;
ThermoBuf[23]=100;
/*---------------Backgndbrush---------*/
COLORREF m_BackgndBrush= RGB(0,0,0);
CBrush brush(m_BackgndBrush),*pOldBrush;
pOldBrush = (CBrush *)dc.SelectObject(&brush);
dc.Rectangle(xStartPoint,yStartPoint,width,high);
/*---------------BaseTime/Thermo_brush---------*/
COLORREF m_BaseTimebrush= RGB(250,250,250);
CBrush brush2(m_BaseTimebrush);
dc.SelectObject(&brush2);
dc.Rectangle(xStartPoint-27,high,width+2,high+20);/*time*/
dc.Rectangle(xStartPoint-27,yStartPoint,xStartPoint,high+20);/*thermo*/

/*---------------단위pixel-------------*/
for(int i=xStartPoint; i<width; i+=xLimit)
{
for(int n=yStartPoint; n<high; n+=yLimit)
{
dc.SetPixel(i,n,RGB(0,250,250));
}
}
/*----------------전체 테두리-중간 Rect1-----------------*/
CPen penRectBlue1(PS_SOLID,2,RGB(50,0,250)),*pOldPen;
pOldPen = dc.SelectObject(&penRectBlue1);
dc.MoveTo(xStartPoint-27,yStartPoint);
dc.LineTo(width,yStartPoint);
dc.LineTo(width,high+20);
dc.LineTo(xStartPoint-27,high+20);
dc.LineTo(xStartPoint-27,yStartPoint);
/*---------------전체 테두리-안쪽-------------------*/
CPen penRectYello2(PS_SOLID,2,RGB(250,250,0));
dc.SelectObject(&penRectYello2);
dc.MoveTo(xStartPoint+4,yStartPoint+4);
dc.LineTo(width-4,yStartPoint+4);
dc.LineTo(width-4,high-4);
dc.LineTo(xStartPoint+4,high-4);
dc.LineTo(xStartPoint+4,yStartPoint+4);

/*---------------전체 테두리-바깥 Rect3-------------------*/
CPen penRectBlack(PS_SOLID,4,RGB(0,250,250));
dc.SelectObject(&penRectBlack);
dc.MoveTo(xStartPoint-3-27,yStartPoint-3);
dc.LineTo(width+3,yStartPoint-3);
dc.LineTo(width+3,high+20+3);
dc.LineTo(xStartPoint-3-27,high+20+3);
dc.LineTo(xStartPoint-3-27,yStartPoint-3);
/*---------------온도 기준 line-------------------*/
CPen penRectBlack2(PS_SOLID,2,RGB(0,0,0));
dc.SelectObject(&penRectBlack2);
dc.MoveTo(xStartPoint-26,high);
dc.LineTo(xStartPoint,high);
/*---------------각시간 지시선 ----------------------*/
CPen penWhite(PS_SOLID,2,RGB(250,250,250));
dc.SelectObject(&penWhite);

for(int n2=xStartPoint+xLimit; n2<width; n2+=xLimit)
{
dc.MoveTo(n2,high-6);
dc.LineTo(n2,high-16);
}
/*---------------각온도 지시선-----------------------*/
for(int n3=yStartPoint+yLimit; n3<high; n3+=yLimit)
{
dc.MoveTo(xStartPoint+6,n3);
dc.LineTo(xStartPoint+16,n3);
}
/*--------------x_BaseTime출력Text---------------*/
CString TimeText;
int time=0;
// ModifyStyleEx(0,WS_BORDER,SWP_DRAWFRAME);
dc.SetBkMode(TRANSPARENT);
dc.SetTextColor(RGB(50,0,0));
for(int a2=xStartPoint+xLimit; a2<width; a2+=xLimit)
{
time++;
TimeText.Format("%d",time);
dc.TextOut(a2-6,high+3,TimeText);
}
dc.SetTextColor(RGB(250,0,0));
dc.TextOut(xStartPoint-25,yStartPoint-24,"( 'C )");
dc.SetTextColor(RGB(0,0,250));
dc.TextOut(xStartPoint+36,high+26,"TIME- - -");
/*----------------y_Base온도Text--------------------*/
CString ThermoText;
for(int a3=yStartPoint+yLimit; a3<high; a3+=yLimit)
{
if(yhigh==100)
{
ThermoText.Format("%d",yTatalNo-((a3-yLimit)-yStartPoint)+yLimit);
dc.TextOut(xStartPoint-24,a3-8,ThermoText);
}
else if(yhigh==200)
{
ThermoText.Format("%d",(yTatalNo-((a3-yLimit)-yStartPoint)+yLimit)/2);
dc.TextOut(xStartPoint-24,a3-8,ThermoText);
}
}
/*------------온도 point 꼭지점 ----------*/
int count1=0;
int xMove=3;
int point_x=6;
int point_y=6;
CPen penWhite2(PS_SOLID,4,RGB(250,0,50));
dc.SelectObject(&penWhite2);

for(int c=xStartPoint+xLimit; c<width; c+=xLimit)
{
ThermoBufX[count1]=c;
count1++;
}
for(int c2=0; c2<24; c2++)
{
if(yTatalNo==100)
{
dc.Ellipse(ThermoBufX[c2]-xMove,(yTatalNo-ThermoBuf[c2])+yStartPoint+yExpand,ThermoBufX[c2]+point_x-xMove,(yTatalNo-ThermoBuf[c2])+yStartPoint+yExpand+point_y);
}
else if(yTatalNo==200)
{
dc.Ellipse(ThermoBufX[c2]-xMove,((yTatalNo/2)-ThermoBuf[c2])*2+yStartPoint+yExpand,ThermoBufX[c2]+point_x-xMove,((yTatalNo/2)-ThermoBuf[c2])*2+yStartPoint+yExpand+point_y);
}
}
/*-------------온도 그래프 실선--------*/
int count2=0;
int GrapeStartPoint=yhigh+yStartPoint+yExpand-4;
CPen penGrapeRed(PS_SOLID,1,GrapeLineColor);
dc.SelectObject(&penGrapeRed);
dc.MoveTo(xStartPoint+4,GrapeStartPoint);

for(int d=xStartPoint+xLimit; d<width; d+=xLimit)
{
ThermoBufX[count2]=d;
count2++;
}
for(int d2=0; d2<24; d2++)
{
if(yTatalNo==100)
{
dc.LineTo(ThermoBufX[d2],(yTatalNo-ThermoBuf[d2])+yStartPoint+yExpand+3);
}
else if(yTatalNo==200)
{
dc.LineTo(ThermoBufX[d2],((yTatalNo/2)-ThermoBuf[d2])*2+yStartPoint+yExpand+3);
}
}
/*--------------온도출력 Text---------------*/
// ModifyStyleEx(WS_BORDER,0,SWP_DRAWFRAME);
CString TextData;
dc.SetBkMode(TRANSPARENT);
dc.SetTextColor(RGB(250,250,250));

for(int a=0; a<24; a++)
{
TextData.Format("%d",ThermoBuf[a]);
if(yTatalNo==100)
{
dc.TextOut(ThermoBufX[a]-6,(yTatalNo-ThermoBuf[a])+yStartPoint+yExpand-20,TextData);
}
else if(yTatalNo==200)
{
dc.TextOut(ThermoBufX[a]-6,((yTatalNo/2)-ThermoBuf[a])*2+yStartPoint+yExpand-20,TextData);
}
}
/*-----------------------------------------------*/
dc.SelectObject(pOldBrush);
dc.SelectObject(pOldPen);
/*------------------------------------------------*

교육중..

희자매파파 — Wed, 4 Jul 2012 08:44:49 +0900

이번주(7/2 ~ 7/6)는 서울로 통근하면서 교육 중이다. 누군가는 여관잡고 자라고 하지만, 난 그게 별로다..

멀어도 집으로 가는게 좋으니까..

아침 6시에 나와서 서울오면 한 8시쯤.. 7시쯤 나올까도 하는데, 그때 나오면 지각할 것 같고..

좌우지간 c# 교육을 듣고 있는데, 어제까지는 그나마 초기부분 이라서 그런지 어렵지는 않은 듯 싶다.

오늘부터 아마 어렵고 바빠지겠지..

그런데, 배우는 내용이 기초라서 응용 부분은 회사로 복귀해서 해야만 할 듯 하다.

여기는 콘솔위주이고.. 회사에서는 GUI 위주니까..

장비업계로 와서 계속 교육의 연속인듯 하다.

아마 프로필에 교육 필증이 계속 늘어날 듯 하다. 근데, 내가 받은 교육들 내가 다 이해했었나?

이번 교육은 다 이해하도록 해 봐야겠다.

목동에 가다

희자매파파 — Wed, 4 Jul 2012 08:38:52 +0900

서울에서 교육 받는중 갑자기 야구장에 가보고 싶었다. 어차피 한화가 이번주 목동에서 경기도 있고.

하지만 4-2 패.

될듯될듯. 하면서 안되었다.

누군가는 크레이지 모드로 한 2-3명만 되면 되는데.

한화 응원하려고 머리민건 아니지만 나도 한화 선수보다 더 짧게 밀었는데.

좀 힘내서 가을 잔치 가보자구.

itistory-photo-1

iPhone 에서 작성된 글입니다.

SQL2008 - 설치중 "performance counter registry hive consistency" 오류 발생시 처리 방법

희자매파파 — Thu, 14 Jun 2012 19:04:10 +0900

오늘 SQL2008을 다시 설치하다보니까 "performance counter registry hive consistency" 이런 오류가 발생되면서 다음으로 진행이 되지 않는 문제가 발생됨..

결국 구글사마의 힘을 빌어 몇가지 방법을 찾아보니 다음과 같다..

다음에 같은 에러 발생시 대처하기 위해 적어둠..

*. 국가별 옵션에서 관리자 언어를 한국얼로 바꿔본다.. --> 되는 경우도 있음..

* . 오류에 나오는 http://support.microsoft.com/kb/300956 방법대로 해본다.

--> 이것도 잘 안 되는 경우가 발생함

*. cmd 창에서 다음과 같이 입력한다. 해당 오류를 무시하는 방법이다. 그리 추천하지는 않지만, 이 방법으로 하면 다음으로 진행은 된다. 참고로 이 명령은 SQL2008이 있는 드라이브 루트에서 실행해야 한다.

setup /skiprules=PerfMonCounterNotCorruptedCheck /ACTION=install

바쁜 나날들

희자매파파 — Thu, 24 May 2012 00:20:26 +0900

요즘은 하루가 어떻게 가는지 모를 정도로 바쁘게 지나간다.

힘든데 힘든티도 못 낸다.
밑에 사람들한테 모범이 되어야하고. 위에는 성실해 보여야 하고.

정신없이 지나가는게 좋은걸까.

바쁜 나날들과 아이패드..

희자매파파 — Wed, 16 May 2012 10:02:50 +0900

이틀에 한번씩 포스팅이 쉬운게 아니구나라는 것을 느끼는 요즘이다.

거의 매일 야근이다 보니 집에가면 만사가 귀찮아 진다.

아이패드에서라도 작성해야 하는데, 집에가면 아이패드는 애들 차지가 된다.

그게 끝나면 안사람이 사용하고..

회사에서만 사용하게 된는듯..

그나마 회의 시간에 노트 대신 사용하고.. 중간중간.. 메일 확인하고..

덕분에 아이폰의 사용시간은 줄어드는듯하다.

아이패드는 한번 사볼만한 아이템인 듯 하다..

참고로 오늘은 하드복사중.. 하드 하나가 맛탱이가 가서 클론 장비 빌려와서 작업중.. 1TB이다 보니 시간이 좀 걸릴듯.하네..

위에서 시킨일도 많고.. 에고.. 어떤것부터 처리해야 할지 적고 시작해야 겠다.