�������� Linux Tags

14. ����ͼ��Bitblt

����ͼ��һ����ά��λԪ���У�����ͼ���ͼ��һһ��Ӧ������ʵ�����ͼ��ɨ��ɵ���ͼ���ᣬͼ�񱻷ָ�����񣬲���ͼ����Ϊȡ����λ���ڵ���ͼ�е�ÿ��ͼ��ֵָ����һ����λ������ͼ���ƽ����ɫ����ɫ����ͼÿ��ͼ��ֻ��ҪһλԪ����ɫ���ɫ����ͼ��ÿ��ͼ����Ҫ���λԪ��

����ͼ������Windows��ʽ�ڴ���ͼ����Ѷ�����ַ���֮һ������ͼ����Ѷ����һ����ʽ��metafile���ҽ��ڵ�ʮ�������ۡ�Metafile����ľ��Ƕ�ͼ��������ɵ������������ǽ�ͼ������λ����ͼʾ������

�����ҽ�����ϸ�����ۣ�Microsoft Windows 3.0������һ�ֳ�Ϊװ���޹ص���ͼ��DIB��device-independent bitmap�����ҽ�����һ������DIB��������Ҫ����GDI����ͼ���������һ����Windows�б�DIB����֧Ԯ�ĵ���ͼ�����ϡ���ͬ���´����ķ�����ʽ��˵���ģ����ֱ�DIB����ͼ���类Windows֧Ԯ��ͼ�θ�ʽ��Ȼ�������ü�ֵ��

����ͼ����
��

����ͼ��metafile�ڵ���ͼ�δ��������ж�ռ��һϯ֮�ء�����ͼ����������ʾ������ʵ����ĸ���ͼ��������λ������Ƭ������Ѷͼ��Metafile���ʺ���������˻��߻���������ͼ�񣬱��罨����ͼ������ͼ��metafile���ܴ�춼��������Ϊ������춴�Ƭ�ϣ����Ҷ���ͨ����������WindowsӦ�ó�ʽ֮�䴫�䡣

����ͼ��metafile���������λԪӳ��ͼ�������ͼ��֮��IJ��λԪӳ��ͼ������ɢ��ͼ������������豸��������ͼ���õѿ�������ϵͳ����������豸�����������������ܱ��������ơ����ڴ������ͼ������豸��λԪӳ���豸���������Ѷ��ʾ������ӡ����������ӡ��������īӡ����������ʽ��ͼ��������������豸��

����ͼ��������Ҫ��ȱ�㡣��һ��������������װ�������Ե�Ӱ�졣�����Եľ��Ƕ���ɫ�������ԣ��ڵ�ɫ�豸����ʾ��ɫ����ͼ��Ч�����Dz�����������ġ���һ�������ǵ���ͼ������ʾ���ض�����ʾ�����Ⱥ�ͼ���ݺ�ȡ����ܵ���ͼ�ܱ��������С�����������Ĵ���ͨ���������ƻ�ɾ��ͼ�ص�ijЩ�к��У��������ƻ�ͼ��Ĵ�С����metafile�ڷŴ���С����Ȼ�ܱ���ͼ����ò�����ƻ���

����ͼ�ĵڶ���ȱ������Ҫ�ܴ�Ĵ���ռ䡣���磬����������640��480ͼ�أ�16ɫ����Ƶͼ�����У�VGA��Video Graphics Array��өĻ��һ������ͼ��Ҫ���150 KB�Ŀռ䣻һ��1024��768������ÿ��ͼ��Ϊ24λԪ��ɫ��ͼ������Ҫ���2 MB�Ŀռ䡣Metafile��Ҫͨ���ȵ���ͼ�����ٵĿռ䡣����ͼ�Ĵ���ռ���ͼ��Ĵ�С�����������ɫ��������metafile�Ĵ���ռ�����ͼ��ĸ��ӳ̶Ⱥ�����������GDIָ����������

Ȼ��������ͼ���metafile֮������ٶȡ�������ͼ���Ƹ���Ѷ��ʾ��ͨ���ȸ��ƻ���ͼ�ε������ٶ�Ҫ�졣������꣬ѹ����������ѹ������ͼ�ĵ�����С����ʹ������Ч��ͨ���绰�ߴ��䲢�㷺�����Internet����ҳ�ϡ�

����ͼ����Դ
��

����ͼ�����ֹ����������磬ʹ��Windows 98�����ġ�С���ҡ���ʽ��һЩ����Ըʹ��λԪӳ���ͼ����Ҳ��ʹ��������ͼ���塣���Ǽٶ���ͼ������һ���Ḵ�ӵ�������������������������

����ͼͼ��Ҳ���ɵ��Գ�ʽ�������ɡ����ܴ�����������ɵ�ͼ���ܰ�����ͼ��metafile���棬���Ǹ������ȵĻ��������ͼ��ͨ��������Ҫ����ͼ��

���ڣ�����ͼͨ�����������ʵ�����ͼ�ñ£¬²ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ó²ï¿½ï¿½ï¿½è±¸ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Êµï¿½ï¿½ï¿½ï¿½ï¿½Í¼ï¿½ï¿½ï¿½ï¿½ï¿½ëµ½ï¿½ï¿½ï¿½Ô¡ï¿½ï¿½ï¿½ï¿½ï¿½Ó²ï¿½ï¿½Í¨ï¿½ï¿½Ê¹ï¿½ï¿½ ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½×°ï¿½ï¿½ ï¿½ï¿½CCD��charge-coupled device��������װ�ýӴ�������ͷŵ�ɡ���ʱ��ЩCCD��Ԫ�����г�һ�飬һ��ͼ�ض�Ӧһ��CCD��Ϊ��Լ��֧��ֻ��һ��CCDɨ��ͼ��

��������CCD�豸�У� É¨ï¿½ï¿½ï¿½ï¿½ ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ÏµÄ¡ï¿½ï¿½ï¿½ï¿½ï¿½Ò»ï¿½ï¿½CCD����ֽ��ͼ��������Ƭ���ı���ɨ�衣CCD���ݹ��ǿ�Ȳ�����ɡ������λת������ADC��Analog-to-digital converters���ѵ��ת��Ϊ��λѶ�ţ�Ȼ�����гɵ���ͼ��

Я���������Ҳ����CCD��Ԫ������׽Ӱ��ͨ������ЩӰ���Ǽ�¼��¼Ӱ���ϡ���������Щ��Ѷ���Ҳ��ֱ�ӽ��� Ó°ï¿½ï¿½×½ï¿½ï¿½ ï¿½ï¿½frame grabber������װ���ܰ������Ѷ�ź�ת��Ϊһ��ͼ��ֵ����ЩӰ��׽�����κ����ݵ���Ѷ�ź���Դ����ͬʱʹ�ã�����VCR�������DVD���Ż������ߵ��ӽ�������

�������λ������ļ�λ��춼�ͥʹ������˵��ʼ��ø��������ˡ���������������ͨ�������������λ�������ʹ�õ�Ƭ������һ��CCD������ͼ�񣬲�����ADC�ڲ�����λͼ��ֱ�Ӵ�����������ڵļ������С�ͨ������λ���������ԵĽ���Ҫͨ�����в���

����ͼ�ߴ�
��

����ͼ�ʾ��Σ����пռ�ߴ磬ͼ��ĸ߶ȺͿ��ȶ���ͼ��Ϊ��λ�����磬�����������һ����С�ĵ���ͼ������Ϊ9ͼ�أ��߶�Ϊ6ͼ�أ����߸��򵥵ؼ�Ϊ9��6��


��

ϰ���ϣ�����ͼ���ټdzߴ����ȸ������ȡ�����ͼ����Ϊ9��6����54ͼ�ء��ҽ�����ʹ�÷���cx��cy����ʾ����ͼ�Ŀ��Ⱥ͸߶ȡ�c��ʾ���������cx��cy������x�ᣨˮƽ����y�ᣨ��ֱ����ͼ������

�����ܸ���x��y��������������ͼ�Ͼ����ͼ�ء�һ�㣨�����������������������ڼ���ͼ��ʱ������ͼ��ʼ�ͼ������Ͻǡ��������ڴ˵���ͼ���½ǵ�ͼ���������(8, 5)����Ϊ��0��ʼ���������Դ�ֵ��ͼ��Ŀ��Ⱥ͸߶�С1��

����ͼ�Ŀռ�ߴ�ͨ��Ҳָ���˽����ȣ�������һ��������Ĵʡ�����˵���ǵ���Ѷ��ʾ��640��480�Ľ����ȣ���������ӡ�����Ľ�����ֻ��ÿӢ��300�㡣��ϲ������һ������н����ȵ���˼��Ϊÿ��λͼ�ص�����������ͼ�����������ϵĽ�����ָ���ǵ���ͼ���ض�������λ�е�ͼ��������������������ʹ�ý������������ʱ���䶨�������Ӧ������ȷ�ġ�

����ͼ�Ǿ��εģ����ǵ��Լ�����ռ������Եġ�ͨ������������������������ͼ���д����ڼ������У��ҴӶ���ͼ�ؿ�ʼ�����н�������DIB�Ǵ˹����һ����Ҫ���⣩��ÿһ�У�ͼ�ض�������ߵ�ͼ�ؿ�ʼ�������Ҵ��档��ͺ��񴢴漸�������еĸ�����Ԫ��

��ɫ�͵���ͼ
��

���ռ�ߴ����⣬����ͼ������ɫ�ߴ硣����ָ����ÿ��ͼ������Ҫ��λԪ������ʱҲ��Ϊ����ͼ�� ï¿½ï¿½É«ï¿½ï¿½ï¿½ ï¿½ï¿½color depth���� Î»Ôªï¿½ï¿½ ï¿½ï¿½bit-count���� Î»Ôª/ͼ�� ï¿½ï¿½bpp��bits per pixel����������ͼ�е�ÿ��ͼ�ض�����ͬ��������ɫλԪ��

ÿͼ��1λԪ�ĵ���ͼ��Ϊ ï¿½ï¿½ï¿½ï¿½ ï¿½ï¿½bilevel���� ï¿½ï¿½É« ï¿½ï¿½bicolor������ ï¿½ï¿½É« ï¿½ï¿½monochrome������ͼ��ÿͼ�ؿ�����0��1��0��ʾ��ɫ��1���Ա�ʾ��ɫ���������������������������ɫ��һ��ͼ�ؾ���Ҫ�ж��λԪ�����ܵ���ɫֵ���2λԪ��ֵ����2λԪ���Եõ�4����ɫ����4λԪ���Ե�16����ɫ��8λԪ�ɵõ�256����ɫ��16λԪ�ɵõ�65,536����ɫ����24λԪ�ɵõ�16,777,216����ɫ��

��ν���ɫλԪ���������������Ϥ����ɫ���Ӧ��Ŀǰ��������ͼʱ�������������ҳ��������ѣ������⡣

ʵ�ʵ��豸
��

����ͼ�ɰ�����ɫλԪ�������ࣻ��Windows�ķ�չ�����У���ͬ�ĵ���ͼ��ɫ��ʽȡ��춳�����Ѷ��ʾ���Ĺ��ܡ�ʵ���ϣ����ǿɰ���Ѷ��ʾ�����忴����һ���޴�ĵ���ͼ�����Ǵ���ʾ���ϾͿ��Կ�����

Windows 1.0�������õ���ʾ����IBM�IJ�ɫͼ����������CGA��Color Graphics Adapter���͵�ɫͼ�ο���HGC��Hercules Graphics Card����HGC�ǵ�ɫ�豸����CGAҲֻ����Windows�Ե�ɫͼ��ģʽʹ�á���ɫ����ͼ���ڻ��ܳ��ã����磬������α�һ��Ϊ��ɫ�������ҵ�ɫ����ͼ����ʾͼ�����⻹��������;��

������ǿ��ͼ����ʾ����EGA��Enhanced Graphics Adapter���ij��֣�Windowsʹ���߿�ʼ�Ӵ�16ɫ��ͼ�Ρ�ÿ��ͼ����Ҫ4����ɫλԪ����ʵ���ϣ�EGA�����������ĸ����ӣ���������һ��64����ɫ�ĵ�ɫ�̣�Ӧ�ó�ʽ���Դ���ѡ�������16����ɫ����Windowsֻ���ϼ򵥵ķ���ʹ��EGA������EGA��ʹ�õ�16����ɫ�Ǻڡ��ס����ֻ�ɫ���ߵ����ȵĺ�ɫ���̺�������ԭɫ������ɫ����������ϵ���ɫ����������Ϊ��16����ɫ��Windows�������ɫ��׼��ͬ��������16ɫ����ͼҲ������Windows����ʾ���������ͼʾ����16ɫ�ĵ���ͼ��ͨ�����򵥵Ŀ�ͨͼ��Ҳ��������16����ɫ������

��16ɫ����ͼ�е���ɫ������ʱ��ΪIRGB��������������Intensity-Red-Green-Blue��������ʵ������Դ��IBM CGA����ģʽ�����ʹ�õ�ʮ������ɫ��ÿ��ͼ�����õ�4��IRGB��ɫλԪ��ӳ��Ϊ��14-1��ʾ��Windowsʮ����λRGB��ɫ��

��14-1
IRGB RGB��ɫ ��ɫ����
0000 00-00-00 ��
0001 00-00-80 ����
0010 00-80-00 ����
0011 00-80-80 ����
0100 80-00-00 ����
0101 80-00-80 �����
0110 80-80-00 ����
0111 C0-C0-C0 ����
1000 80-80-80 ����
1001 00-00-FF ��
1010 00-FF-00 ��
1011 00-FF-FF ��
1100 FF-00-00 ��
1101 FF-00-FF ���
1110 FF-FF-00 ��
1111 FF-FF-FF ��

EGA�ļ�����������ĸ�����ɫ�桹��Ҳ����˵������ÿ��ͼ����ɫ����λԪ�ڼ��������Dz������ġ�Ȼ����������֯��ʾ��������ʹ���е�����λԪ��������һ�����еĺ�ɫλԪ������һ�𣬵ȵȡ������������ͺ���һ���豸�������ԣ���Windows��ʽд���߲���Ҫ�˽�����ϸ�ڣ�����ʱӦ�����ٵ�֪��һЩ����������Щ��ɫ��������һЩAPI�����У�����GetDeviceCaps��CreateBitmap��

Windows 98��Microsoft Windows NT��ҪVGA������ȸ��ߵ�ͼ�ο�������Ŀǰ���ϵ���ʾ������ͱ�׼��

1987�꣬IBM���緢����Ѷͼ�����У�Video Graphics Array��VGA���Լ�PS/2ϵ�еĸ��˵��ԡ����ṩ�����಻ͬ����ʾģʽ������õ�ͼ��ģʽ��WindowsҲʹ������֮һ����ˮƽ��ʾ640��ͼ�أ���ֱ��ʾ480��ͼ�أ�����16����ɫ��Ҫ��ʾ256����ɫ�������VGA�����л���320��240��ͼ��ģʽ������ͼ�������ʺ�Windows������������

һ�������Ѿ����������VGA������ɫ���ƣ���Ϊ����Ӳ�������̺ܿ�Ϳ����ˡ�Super-VGA����SVGA����ʾ�����������������Ѷ�����壬����ʾ256����ɫ���ж��640��480��ģʽ���������ڵı�׼������Ҳ��һ�����£���Ϊ�����ʵ�����е�ͼ����˵��16����ɫ��춼򵥣���Щ���ʺϡ�

��ʾ256����ɫ����ʾ��ģʽ����ÿͼ��8λԪ����������Щ8λԪֵ��������ʵ�ʵ���ɫ�������ʵ�ϣ���ʾ���ṩ�ˡ���ɫ�̶��ձ���palette lookup table�������ñ���������ָ����8λԪ����ɫֵ���Ա���ʵ����ɫ����ϡ���Windows�У�Ӧ�ó�ʽ����ֱ�Ӵ�ȡ��ɫ�̶��ձ���ʵ���ϣ�Windows������256����ɫ�е�20�֣���Ӧ�ó�ʽ����ͨ����Windows��ɫ�̹����������Զ������236����ɫ�������Щ���ݣ��ҽ��ڵ�ʮ������ϸ���ܡ���ɫ�̹���������Ӧ�ó�ʽ��256ɫ��ʾ������ʾʵ�ʵ���ͼ��Windows�������20����ɫ���14-2��ʾ��

��14-2
IRGB RGB��ɫ ��ɫ����
00000000 00-00-00 ��
00000001 80-00-00 ����
00000010 00-80-00 ����
00000011 80-80-00 ����
00000100 00-00-80 ����
00000101 80-00-80 �����
00000110 00-80-80 ����
00000111 C0-C0-C0 ����
00001000 C0-DC-C0 ��Ԫ��
00001001 A6-CA-F0 ����
11110110 FF-FB-F0 ���
11110111 A0-A0-A4 ���Ի�
11111000 80-80-80 ����
11111001 FF-00-00 ��
11111010 00-FF-00 ��
11111011 FF-FF-00 ��
11111100 00-00-FF ��
11111101 FF-00-FF ���
11111110 00-FF-FF ��
11111111 FF-FF-FF ��

������꣬True-Color��ʾ�����ձ飬������ÿͼ��ʹ��16λԪ��24λԪ����ʱÿͼ����Ȼ����16λԪ��������1λԪ���ã�������15λԪ��Ҫ����춺졢�̺����������졢�̺���ÿ�ֶ���32ɫ�ף���������Ϳ��Դﵽ32,768����ɫ�����ձ���ǣ�6λԪ�����ɫ������Դ���ɫ�����У��������Ϳɵõ�65,536����ɫ����춷Ǽ����Ե�PCʹ������˵�����Dz���ϲ����������32,768��65,536֮������֣����ͨ����������Ѷ��ʾ����ΪHi-Color��ʾ���������ṩ����ǧ�Ƶ���ɫ��

����ÿ��ͼ��24λԪʱ�������ܹ�����16,777,216����ɫ������True Color�����������ɫ����ÿ��ͼ��ʹ��3λԪ�顣�������ı�׼�����ƣ���Ϊ�����´���������йٵļ��޶���Ҳ�ܷ��㡣

�ں���GetDeviceCapsʱ���μ������µ�DEVCAPS��ʽ������������BITSPIXEL��PLANES�����������ʾ������ɫ��λ����Щֵ��ʾ���14-3��ʾ

��14-3
BITSPIXEL PLANES ��ɫ��
1 1 2
1 4 16
8 1 256
15��16 1 32,768��65 536
24��32 1 16 777 216

�������Ӧ�ò�����������ɫ��ʾ���ˣ������������ˣ�����Ӧ�ó�ʽҲӦ�ò��ᷢ�����⡣

GDI֧Ԯ�ĵ���ͼ
��

Windowsͼ��װ�ý��棨GDI��Graphics Device Interface����1.0�濪ʼ֧Ԯ����ͼ��������һֱ��Windows 3.0��ǰ��Windows��Ψһ֧ԮGDI�����ֻ�е���ͼ���Ե���ͼ������ʹ�á���ЩGDI����ͼ����ǵ�ɫ�ģ�������ʵ�ʵ�ͼ������豸��������Ѷ��ʾ��������ͬ����ɫ��λ�����磬��16ɫVGA���ݵĵ���ͼ���ĸ���ɫ�档��������Щ��ɫ����ͼ���ܴ��棬Ҳ���������ɫ��λ��ͬ��ͼ������豸����ÿͼ��ռ8λԪ�Ϳ��Բ���256����ɫ���豸���ϡ�

��Windows 3.0��ʼ��������һ���µĵ���ͼ��ʽ�����dz�֮Ϊװ���޹ص���ͼ��device-independent bitmap��������DIB��DIB�������Լ��ĵ�ɫ�̣�������ʾ����RGB��ɫ���Ӧ��ͼ��λԪ��DIB����ʾ���κ�λԪӳ������豸�ϡ�����Ψһ��������DIB����ɫͨ��һ����ת�����豸ʵ�ʱ��ֳ�������ɫ��

��DIBͬʱ��Windows 3.0�������ˡ�Windows��ɫ�̹������������ó�ʽ�ܹ�����ʾ��256����ɫ���Զ���ɫ�����������ڵ�ʮ������������������Ӧ�ó�ʽͨ������ʾDIBʱʹ�á���ɫ�̹���������

Microsoft��Windows 95����Windows NT 4.0������չ��DIB�Ķ��壬������Windows 98����Windows NT 5.0�����ٴ���չ����Щ��չ��������ν�ġ�ͼ����ɫ��������ICM��Image Color Management����������DIB����ȷ��ָ��ͼ������Ҫ����ɫ���ҽ��ڵ�ʮ���¼�Ҫ����ICM��

����DIB��ô��Ҫ���ڴ�������ͼʱ�����ڵ�GDI����ͼ�����Ȼ��������Ҫ�Ľ�ɫ�����յ���ͼʹ�÷�ʽ����÷����ǰ������÷����ݽ���չ��ʱ��˳����ѧϰ���ȴ�GDI����ͼ�����λԪ�鴫��ĸ��ʼ��

λԪ�鴫��
��

��ǰ���ᵽ���������԰�������Ѷ��ʾ��������һ�������ͼ������өĻ�ϼ�����ͼ���ɴ�������Ѷ��ʾ���ϼ������е�λԪ���������κ���Ѷ��ʾ�ľ�������Ҳ����һ������ͼ�����С��������������������

�����Ǵӽ�ͼ�����Ѷ��ʾ��һ�������Ƶ���һ�����򣬿�ʼ�����ڵ���ͼ��������аɣ������ǿ���BitBlt��ʽ�Ĺ�����

Bitblt��������bit blit����������λԪ�鴫�䣨bit-block transfer������BLT��Դ�һ���������ָ���ָ����DEC PDP-10���������������顣���bitblt����һ������ͼ������Xerox Palo Alto Research Center��PARC����Ƶ�SmallTalkϵͳ�йء���SmallTalk�У����е�ͼ�����������ʹ��bitblt����ʽд������ʱ��blt�������ʣ����磺��Then I wrote some code to blt the happy face to the screen and play a wave file.��

BitBlt��ʽ�ƶ�����ͼ�أ����ߣ�����ȷ�أ���һ��λԪӳ��ͼ�顣����������������䣨transfer������BitBlt��ʽ������ͬ���˺�ʽʵ���϶�ͼ��ִ����һ��λԪ���������ҿ��Բ���һЩ��Ȥ�Ľ����

�򵥵�BitBlt
��

��ʽ14-1��ʾ��BITBLT��ʽ��BitBlt��ʽ����ʽϵͳ�Ĺ��ܱ�ͼʾ��λ춳�ʽWindows�����Ͻǣ����Ƶ�������ʾ����

 ï¿½ï¿½Ê½14-1  BITBLT
BITBLT.C
/*----------------------------------------------------------------------
   	BITBLT.C -- 	BitBlt Demonstration
               						(c) Charles Petzold, 1998
  -------------------------------------------------------------------*/

#include <windows.h>
LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    			PSTR szCmdLine, int iCmdShow)
{
     	static TCHAR 	szAppName [] = TEXT ("BitBlt") ;
     	HWND         			hwnd ;
     	MSG          			msg ;
     	WNDCLASS     			wndclass ;

     	wndclass.style         			= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         			= LoadIcon (NULL, IDI_INFORMATION) ;
     	wndclass.hCursor       			= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= (HBRUSH) GetStockObject (WHITE_BRUSH) ;
     	wndclass.lpszMenuName  		= NULL ;
     	wndclass.lpszClassName 		= szAppName ;
     
   	if (!RegisterClass (&wndclass))
     	{
          		MessageBox (NULL, TEXT ("This program requires Windows NT!"),
                      							szAppName, MB_ICONERROR) ;
          		return 0 ;
     }
     
     	hwnd = CreateWindow (	szAppName, TEXT ("BitBlt Demo"), 
                              WS_OVERLAPPEDWINDOW, 
                          	  CW_USEDEFAULT, CW_USEDEFAULT,
                          	  CW_USEDEFAULT, CW_USEDEFAULT,
                          	  NULL, NULL, hInstance, NULL) ;

     	ShowWindow (hwnd, iCmdShow) ;
     	UpdateWindow (hwnd) ;
     	while (GetMessage (&msg, NULL, 0, 0))
     {
          			TranslateMessage (&msg) ;
          			DispatchMessage (&msg) ;
     }
   	return msg.wParam ;
}

LRESULT CALLBACK WndProc (	HWND hwnd, UINT message, WPARAM wParam,LPARAM lParam)
{
     	static int  		cxClient, cyClient, cxSource, cySource ;
     	HDC         		hdcClient, hdcWindow ;
     	int         		x, y ;
     	PAINTSTRUCT 		ps ;
     
     	switch (message)
     	{
     	case WM_CREATE:
          			cxSource = GetSystemMetrics (SM_CXSIZEFRAME) +
                    GetSystemMetrics (SM_CXSIZE) ;
          			cySource = GetSystemMetrics (SM_CYSIZEFRAME) + 
                    GetSystemMetrics (SM_CYCAPTION) ;
          			return 0 ;
     	case 	WM_SIZE:
          			cxClient = LOWORD (lParam) ;
        			cyClient = HIWORD (lParam) ;
         			return 0 ;

     	case 	WM_PAINT:
          			hdcClient = BeginPaint (hwnd, &ps) ;
          			hdcWindow = GetWindowDC (hwnd) ;
	
          			for (y = 0 ; y < cyClient ; y += cySource)
          			for (x = 0 ; x < cxClient ; x += cxSource)
          			{
               			BitBlt (hdcClient, x, y, cxSource, cySource,
                       						hdcWindow, 0, 0, SRCCOPY) ;
          			}

          			ReleaseDC (hwnd, hdcWindow) ;
          			EndPaint (hwnd, &ps) ;
          			return 0 ;

     	case 	WM_DESTROY:
          			PostQuitMessage (0) ;
          			return 0 ;
     }
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}

��Ϊʲôֻ����һ��BitBlt�أ�ʵ���ϣ��Ǹ�BITBLT��ϵͳ���ܱ�ͼʾ�Ķ��������������ʾ�����ڴ����������Ѷ�������ձ�ʹ�õ�IDI_INFORMATIONͼʾ������ͼ14-1��ʾ��


��

ͼ14-1 BITBLT��өĻ��ʾ

BitBlt��ʽ�ӳ�Ϊ����Դ����װ�������н�һ����������ͼ�ش��䵽��Ϊ��Ŀ��(destination)������һ��װ����������ͬ��С�ľ��������˺�ʽ���﷨���£�

BitBlt (hdcDst, xDst, yDst, cx, cy, hdcSrc, xSrc, ySrc, dwROP) ;

��Դ��Ŀ��װ�����ݿ�����ͬ��

��BITBLT��ʽ�У�Ŀ��װ���������Ӵ�����ʾ����װ�����ݴ��Ŵ�BeginPaint��ʽ��á���Դװ��������Ӧ�ó�ʽ�������Ӵ�����װ�����ݴ��Ŵ�GetWindowDC��õġ������Եأ�������װ������ָ����ͬһ��ʵ���豸����Ѷ��ʾ������������������װ�����ݵ�����ԭ�㲻ͬ��

xSrc��ySrc����ָ������Դͼ�����Ͻǵ�����λ�á���BITBLT�У�������������Ϊ0����ʾͼ�����Դװ�����ݣ�Ҳ���������Ӵ��������Ͻǿ�ʼ��cx��cy������ͼ��Ŀ��Ⱥ͸߶ȡ�BITBLT���ݴ�GetSytemMetrics��ʽ��õ���Ѷ��������Щֵ��

xDst��yDst������ʾ�˸���ͼ��λ�����Ͻǵ�����λ�á���BITBLT�У������������趨Ϊ��ͬ��ֵ�Ա��θ���ͼ�񡣶�춵�һ��BitBlt���У���������������Ϊ0����ͼ���Ƶ���ʾ��������Ͻ�λ�á�

BitBlt������һ��������λԪӳ�������̬���ҽ���̵�����һ�����ֵ��

��ע�⣬BitBlt�Ǵ�ʵ����Ѷ��ʾ�����崫��ͼ�أ������Ǵ�ϵͳ���ܱ�ͼʾ������ͼ���䡣������ƶ�BITBLT�Ӵ���ʹ����ϵͳ���ܱ�ͼʾ�Ƴ�өĻ��Ȼ�����BITBLT�Ӵ��ijߴ�ʹ���ػ�����ʱ��������BITBLT��ʾ��������ʾ���ǹ��ܱ�ͼʾ��һ���֡�BitBlt��ʽ���ٴ�ȡ����ͼ��

��BitBlt��ʽ�У���Դ��Ŀ��װ�����ݿ�����ͬ�����������±�дBITBLT��ʹWM_PAINT����ִ���������ݣ�

BitBlt (hdcClient, 0, 0, cxSource, cySource, 
        		hdcWindow, 0, 0, SRCCOPY) ;
for (y = 0 ; y < cyClient ; y += cySource)
for (x = 0 ; x < cxClient ; x += cxSource)
{
     	if (x > 0 || y > 0)
          			BitBlt (hdcClient, x, y, cxSource, cySource,
                  	hdcClient, 0, 0, SRCCOPY) ;
}

�⽫��ǰ����ʾ��BITBLTһ��������ͬ��Ч����ֻ����ʾ�������ϽDZȽ�ģ����

��BitBlt�ڵ��������������װ�����ݱ��������ݵġ�����ζ����������֮һ�����ǵ�ɫ�ģ��������ߵ�ÿ��ͼ�ض���ͬ��λԪ�����ܶ���֮���������ô˷�����өĻ�ϵ�ijЩͼ�θ��Ƶ�ӡ������

�������ͼ
��

��BitBlt��ʽ�У�Ŀ��ͼ������Դͼ��ijߴ�����ͬ�ģ���Ϊ��ʽֻ������������˵�����Ⱥ͸߶ȡ���������ڸ���ʱ�������ѹ��ͼ��ߴ磬����ʹ��StretchBlt��ʽ��StretchBlt��ʽ���﷨���£�

StretchBlt (	hdcDst, xDst, yDst, cxDst, cyDst, 
            				hdcSrc, xSrc, ySrc, cxSrc, cySrc, dwROP) ;

�˺�ʽ�������������������ڵĺ�ʽ�ͷֱ������Ŀ�ĺ���Դ���ԵĿ��Ⱥ͸߶ȡ�STRETCH��ʽչʾ��StretchBlt��ʽ�����ʽ14-2��ʾ��

 ï¿½ï¿½Ê½14-2  STRETCH
STRETCH.C
/*--------------------------------------------------------------------------
   	STRETCH.C -- 	StretchBlt Demonstration
                						(c) Charles Petzold, 1998
----------------------------------------------------------------------------*/

#include <windows.h>
LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                   PSTR szCmdLine, int iCmdShow)
{
     	static TCHAR 	szAppName [] = TEXT ("Stretch") ;
     	HWND         			hwnd ;
     	MSG          			msg ;
     	WNDCLASS     			wndclass ;

     	wndclass.style         			= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         			= LoadIcon (NULL, IDI_INFORMATION) ;
     	wndclass.hCursor       			= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= (HBRUSH) GetStockObject (WHITE_BRUSH) ;
     	wndclass.lpszMenuName  		= NULL ;
     	wndclass.lpszClassName 		= szAppName ;
     
     	if (!RegisterClass (&wndclass))
     	{
          		MessageBox (	NULL, TEXT ("This program requires Windows NT!"),
                      							szAppName, MB_ICONERROR) ;
          		return 0 ;
     }
     
     hwnd = CreateWindow (szAppName, TEXT ("StretchBlt Demo"), 
                          WS_OVERLAPPEDWINDOW, 
                          CW_USEDEFAULT,
CW_USEDEFAULT,
                          CW_USEDEFAULT,
CW_USEDEFAULT,
                          NULL, NULL, hInstance, NULL) ;
     	ShowWindow (hwnd, iCmdShow) ;
     	UpdateWindow (hwnd) ;

     	while (GetMessage (&msg, NULL, 0, 0))
     	{
          				TranslateMessage (&msg) ;
          				DispatchMessage (&msg) ;
   	}
     	return msg.wParam ;
}

LRESULT CALLBACK WndProc (	HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
     	static int  		cxClient, cyClient, cxSource, cySource ;
     	HDC        			hdcClient, hdcWindow ;
     	PAINTSTRUCT 		ps ;
     
     	switch (message)
     	{
     	case 	WM_CREATE:
          			cxSource = GetSystemMetrics (SM_CXSIZEFRAME) +
                    GetSystemMetrics (SM_CXSIZE) ;

          			cySource = GetSystemMetrics (SM_CYSIZEFRAME) + 
                    GetSystemMetrics (SM_CYCAPTION) ;
          			return 0 ;

     	case 	WM_SIZE:
          			cxClient = LOWORD (lParam) ;
          			cyClient = HIWORD (lParam) ;
          			return 0 ;

     	case 	WM_PAINT:
          			hdcClient = BeginPaint (hwnd, &ps) ;
          			hdcWindow = GetWindowDC (hwnd) ;

          			StretchBlt (hdcClient, 0, 0, cxClient, cyClient,
                    hdcWindow, 0, 0, cxSource, cySource, MERGECOPY) ;

          			ReleaseDC (hwnd, hdcWindow) ;
          			EndPaint (hwnd, &ps) ;
          			return 0 ;

     	case 	WM_DESTROY:
          			PostQuitMessage (0) ;
          			return 0 ;
     }
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}

�˳�ʽֻ�к�����StretchBlt��ʽһ�Σ��������ô˺�ʽ��ϵͳ���ܱ�ͼʾ�����������ʾ������ͼ14-2��ʾ��


��

ͼ14-2 STRETCH��өĻ��ʾ

BitBlt��StretchBlt��ʽ�����е��������С���������߼���λ�ġ����ǵ�����BitBlt��ʽ�ж�����������ͬ��װ�����ݣ���������װ��������Ȼ�ο�ͬһ��ʵ���豸��ȴ����������ͬ��ӳ��ģʽ����ʱ������ʲô����أ���������������������BitBlt�����Ľ�����Եò���ȷ�ˣ�cx��cy���������߼���λ��������ͬ��Ӧ�����Դװ�����ݺ�Ŀ��װ�������еľ����������е�����ͳߴ������ʵ�ʵ�λԪ����֮ǰת��Ϊװ�����ꡣ��Ϊcx��cyֵͬʱ�����Դ��Ŀ��װ�����ݣ����Դ�ֵ����ת��Ϊװ�������Լ��ĵ�λ��

����Դ��Ŀ��װ��������ͬ����������װ�����ݶ�ʹ��MM_TEXTͼ��ģʽʱ��װ�õ�λ�µľ��γߴ�������װ�������л�����ͬ�ģ�Ȼ�����Windows����ͼ�ض�ͼ�ص�ת�������������װ�õ�λ�µľ��γߴ�������װ�������в�ͬʱ����Windows�ͰѴ˹���ת������ͨ�õ�StretchBlt��ʽ��

StretchBltҲ����ˮƽ��ֱ��תͼ�����cxSrc��cxDst��ǣ�ת����װ�õ�λ���ᣩ��ͬ����ôStretchBlt�ͽ���һ���������ҷ�ת����STRETCH��ʽ�У�ͨ����xDst������ΪcxClient����cxDst�����ij�-cxClient�����Ϳ���������һ�㡣���cySrc��cyDst��ͬ����StretchBlt�����·�תͼ��Ҫ��STRETCH��ʽ�в�����һ�㣬�ɽ�yDst������ΪcyClient����cyDst�����ij�-cyClient��

StretchBltģʽ
��

ʹ��StretchBlt������һЩ�����ͼ��С������ص�һЩ�������⡣����չһ������ͼʱ��StretchBlt���븴��ͼ���л��С�����Ŵ�������ԭͼ������������ô�˲�������ɲ�����ͼ����Щʧ�档

���Ŀ�ľ��α���Դ����С����ôStretchBlt����Сͼ��ʱ�ͱ�������У����У����߶��У����У���ͼ�غϲ���һ�У����У�����ɴ˲��������ַ�����������װ��������չģʽ������ѡ������һ�ַ���������ʹ��SetStretchBltMode��ʽ���޸�������ԡ�

SetStretchBltMode (hdc, iMode) ;

iMode��ȡ����ֵ��

  • BLACKONWHITE����STRETCH_ANDSCANS���ڶ��� �����������ͼ�صúϲ���һ��ͼ�أ���ôStretchBlt���ͼ��ִ��һ���߼�AND���㡣�����Ľ����ֻ��ȫ����ԭʼͼ���ǰ�ɫʱ��ͼ�ز�Ϊ��ɫ����ʵ�������Ǻ�ɫͼ�ؿ����˰�ɫͼ�ء�������춰ױ�������Ҫ�Ǻ�ɫ�ĵ�ɫ����ͼ��
    ��
  • WHITEONBLACK��STRETCH_ORSCANS �����������ͼ�صúϲ���һ��ͼ�أ���ôStretchBltִ���߼�OR���㡣�����Ľ����ֻ��ȫ����ԭʼͼ�ض��Ǻ�ɫʱ���Ǻ�ɫ��Ҳ����˵�ɰ�ɫͼ�ؾ�����ɫ��������춺�ɫ��������Ҫ�ǰ�ɫ�ĵ�ɫ����ͼ��
    ��
  • COLORONCOLOR��STRETCH_DELETESCANS StretchBlt�òµ¥µï¿½ï¿½ï¿½ï¿½ï¿½Í¼ï¿½ï¿½ï¿½Ð»ï¿½ï¿½Ð£ï¿½ï¿½ï¿½Ã»ï¿½ï¿½ï¿½Îºï¿½ï¿½ß¼ï¿½ï¿½ï¿½Ï¡ï¿½ï¿½ï¿½ï¿½ï¿½Í¨ï¿½ï¿½ï¿½Ç´ï¿½ï¿½ï¿½ï¿½ï¿½É«ï¿½ï¿½ï¿½ï¿½Í¼ï¿½ï¿½ï¿½ï¿½Ñ·ï¿½ï¿½ï¿½ï¿½ï¿½
    ��
  • HALFTONE��STRETCH_HALFTONE Windows���������������Դ��ɫ������Ŀ�ĵ�ƽ����ɫ���⽫������ɫ������ʹ�ã���ʮ���½�չʾ��һ����
    ��

Windows���������ȡ��Ŀǰ��չģʽ��GetStretchBltMode��ʽ��

λԪӳ�����
��

BITBLT��STRETCH��ʽ�򵥵ؽ���Դ����ͼ���Ƹ���Ŀ�ĵ���ͼ���ڹ�����Ҳ���ܽ��������š����ǰ�SRCCOPY��ΪBitBlt��StretchBlt��ʽ����һ�������Ľ����SRCCOPYֻ����������Щ��ʽ��ʹ�õ�256��λԪӳ������е�һ��������������STRETCH��ʽ����һ�����ʵ�飬Ȼ����ϵͳ���о�λԪӳ�������

������NOTSRCCOPY������SRCCOPY������������һ����λԪӳ������ڸ��Ƶ���ͼʱת������ɫ������ʾ�����Ӵ������е���ɫת������ɫ��ɰ�ɫ����ɫ��ɺ�ɫ����ɫ��ɻ�ɫ��������һ��SRCINVERT�������õ�ͬ��Ч���������һ��BLACKNESS������������һ����������ʾ���򶼽���ɺ�ɫ����WHITENESS��ʹ���ɰ�ɫ��

������һ����������������������StretchBlt���У�

SelectObject (hdcClient, CreateHatchBrush (HS_DIAGCROSS, RGB (0, 0, 0)));
StretchBlt (	hdcClient, 0, 0, cxClient, cyClient,
            				hdcWindow, 0, 0, cxSource, cySource, MERGECOPY) ;

DeleteObject (hdcClient, GetStockObject (WHITE_BRUSH)) ;

��Σ�������ͼ���Ͽ���һ�����εĻ�ˢ������ʲô��

����ǰ��˵����BitBlt��StretchBlt��ʽ���Ǽ򵥵�λԪ�鴫�䡣�˺�ʽʵ������������ͼ���ִ��λԪ������

  • Source ��Դ����ͼ�������ѹ��������б�Ҫ����Ŀ�ľ��εijߴ硣
    ��
  • Destination ��BitBlt��StretchBlt����֮ǰ��Ŀ�ľ��Ρ�
    ��
  • Pattern ��Ŀ��װ��������ѡ���Ŀǰ��ˢ��ˮƽ��ֱ�ظ��Ƶ�Ŀ�ľ��η�Χ�ڡ�
    ��

����Ǹ��Ƶ���Ŀ�ľ����С�

λԪӳ������������ڵ����������Ļ�ͼģʽ�ڸ��������ơ���ͼģʽ����ͼ������Ŀ����ʽ������һ���߾���ϳ�һ��Ŀ�ġ�����֪����16�ֻ�ͼģʽ��Ҳ����˵������е�0��1����ʱ��Ψһ�������Ŀ����0��1����ϡ�

ʹ��BitBlt��StretchBlt��λԪӳ����������������������ϣ��⽫����256��λԪӳ���������256�ַ����������Դ����ͼ��Ŀ�ĵ���ͼ��ͼ������15��λԪӳ������Ѿ�����������һЩ������ʵ�����ܹ�������˵�������壭���Ƕ�����WINGDI.H��ͷ������Ķ�����ֵ������/Platform SDK/Graphics and Multimedia Services/GDI/Raster Operation Codes/Ternary Raster Operations֮�С�

�����Ƶ�15��ROP�������14-4��

��14-4
ͼ����P����1 1 1 1 0 0 0 0

��Դ��s����1 1 0 0 1 1 0 0

Ŀ�ģ�D����1 0 1 0 1 0 1 0

���ֲ��� ROP ���� ����
����� 0 0 0 0 0 0 0 0 0 0x000042 BLACKNESS
  0 0 0 1 0 0 0 1 ~(S ¦ D) 0x1100A6 NOTSRCERASE
  0 0 1 1 0 0 1 1 ~S 0x330008 NOTSRCCOPY
  0 1 0 0 0 1 0 0 S & ~D 0x440328 SRCERASE
  0 1 0 1 0 1 0 1 ~D 0x550009 DSTINVERT
  0 1 0 1 1 0 1 0 P ^ D 0x5A0049 PATINVERT
  0 1 1 0 0 1 1 0 S ^ D 0x660046 SRCINVERT
  1 0 0 0 1 0 0 0 S & D 0x8800C6 SRCAND
  1 0 1 1 1 0 1 1 ~S ¦ D 0xBB0226 MERGEPAINT
  1 1 0 0 0 0 0 0 P & S 0xC000CA MERGECOPY
  1 1 0 0 1 1 0 0 S 0xCC0020 SRCCOPY
  1 1 1 0 1 1 1 0 ¦ D 0xEE0086 SRCPAINT
  1 1 1 1 0 0 0 0 P 0xF00021 PATCOPY
  1 1 1 1 1 0 1 1 ¦  ~S ¦  D 0xFB0A09 PATPAINT
  1 1 1 1 1 1 1 1 1 0xFF0062 WHITENESS

�˱����������ʹ��λԪӳ������dz���Ҫ���������Ӧ����ʱ�����о���

����������У���ROP���롹�е�ֵ�����ݸ�BitBlt��StretchBlt������һ���������ڡ����ơ����е�ֵ��WINGDI.H���塣ROP����ĵ�����Э��װ��������ʽ����λԪӳ���������������0��255֮�����ֵ������ֵ���2�е�ͼ����λԪ��ͬ��������ͼ������Դ����ʾ�ڶ�����Ŀ��֮�����λԪ�����Ľ�������������㡹�а�C�﷨��ʾͼ������Դ��Ŀ�ĵ���Ϸ�ʽ��

Ҫ��ʼ�˽�˱�����򵥵İ취�Ǽٶ���������һ����ɫϵͳ��ÿͼ��1λԪ������0������ɫ��1������ɫ��BLACKNESS�����Ľ���Dz�������Դ��Ŀ�ĺ�ͼ����ʲô��ȫ��Ϊ�㣬���Ŀ�Ľ���ʾ��ɫ�����Ƶأ�WHITENESS�ܵ���Ŀ�ijʰ�ɫ��

���ڼٶ���ʹ��λԪӳ�����PATCOPY���⵼�½��λԪ��ͼ��λԪ��ͬ������������Դ��Ŀ�ĵ���ͼ�����仰˵��PATCOPY�򵥵ؽ�Ŀǰͼ�����Ƹ���Ŀ�ľ��Ρ�

PATPAINTλԪӳ���������һ�������ӵIJ�����������ͬ���ͼ����Ŀ�ĺͷ�ת����Դ֮�����λԪ�����������Դ����ͼ�Ǻ�ɫ��0��ʱ���������ǰ�ɫ��1��������Դ�ǰ�ɫ��1��ʱ��ֻҪͼ����Ŀ��Ϊ��ɫ���������ǰ�ɫ�����仰˵��ֻ����ԴΪ��ɫ��ͼ����Ŀ�Ķ��Ǻ�ɫʱ��������Ǻ�ɫ��

��ɫ��ʾʱÿ��ͼ�ض�ʹ���˶��λԪ��BitBlt��StretchBlt��ʽ��ÿ����ɫλԪ���ֱ��ṩ��λԪ���������磬���Ŀ���Ǻ�ɫ����ԴΪ��ɫ��SRCPAINTλԪӳ�������Ŀ�ı�����ɫ��ע�⣬����ʵ���ǰ���ʾ���ڴ����λԪִ�еġ���ЩλԪ����Ӧ����ɫȡ�����ʾ���ĵ�ɫ�̵��趨��Windows����˴˲������Ա�λԪӳ������ܴﵽ��Ԥ�ƵĽ����������������޸��˵�ɫ�̣��ҽ��ڵ�ʮ�������ۣ���λԪӳ������������޷�Ԥ�ϵĽ����

��Ҫ�õ�λԪӳ������Ϻõ�Ӧ�ó�ʽ����μ���������ġ��Ǿ��ε���ͼͼ��һ�ڡ�

ͼ��Blt
��

����BitBlt��StretchBlt���⣬Windows������һ����ΪPatBlt ����pattern block transfer��ͼ���鴫�䡹���ĺ�ʽ������������blt����ʽ����򵥵ġ���BitBlt��StretchBlt��ͬ����ֻʹ��һ��Ŀ��װ�����ݡ�PatBlt�﷨�ǣ�

PatBlt (hdc, x, y, cx, cy, dwROP) ;

x��y��cx��cy����λ��߼���λ���߼��㣨x,y��ָ���˾��ε����Ͻǡ����ο�Ϊcx��λ����Ϊcy��λ������PatBlt�޸ĵľ�������PatBlt�ڻ�ˢ��Ŀ��װ��������ִ�е��߼�������dwROP�����������˲�����ROP������Ӽ���Ҳ����˵��������ֻʹ����Щ��������ԴĿ��װ�����ݵ�ROP���롣�±��г���PatBlt֧Ԯ��16��λԪӳ�������

��14-5
ͼ����P����1 1 0 0

Ŀ�ģ�D����1 0 1 0

���ֲ��� ROP ���� ����
����� 0 0 0 0 0 0x000042 BLACKNESS
  0 0 0 1 ~(P | D) 0x0500A9  
  0 0 1 0 ~P & D 0x0A0329  
  0 0 1 1 ~P 0x0F0001  
  0 1 0 0 P & ~D 0x500325  
  0 1 0 1 ~D 0x550009 DSTINVERT
  0 1 1 0 P ^ D 0x5A0049 PATINVERT
  0 1 1 1 ~(P & D) 0x5F00E9  
  1 0 0 0 P & D 0xA000C9  
  1 0 0 1 ~(P ^ D) 0xA50065  
  1 0 1 0 D 0xAA0029  
  1 0 1 1 ~P | D 0xAF0229  
  1 1 0 0 P 0xF00021 PATCOPY
  1 1 0 1 P | ~D 0xF50225  
  1 1 1 0 P | D 0xFA0089  
  1 1 1 1 1 0xFF0062 WHITENESS

�����г���PatBltһЩ��������;������뻭һ����ɫ���Σ����ɺ���

PatBlt (hdc, x, y, cx, cy, BLACKNESS) ;

Ҫ��һ����ɫ���Σ�����

PatBlt (hdc, x, y, cx, cy, WHITENESS) ;

��ʽ

PatBlt (hdc, x, y, cx, cy, DSTINVERT) ;

��춸ı���ε���ɫ�����Ŀǰװ��������ѡ����WHITE_BRUSH����ô��ʽ

PatBlt (hdc, x, y, cx, cy, PATINVERT) ;

Ҳ�ı���Ρ�

�������ٴκ���FillRect��ʽ���û��ʳ���һ����������

FillRect (hdc, &rect, hBrush) ;

FillRect��ʽ��ͬ����д��룺

hBrush = SelectObject (hdc, hBrush) ;
PatBlt (hdc, 	rect.left, rect.top,
             				rect.right - rect.left,
             				rect.bottom - rect.top, PATCOPY) ;
SelectObject (hdc, hBrush) ;

ʵ���ϣ��˳�ʽ����Windows���ִ��FillRect��ʽ�Ķ��������������

InvertRect (hdc, &rect) ;

Windows����ת���ɺ�ʽ��

PatBlt (hdc, 	rect.left, rect.top,
             				rect.right - rect.left,
             				rect.bottom - rect.top, DSTINVERT) ;

�ڽ���PatBlt��ʽ���﷨ʱ����˵���㣨x,y��ָ���˾��ε����Ͻǣ����Ҵ˾��ο���Ϊcx��λ���߶�Ϊcy��λ��������������ȫ��ȷ��BitBlt��PatBlt��StretchBlt������ʵ�GDI��ͼ��ʽ�����Ǹ��ݴ�һ���Dz�õ��߼����Ⱥ͸߶���ָ���߼�ֱ�����ꡣ���α߿��õ�����������GDI��ͼ��ʽ��Ҫ��������ϽǺ����½ǵ�������ָ�����ꡣ���MM_TEXTӳ��ģʽ�����潲����PatBlt����������ȷ�ġ�Ȼ����춹��Ƶ�ӳ��ģʽ��˵���Ͳ���ȷ�������ʹ��һ��cx��cyֵ����ô�㣨x,y�����Ǿ��ε����½ǡ����ϣ���㣨x,y���Ǿ��ε����Ͻǣ���ôcy����������Ϊ���εĸ��߶ȡ�

��������ȷ����PatBlt�޸���ɫ�ľ��ν�ͨ��cx�ľ���ֵ����߼����ȣ�ͨ��cy�ľ���ֵ����߼��߶ȡ����������������Ǹ�ֵ�����߼��㣨x, y���ͣ�x + cx, y + cy�������������Ƕ����˾��Ρ����ε����Ͻ�ͨ�����PatBlt�޸ĵ��������Ͻ��򳬳��˾��εķ�Χ������ӳ��ģʽ��cx��cy�����ķ��ţ��������Ͻǵĵ�ӦΪ��x, y������x, y + cy������x + cx, y�����ߣ�x + cx, y + cy����

�����MM_LOENGLISH�趨��ӳ��ģʽ��������������ʾ�������Ͻǵ�һС����������ʹ��PatBlt��������ʹ��

PatBlt (hdc, 0, 0, 100, -100, dwROP) ;

��

PatBlt (hdc, 0, -100, 100, 100, dwROP) ;

��

PatBlt (hdc, 100, 0, -100, -100, dwROP) ;

��

PatBlt (hdc, 100, -100, -100, 100, dwROP) ;

��PatBlt�趨��ȷ���������׵ķ����ǽ�x��y��Ϊ�������Ͻǡ����ӳ��ģʽ����y�����������Ͼ�����ʾ�����ӣ���ô��ʹ�ø���cy���������ӳ��ģʽ����x�����������ӣ����������ã�������Ҫʹ�ø���cx������

GDI����ͼ���
��

���ڱ���ǰ�����ᵽ��Windows��1.0��ʼ��֧ԮGDI����ͼ�������Ϊ��Windows 3.0������װ���޹ص���ͼ��GDI����ͼ�����ʱҲ��Ϊװ����ص���ͼ������DDB���Ҿ�����ȫ������device-dependent bitmap��ȫ�ģ���Ϊ������ȥ��device-independent bitmap���ơ���дDDB���һЩ����Ϊ���Ǻ����װ�����DIB��������

�Գ�ʽд������˵���ִ�����ֲ�ͬ��̬�ĵ���ͼ��Windows 3.0��ʼ�͸�Ϊ���ҡ������о����Windows��ʽд���߶�����׼ȷ������DIB��DDB֮��Ĺ�ϵ�������±����Windows 3.0�汾���ܳ���������⣩����Ȼ��DIB��DDB�����෽������صģ�DIB��DDB���໥ת��������ת�������лᶪʧһЩ��Ѷ����Ȼ��DIB��DDB�Dz������໥�滻�ģ����Ҳ��ܼ򵥵�ѡ��һ�ַ�������ʾͬһ���������ϡ�

��������ܼ���˵DIBһ�������DDB��������ͻ�ܷ����ˡ�����ʵ��������ˣ�DDB����Windows�а���������Ҫ��ɫ�����������ں���ʽִ�б��ֺû�ʱ��

����DDB
��

DDB��Windowsͼ��װ�ý����ͼ�����֮һ�����л�������ͼ�ʡ���ˢ�����塢metafile�͵�ɫ�̣�����Щͼ�����������GDIģ���ڲ�����Ӧ�ó�ʽ�����Դ������ֵķ�ʽ���á������Խ�DDB���Ŵ�����һ��HBITMAP����handle to a bitmap������ͼ���š�����̬�ı����У����磺

HBITMAP hBitmap ;

Ȼ��ͨ������DDB������һ����ʽ����ô��ţ����磺CreateBitmap����Щ��ʽ���ò���ʼ��GDI�������е�һЩ�������������춵���ͼ����Ѷ���Լ�ʵ�ʵ���ͼλԪ����Ѷ��Ӧ�ó�ʽ����ֱ�Ӵ�ȡ��μ����塣����ͼ��װ�������޹ء�����ʽʹ�������ͼ���ᣬ��Ҫ�����μ����壺

DeleteObject (hBitmap) ;

�����ʽִ��ʱ��ʹ����DDB����ô��ʽ��ֹʱ���������������IJ�����

CreateBitmap��ʽ�÷����£�

hBitmap = CreateBitmap (cx, cy, cPlanes, cBitsPixel, bits) ;

ǰ���������ǵ���ͼ�Ŀ��Ⱥ͸߶ȣ���ͼ��Ϊ��λ������������������ɫ�����Ŀ�����ĸ�������ÿͼ�ص�λԪ���������������ָ��һ�����ض���ɫ��ʽ��ŵ�λԪ���е�ָ�꣬�����ڴ����������ʼ����DDB��ͼ�������������һ�����е�ͼ������ʼ��DDB�����Խ�����һ��������ΪNULL�����������ǿ����趨��DDB��ͼ�ص����ݡ�

ʹ�ô˺�ʽʱ��WindowsҲ����������ϲ�����ض���̬GDI����ͼ��������磬������ϣ������ͼ��7��ͼ�ء���9��ͼ�ء�5��?ɫλԪ�棬����ÿ��ͼ��ռ3λԪ����ֻ��Ҫִ������IJ�����

hBitmap = CreateBitmap (7, 9, 5, 3, NULL) ;

��ʱWindows��úø���һ����Ч�ĵ���ͼ���š�

�ڴ˺�ʽ�����ڼ䣬Windows�����������ݸ���ʽ����Ѷ����Ϊͼ��λԪ���ü����塣���Եļ����Ǵ˵���ͼ��Ҫ7��9��5��3����945λԪ������Ҫ��118��λԪ�黹�༸��λԪ��

Ȼ����WindowsΪ����ͼ���úü��������ᣬÿ��ͼ�ض�ռ�����������λԪ�飬����

iWidthBytes = 2 * ((cx * cBitsPixel + 15) / 16) ;

����C��ʽд���߸������д�ɣ�

iWidthBytes = (cx * cBitsPixel + 15) & ~15) >> 3 ;

��ˣ�ΪDDB���õļ�������ǣ�

iBitmapBytes = cy * cPlanes * iWidthBytes ;

�����У�iWidthBytesռ4λԪ�飬iBitmapBytesռ180λԪ�顣

���ڣ�֪��һ�ŵ���ͼ��5����ɫλԪ�棬ÿͼ��ռ3����ɫλ��ʲô���������Ǽ����ˣ����������ܰ�������һ��ϰ����ҵ����Ȼ����GDI�ڲ�������Щ�����壬��������Щ��������һ���ṹ�����ݣ����������ŵ���ͼ��ȫ�������κ����õ���������

ʵ���ϣ�������������̬�IJ���������CreateBitmap��

  • cPlanes��cBitsPixel�����1����ʾ��ɫ����ͼ��������
    ��
  • cPlanes��cBitsPixel�����ij���ض�װ�����ݵ�ֵ��������ʹ��PLANES��BITSPIXEL��������GetDeviceCaps��ʽ��á�
    ��

����ʵ������£���ֻ���ڵ�һ������º���CreateBitmap����춵ڶ����������������CreateCompatibleBitmap�������⣺

hBitmap = CreateCompatibleBitmap (hdc, cx, cy) ;

�˺�ʽ������һ�����豸���ݵĵ���ͼ�����豸��װ�����ݴ����ɵ�һ������������CreateCompatibleBitmap��װ�����ݴ��������GetDeviceCaps��Ѷ��Ȼ�Ὣ����Ѷ���ݸ�CreateBitmap��������ʵ�ʵ�װ����������ͬ�ļ�������֮֯�⣬DDB��װ������û��������ϵ��

CreateDiscardableBitmap��ʽ��CreateCompatibleBitmap�IJ�����ͬ�����ҹ�������ͬ�������ڵ�Windows�汾�У�CreateDiscardableBitmap�����ĵ���ͼ�����ڼ��������ʱ��Windows����Ӽ������������Ȼ���ʽ���ؽ�����ͼ���ϡ�

����������ͼ������ʽ��CreateBitmapIndirect��

hBitmap CreateBitmapIndirect (&bitmap) ;

����bitmap��BITMAP��̬�Ľṹ��BITMAP�ṹ�������£�

typedef struct _tagBITMAP
{
     	LONG   		bmType ;        		// set to 0
     	LONG   		bmWidth ;       		// width in pixels
     	LONG   		bmHeight ;      		// height in pixels
     	LONG   		bmWidthBytes ;  		// width of row in bytes
     	WORD   		bmPlanes ;      		// number of color planes
     	WORD   		bmBitsPixel ;   		// number of bits per pixel
     	LPVOID	bmBits ;        			// pointer to pixel bits
}
BITMAP, * PBITMAP ;

�ں���CreateBitmapIndirect��ʽʱ��������Ҫ�趨bmWidthBytes��λ��Windows��Ϊ�����㣬��Ҳ���Խ�bmBits��λ�趨ΪNULL�������趨Ϊ��ʼ������ͼʱ�õ�ͼ��λԪλַ��

GetObject��ʽ��Ҳʹ��BITMAP�ṹ�����ȶ���һ��BITMAP��̬�Ľṹ��

BITMAP bitmap ;

�����к�ʽ���£�

GetObject (hBitmap, sizeof (BITMAP), &bitmap) ;

Windows���õ���ͼ��Ѷ���BITMAP�ṹ����λ��������bmBits��λ���NULL��

������Ӧ����DeleteObject�������ʽ�ڽ��������е���ͼ��

����ͼλԪ
��

��CreateBitmap��CreateBitmapIndirect�������豸���GDI����ͼ���ʱ�������Ը�����ͼͼ��λԪָ��һ��ָ�ꡣ������Ҳ�����õ���ͼά��δ��ʼ����״̬���ڽ�������ͼ���ᣬWindows���ṩ������ʽ����ò��趨ͼ��λԪ��

Ҫ�趨ͼ��λԪ������У�

SetBitmapBits (hBitmap, cBytes, &bits) ;

GetBitmapBits��ʽ����ͬ���﷨��

GetBitmapBits (hBitmap, cBytes, &bits) ;

����������ʽ�У�cBytesָ��Ҫ���Ƶ�λԪ������bits������cBytes��С�Ļ�������

DDB�е�ͼ��λԪ�Ӷ��п�ʼ���С�����ǰ��˵����ÿ�е�λԪ��������ż��������֮�⣬ûʲô��˵�����ˡ��������ͼ�ǵ�ɫ�ģ�Ҳ����˵����1��λԪ�沢��ÿ��ͼ��ռ1λԪ����ÿ��ͼ�ز���1����0��ÿ������ߵ�ͼ���DZ��е�һ��λԪ�����λԪ��λԪ�������ڱ��µ����潲�������ʾ��ɫDDB֮�ᣬ����һ����ɫ��DDB��

��춷ǵ�ɫ����ͼ��Ӧ�����������Ҫ֪��ͼ��λԪ�����״�������磬�ٶ���8λ��ɫ��VGA��ִ��Windows�������Ժ���CreateCompatibleBitmap��ͨ��GetDeviceCaps�����ܹ�ȷ����������һ����1����ɫλԪ���ÿͼ��8λԪ���豸��һ��λԪ�鴢��һ��ͼ�ء�����ͼ��ֵ0x37��ʲô��˼�أ���������ij����ɫ����������ʲô��ɫ�أ�

ͼ��ʵ���ϲ����漰�κι̶�����ɫ����ֻ��һ��ֵ��DDBû����ɫ��������Ĺؼ���춣���DDB��ʾ��өĻ��ʱ��ͼ�ص���ɫ��ʲô�����϶���ij����ɫ����������ʲô��ɫ�أ���ʾ��ͼ�ؽ�������ʾ���ϵĵ�ɫ�̲鿴�����0x37����ֵ������RGB��ɫ�йء������������������װ�������ԡ�

��������Ҫֻ��Ϊ���Dz�֪��ͼ��ֵ�ĺ��壬�ͼٶ��ǵ�ɫDDBû�á����ǽ���Ҫ��һ�����ǵ���;����һ�£����ǽ�����SetBitmapBits��GetBitmapBits��ʽ����α������õ�SetDIBits��GetDIBits��ʽ��ȡ���ġ�

��ˣ������Ĺ����������ģ���Ҫ��CreateBitmap��CreateBitmapIndirect��SetBitmapBits���趨��ɫDDB��λԪ����ֻ�ܰ�ȫ��ʹ����Щ��ʽ���趨��ɫDDB��λԪ����������ں���GetBitmapBits�ڼ䣬��������ͬ��ʽ��DDB�л��λԪ����ô��Щ�������⡣��

�ڼ���֮ǰ������������һ��SetBitmapDimensionEx��GetBitmapDimensionEx��ʽ����Щ��ʽ�����趨���ͻ�ã�����ͼ�IJ����ߴ磨��0.1����Ϊ��λ������Щ��Ѷ�����ͼ������һ�𴢴���GDI�У���������κβ�������ֻ������DDB��ϵ��һ�������ߴ��ʶ��

������װ������
��

���DZ���������һ�������Ǽ�����װ�����ݡ�����Ҫ�ü�����װ������������GDI����ͼ�����

ͨ����װ������ָ���������ͼ������豸��������Ѷ��ʾ������ӡ����������װ��������ʽ��������װ������ֻλ춼������У�������������ͼ������豸��������˵��ָ���������豸�����ݡ���

Ҫ����һ��������װ�����ݣ�������������ʵ���豸��װ�����ݴ��š������hdc����ô��������������������������װ�����ݣ�

hdcMem = CreateCompatibleDC (hdc) ;

ͨ������ʽ�ĺ��б�����򵥡��������������ΪNULL����ôWindows������һ������Ѷ��ʾ�������ݵļ�����װ�����ݡ�Ӧ�ó�ʽ�������κμ�����װ���������ն�ͨ������DeleteDC�������

������װ��������һ����ʵ��λԪӳ���豸��ͬ����ʾƽ�档�������������ʾƽ��dz�С����ɫ��1ͼ�ؿ���1ͼ�ظߡ���ʾƽ����ǵ���1λԪ��

��Ȼ����1λԪ����ʾƽ�棬������������Ĺ����������һ������������ʾƽ�档������ͨ����һ��GDI����ͼ���ѡ��������װ���������������������磺

SelectObject (hdcMem, hBitmap) ;

�˺�ʽ���������ʡ���ˢ�����塢����͵�ɫ��ѡ��װ�����ݵĺ�ʽ��ͬ��Ȼ����������װ��������������ѡ������ͼ��Ψһһ��װ��������̬���������Ҫ����Ҳ���Խ�����GDI���ѡ��������װ�����ݡ���

ֻ��ѡ��������װ�����ݵĵ���ͼ�ǵ�ɫ�ģ������������װ�����������豸����ͬ��ɫ����֯ʱ��SelectObject�Ż������á���Ҳ�ǽ��������DDB��������5��λԪ�棬��ÿͼ��3λԪ��û���õ�ԭ��

���������������SelectObject�������ᣬDDB���Ǽ�����װ�����ݵ���ʾƽ�档����ʵ��װ�����ݵ�ÿ���������������������춼�����װ�����ݡ����磬�����GDI��ͼ��ʽ�ڼ�����װ�������л�ͼ����ôͼ�񽫻��ڵ���ͼ�ϡ����Ƿdz����õġ������Խ�������װ��������Ϊ��Դ������Ѷװ��������ΪĿ��������BitBlt�����������ʾ���ϻ��Ƶ���ͼ�ķ������������Ѷװ��������Ϊ��Դ���Ѽ�����װ��������ΪĿ�ģ���ô����BitBlt�ɽ�өĻ�ϵ�һЩ���ݸ��Ƹ�����ͼ�����ǽ�������Щ���ǿ��ܵġ�

�������ͼ��Դ
��

���˸��ָ����ĵ���ͼ������ʽ���⣬���GDI����ͼ������ŵ���һ���������Ǻ���LoadBitmap��ʽ��ʹ�ô˺�ʽ�������ص��ĵ���ͼ��ʽ���ڳ�ʽ�У���ֻ��򵥵ذ���Դ����������ͼ�����뽨��ͼʾ���߻����α�ķ������ơ�LoadBitmap��ʽ���﷨��LoadIcon��LoadCursor��ͬ��

hBitmap = LoadBitmap (hInstance, szBitmapName) ;

���������ϵͳ����ͼ����ô����һ��������ΪNULL����Щ��ͬ�ĵ���ͼ��Windows�Ӿ����棨����رշ���͹�ѡ��ǣ���һС���֣����ǵ�ʶ��������ĸOBM��ʼ���������ͼ������ʶ���ֶ���������������ϵ����ô�ڶ��������Ϳ���ʹ��MAKEINTRESOURCE�޼�����LoadBitmap��������е���ͼ����Ӧ��DeleteObject�����

�������ͼ��Դ�ǵ�ɫ�ģ���ô��LoadBitmap���صĴ��Ž�ָ��һ����ɫ�ĵ���ͼ������������ͼ��Դ���ǵ�ɫ����ô��LoadBitmap���صĴ��Ž�ָ��һ��GDI����ͼ������������ִ�г�ʽ����Ѷ��ʾ������ͬ��ɫ����֯����ˣ�����ͼʼ������Ѷ��ʾ�����ݣ���������ѡ������Ѷ��ʾ�����ݵļ�����װ�������С�����LoadBitmap�����ᣬ�Ͳ��õ����κ�ɫ��ת���������ˡ�����һ���У����Ǿ�֪��LoadBitmap�ľ���������ʽ�ˡ�

��ʽ14-3��ʾ��BRICKS1��ʽʾ��������һС�ŵ�ɫ����ͼ��Դ�ķ������˵���ͼ��������ש�飬������ˮƽ�ʹ�ֱ�ظ�ʱ������שǽ�����ˡ�

 ï¿½ï¿½Ê½14-3  BRICKS1
BRICKS1.C
/*--------------------------------------------------------------------------
   	BRICKS1.C -- LoadBitmap Demonstration
                						(c) Charles Petzold, 1998
----------------------------------------------------------------------------*/

#include <windows.h>
LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    		PSTR szCmdLine, int iCmdShow)
{
     	static TCHAR 	szAppName [] = TEXT ("Bricks1") ;
     	HWND         			hwnd ;
     	MSG          			msg ;
     	WNDCLASS     			wndclass ;

     	wndclass.style         			= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         			= LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       			= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= (HBRUSH) GetStockObject (WHITE_BRUSH) ;
     	wndclass.lpszMenuName  		= NULL ;
     	wndclass.lpszClassName 		= szAppName ;
     
     	if (!RegisterClass (&wndclass))
     	{
          		MessageBox (NULL, TEXT ("This program requires Windows NT!"),
                      					szAppName, MB_ICONERROR) ;
          		return 0 ;
     }
     
     	hwnd = CreateWindow (	szAppName, TEXT ("LoadBitmap Demo"), 
                          		  WS_OVERLAPPEDWINDOW, 
                          		  CW_USEDEFAULT, CW_USEDEFAULT,
                          		  CW_USEDEFAULT, CW_USEDEFAULT,
                          		  NULL, NULL, hInstance, NULL) ;

     	ShowWindow (hwnd, iCmdShow) ;
     	UpdateWindow (hwnd) ;

     	while (GetMessage (&msg, NULL, 0, 0))
     	{
          			TranslateMessage (&msg) ;
          			DispatchMessage (&msg) ;
     	}
     	return msg.wParam ;
}

LRESULT CALLBACK WndProc (	HWND hwnd, UINT message, WPARAM wParam,LPARAM lParam)
{
     	static HBITMAP hBitmap ;
     	static int     			cxClient, cyClient, cxSource, cySource ;
     	BITMAP         			bitmap ;
     	HDC            			hdc, hdcMem ;
     	HINSTANCE      			hInstance ;
     	int            			x, y ;
     	PAINTSTRUCT    			ps ;
     
     	switch (message)
     	{
     	case 	WM_CREATE:
          			hInstance = ((LPCREATESTRUCT) lParam)->hInstance ;

          			hBitmap = LoadBitmap (hInstance, TEXT ("Bricks")) ;

          			GetObject (hBitmap, sizeof (BITMAP), &bitmap) ;

          			cxSource = bitmap.bmWidth ;
          			cySource = bitmap.bmHeight ;

          			return 0 ;

     	case 	WM_SIZE:
          			cxClient = LOWORD (lParam) ;
          			cyClient = HIWORD (lParam) ;
          			return 0 ;

     	case 	WM_PAINT:
          			hdc = BeginPaint (hwnd, &ps) ;

          			hdcMem = CreateCompatibleDC (hdc) ;
          			SelectObject (hdcMem, hBitmap) ;

          			for (y = 0 ; y < cyClient ; y += cySource)
          			for (x = 0 ; x < cxClient ; x += cxSource)
          			{
               		BitBlt (hdc, x, y, cxSource, cySource, hdcMem, 0, 0, SRCCOPY) ;
          }

          			DeleteDC (hdcMem) ;
          			EndPaint (hwnd, &ps) ;
          			return 0 ;
     	
	case 	WM_DESTROY:
          			DeleteObject (hBitmap) ;
          			PostQuitMessage (0) ;
          			return 0 ;
     	}
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}
 BRICKS1.RC ��ժ¼��
//Microsoft Developer Studio generated resource script.
#include "resource.h"
#include "afxres.h"

/////////////////////////////////////////////////////////////////////////////
// Bitmap
BRICKS                  			BITMAP  DISCARDABLE     "Bricks.bmp"
BRICKS.BMP


��

��Visual C++ Developer Studio�н�������ͼʱ��Ӧָ������ͼ�ĸ߶ȺͿ��ȶ���8��ͼ�أ��ǵ�ɫ�������ǡ�Bricks����BRICKS1��ʽ��WM_CREATEѶϢ�����ڼ������˵���ͼ����GetObject��ȷ������ͼ��ͼ�سߴ磨�Ա㵱����ͼ����8ͼ�ؼ���ʱ��ʽ���ܼ��������������ᣬBRICKS1����WM_DESTROYѶϢ��ɾ���˵���ͼ��

��WM_PAINTѶϢ�����ڼ䣬BRICKS1������һ������ʾ�����ݵļ�����װ�����ݣ�����ѡ���˵���ͼ��Ȼ���ǴӼ�����װ�����ݵ���ʾ����װ������һϵ�е�BitBlt��ʽ���У���ɾ��������װ�����ݡ�ͼ14-3��ʾ�˳�ʽ��ִ�н����

˳��˵һ�£�Developer Studio������BRICKS.BMP������һ��װ���޹ص���ͼ������������Developer Studio�ڽ���һ����ɫ��BRICKS.BMP�����������Լ�ѡ����ɫ�������ұ�֤һ�й���������

���ǿ���DIB��ת��������Ѷ��ʾ�����ݵ�GDI����ͼ��������ǽ�����һ�¿���������β����ġ�


��

ͼ14-3 BRICKS1��өĻ��ʾ

��ɫ����ͼ��ʽ
��

������ڴ���С�鵥ɫͼ����ô�����ذ����ǵ�����Դ�����������ɫ����ͼ�����ͬ����ɫλԪ�ĸ�ʽ��Լ�һЩ�����Ҽ�����ȫ������Ҫ������ͼ���з�����������磬�ٶ���Ҫ������ͼ��ʾ�ĵ���ͼ��


��

����д��һϵ�е�λԪ��0������ɫ��1������ɫ������ЩλԪֱ�Ӷ�Ӧ����񡣴����Ҷ���ЩλԪ�����ܸ�ÿ8λԪ������һ��ʮ����λԪ��λԪ��ֵ���������ͼ�Ŀ��Ȳ���16�ı�������λԪ����ұ�������䣬�Եõ�ż����λԪ�飺

0 1 0 1 0 0 0 1 0 1 1 1 0 1 1 1 0 0 0 1 = 51 77 10 00
0 1 0 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 0 1 = 57 77 50 00
0 0 0 1 0 0 1 1 0 1 1 1 0 1 1 1 0 1 0 1 = 13 77 50 00
0 1 0 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 0 1 = 57 77 50 00
0 1 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 = 51 11 10 00

ͼ�ؿ�Ϊ20��ɨ���߸�Ϊ5��λԪ���Ϊ4����������������������趨�˵���ͼ��BITMAP�ṹ��

static BITMAP bitmap    		= { 0, 20, 5, 4, 1, 1 } ;

���ҿ��Խ�λԪ������BYTE�����У�

static BYTE  bits [] 	= { 	0x51, 0x77, 0x10, 0x00,
                         		0x57, 0x77, 0x50, 0x00,
                				0x13, 0x77, 0x50, 0x00,
                         	    0x57, 0x77, 0x50, 0x00,
                                0x51, 0x11, 0x10, 0x00 } ;

��CreateBitmapIndirect����������ͼ��Ҫ��������������

bitmap.bmBits = (PSTR) bits ; 
hBitmap = CreateBitmapIndirect (&bitmap) ;

��һ�ַ����ǣ�

hBitmap = CreateBitmapIndirect (&bitmap) ;
SetBitmapBits (hBitmap, sizeof bits, bits) ;

��Ҳ������һ����������������ͼ��

hBitmap = CreateBitmap (20, 5, 1, 1, bits) ;

�ڳ�ʽ14-4��ʾ��BRICKS2��ʽ���ô˼���ֱ�ӽ�����ש�����ͼ����û��ʹ����Դ��

 ï¿½ï¿½Ê½14-4  BRICKS2
BRICKS2.C
/*--------------------------------------------------------------------------
   	BRICKS2.C -- 	CreateBitmap Demonstration
                						(c) Charles Petzold, 1998
---------------------------------------------------------------------------*/

#include <windows.h>
LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    PSTR szCmdLine, int iCmdShow)
{
     	static TCHAR 	szAppName [] = TEXT ("Bricks2") ;
     	HWND         			hwnd ;
     	MSG          			msg ;
     	WNDCLASS     			wndclass ;

     	wndclass.style         			= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         			= LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       			= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= (HBRUSH) GetStockObject (WHITE_BRUSH) ;
     	wndclass.lpszMenuName  		= NULL ;
     	wndclass.lpszClassName 		= szAppName ;
     
     	if (!RegisterClass (&wndclass))
     	{
          		MessageBox (	NULL, TEXT ("This program requires Windows NT!"),
                      		szAppName, MB_ICONERROR) ;
          		return 0 ;
     	}

     		hwnd = CreateWindow (szAppName, TEXT ("CreateBitmap Demo"), 
                        WS_OVERLAPPEDWINDOW, 
                        CW_USEDEFAULT, CW_USEDEFAULT,
                        CW_USEDEFAULT, CW_USEDEFAULT,
                        NULL, NULL, hInstance, NULL) ;

     	ShowWindow (hwnd, iCmdShow) ;
     	UpdateWindow (hwnd) ;

     	while (GetMessage (&msg, NULL, 0, 0))
   	{
          			TranslateMessage (&msg) ;
          			DispatchMessage (&msg) ;
     	}
     	return msg.wParam ;
}

LRESULT CALLBACK WndProc (	HWND hwnd, UINT message, WPARAM wParam,LPARAM lParam)
{
     	static BITMA		Pbitmap = { 	0, 8, 8, 2, 1, 1 } ;
     	static BYTE			bits [8][2]={ 	0xFF, 0, 0x0C, 0, 0x0C, 0, 0x0C, 0,
                                    		0xFF, 0, 0xC0, 0, 0xC0, 0, 0xC0, 0 } ;
     	static HBITMAP hBitmap ;
     	static int     			cxClient, cyClient, cxSource, cySource ;
     	HDC            			hdc, hdcMem ;
     	int            			x, y ;
     	PAINTSTRUCT    			ps ;
     
     	switch (message)
     	{
     	case 	WM_CREATE:
          			bitmap.bmBits = bits ;
          			hBitmap 	  = CreateBitmapIndirect (&bitmap) ;
          			cxSource 	  = bitmap.bmWidth ;
          			cySource 	  = bitmap.bmHeight ;
          			return 0 ;

     	case 	WM_SIZE:
          			cxClient = LOWORD (lParam) ;
          			cyClient = HIWORD (lParam) ;
          			return 0 ;

     	case 	WM_PAINT:
          			hdc = BeginPaint (hwnd, &ps) ;

          			hdcMem = CreateCompatibleDC (hdc) ;
          			SelectObject (hdcMem, hBitmap) ;

          			for (y = 0 ; y < cyClient ; y += cySource)
          			for (x = 0 ; x < cxClient ; x += cxSource)
          			{
               				BitBlt (hdc, x, y, cxSource, cySource, hdcMem, 0, 0, SRCCOPY) ;
          			}

          			DeleteDC (hdcMem) ;
          			EndPaint (hwnd, &ps) ;
          			return 0 ;

     	case 	WM_DESTROY:
          			DeleteObject (hBitmap) ;
          			PostQuitMessage (0) ;
          			return 0 ;
     	}
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}

�����Գ���һ�����ɫ����ͼ���Ƶ���������磬���������Ѷ��ʾ��ִ����256ɫģʽ�£���ô�����Ը��ݱ�14-2�������ɫש��ÿ��ͼ�ء�����������ʽִ����������ʾģʽ��ʱ���˳�ʽ�벻�����á���װ���޹ط�ʽ������ɫ����ͼ��Ҫʹ���������۵�DIB��

����ͼ�еĻ�ˢ
��

BRICKSϵ�е�����һ��ר����BRICKS3�����ʽ14-5��ʾ��է���˳�ʽ�������ܻ������ָо�����ʽ������ȥ���أ�

 ï¿½ï¿½Ê½14-5  BRICKS3
BRICKS3.C
/*-------------------------------------------------------------------------
   	BRICKS3.C -- CreatePatternBrush Demonstration
                						(c) Charles Petzold, 1998
---------------------------------------------------------------------------*/

#include <windows.h>
LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    		PSTR szCmdLine, int iCmdShow)
{
     	static TCHAR		szAppName [] = TEXT ("Bricks3") ;
     	HBITMAP      		hBitmap ;
     	HBRUSH       		hBrush ;
     	HWND         		hwnd ;
     	MSG          		msg ;
     	WNDCLASS     		wndclass ;

     	hBitmap = LoadBitmap (hInstance, TEXT ("Bricks")) ;
     	hBrush = CreatePatternBrush (hBitmap) ;
     	DeleteObject (hBitmap) ;

     	wndclass.style         			= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         			= LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       			= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= hBrush ; 
     	wndclass.lpszMenuName  		= NULL ;
     	wndclass.lpszClassName 		= szAppName ;
     
   	if (!RegisterClass (&wndclass))
     	{
          		MessageBox (	NULL, TEXT ("This program requires Windows NT!"),
                szAppName, MB_ICONERROR) ;
          		return 0 ;
     }
     
     	hwnd = CreateWindow (szAppName, TEXT ("CreatePatternBrush Demo"), 
                          	WS_OVERLAPPEDWINDOW, 
                          	CW_USEDEFAULT, CW_USEDEFAULT,
                          	CW_USEDEFAULT, CW_USEDEFAULT,
                          	NULL, NULL, hInstance, NULL) ;

     	ShowWindow (hwnd, iCmdShow) ;
     	UpdateWindow (hwnd) ;

     	while (GetMessage (&msg, NULL, 0, 0))
     	{
          		TranslateMessage (&msg) ;
          		DispatchMessage (&msg) ;
     }

     	DeleteObject (hBrush) ;
     	return msg.wParam ;
}

LRESULT CALLBACK WndProc (	HWND hwnd, UINT message, WPARAM wParam,LPARAM lParam)
{
     	switch (message)
     	{
     	case 	WM_DESTROY:
          			PostQuitMessage (0) ;
          			return 0 ;
     }
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}
 BRICKS3.RC ��ժ¼��
//Microsoft Developer Studio generated resource script.
#include "resource.h"
#include "afxres.h"

/////////////////////////////////////////////////////////////////////////////
// Bitmap
BRICKS                  			BITMAP  DISCARDABLE     "Bricks.bmp"

�˳�ʽ��BRICKS1ʹ��ͬһ��BRICKS.BMP�����������Ӵ�����ȥҲ��ͬ��

������������һ�����Ӵ�ѶϢ������ʽû�и�������ݡ�BRICKS3ʵ����ʹ��ש��ͼ����Ϊ�Ӵ���𱳾���ˢ������WNDCLASS�ṹ��hbrBackground��λ�ж��塣

�����ڿ��ܲ���GDI��ˢ�Ǻ�С�ĵ���ͼ��ͨ����8��ͼ�ؼ����������LOGBRUSH�ṹ��lbStyle��λ�趨ΪBS_PATTERN��Ȼ�����CreatePatternBrush��CreateBrushIndirect�����Ϳ����ڵ���ͼ������������ˢ�ˡ��˵���ͼ�����ǿ��߸�8��ͼ�ء�����ٴ�Windows 98��ֻʹ�õ���ͼ�����Ͻ���Ϊ��ˢ����Windows NT���ܴ����ƣ�����ʹ����������ͼ��

���ס����ˢ�͵���ͼ����GDI�����������Ӧ���ڳ�ʽ��ֹǰɾ�����ڳ�ʽ�н�����ˢ�͵���ͼ����������ݵ���ͼ������ˢ����ô���û�ˢ��ͼʱ��Windows�����Ƶ���ͼλԪ����ˢ�����Ƶ������ڡ�����CreatePatternBrush������CreateBrushIndirect��֮�ᣬ����������ɾ������ͼ������Ӱ�쵽���ʡ����Ƶأ���Ҳ����ɾ����ˢ������Ӱ�쵽��ѡ����ԭʼ����ͼ��ע�⣬BRICKS3�ڽ�����ˢ��ɾ���˵���ͼ�����ڳ�ʽ��ֹǰɾ���˻�ˢ��

���Ƶ���ͼ
��

���Ӵ��л�ͼʱ�������Ѿ�������ͼ���ɻ�ͼ��Դʹ�ù��ˡ���Ҫ���Ƚ�����ͼѡ��������װ�����ݣ�������BitBlt����StretchBlt����Ҳ�����ü�����װ�����ݴ�����Ϊ����ʵ�ʺ��е�GDI��ʽ�еĵ�һ������������װ�����ݵĶ�����ʵ�ʵ�װ��������ͬ��������ʾƽ���ǵ���ͼ��

��ʽ14-6��ʾ��HELLOBIT��ʽչʾ�˴��������ʽ��һ��С����ͼ����ʾ���ִ���Hello, world!����Ȼ��ӵ���ͼ����ʽ��ʾ����ִ��BitBlt��StretchBlt������ѡ��Ĺ��ܱ�ѡ���������

 ï¿½ï¿½Ê½14-6  HELLOBIT
HELLOBIT.C
/*-----------------------------------------------------------------------
   	HELLOBIT.C -- 		Bitmap Demonstration
                 							(c) Charles Petzold, 1998
-------------------------------------------------------------------------*/

#include <windows.h>
#include "resource.h"

LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    PSTR szCmdLine, int iCmdShow)
{
     	static TCHAR 		szAppName [] = TEXT ("HelloBit") ;
     	HWND         			    hwnd ;
     	MSG          				msg ;
     	WNDCLASS     				wndclass ;

     	wndclass.style         			= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         			= LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       			= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= (HBRUSH) GetStockObject (WHITE_BRUSH) ;
     	wndclass.lpszMenuName  		= szAppName ;
     	wndclass.lpszClassName 		= szAppName ;
     
     	if (!RegisterClass (&wndclass))
     	{
	MessageBox (	NULL, TEXT ("This program requires Windows NT!"),
                      						szAppName, MB_ICONERROR) ;
 	return 0 ;
     	}
     
	hwnd = CreateWindow (szAppName, TEXT ("HelloBit"), 
                          WS_OVERLAPPEDWINDOW, 
                          CW_USEDEFAULT, CW_USEDEFAULT,
                          CW_USEDEFAULT, CW_USEDEFAULT,
                          NULL, NULL, hInstance, NULL) ;

     	ShowWindow (hwnd, iCmdShow) ;
     	UpdateWindow (hwnd) ;

     	while (GetMessage (&msg, NULL, 0, 0))
     {
          		TranslateMessage (&msg) ;
          		DispatchMessage (&msg) ;
     	}
     		return msg.wParam ;
}

LRESULT CALLBACK WndProc (	HWND hwnd, UINT message, WPARAM wParam,LPARAM lParam)
{
     	static 	HBITMAP 	hBitmap ;
     	static 	HDC     	hdcMem ;
     	static 		int     cxBitmap, cyBitmap, cxClient, cyClient, iSize = IDM_BIG ;
     	static TCHAR * 	szText = TEXT (" Hello, world! ") ;
     	HDC            		hdc ;
     	HMENU          		hMenu ;
     	int            		x, y ;
     	PAINTSTRUCT    		ps ;
     	SIZE           		size ;
     
     	switch (message)
     	{
     	case 	WM_CREATE:
          			hdc = GetDC (hwnd) ;
          			hdcMem  = CreateCompatibleDC (hdc) ;

          			GetTextExtentPoint32 (hdc, szText, lstrlen (szText), &size) ;
          			cxBitmap = size.cx ;
          			cyBitmap = size.cy ;
          			hBitmap = CreateCompatibleBitmap (hdc, cxBitmap, cyBitmap) ;

          			ReleaseDC (hwnd, hdc) ;

          			SelectObject (hdcMem, hBitmap) ;
          			TextOut (hdcMem, 0, 0, szText, lstrlen (szText)) ;
          			return 0 ;

     	case 	WM_SIZE:
          			cxClient = LOWORD (lParam) ;
          			cyClient = HIWORD (lParam) ;
          			return 0 ;

     	case 	WM_COMMAND:
          			hMenu = GetMenu (hwnd) ;

          			switch (LOWORD (wParam))
          			{
          			case 	IDM_BIG:
          			case 	IDM_SMALL:
               					CheckMenuItem (hMenu, iSize, MF_UNCHECKED) ;
               					iSize = LOWORD (wParam) ;
               					CheckMenuItem (hMenu, iSize, MF_CHECKED) ;
               					InvalidateRect (hwnd, NULL, TRUE) ;
               					break ;
          			}
          			return 0 ;

     	case 	WM_PAINT:
          			hdc = BeginPaint (hwnd, &ps) ;

          			switch (iSize)
          			{
  			case 	IDM_BIG:
               					StretchBlt (hdc, 0, 0, cxClient, cyClient, 
                           		hdcMem, 0, 0, cxBitmap, cyBitmap, SRCCOPY) ;
               									break ;

          			case 	IDM_SMALL:
               					for (y = 0 ; y < cyClient ; y += cyBitmap)
               					for (x = 0 ; x < cxClient ; x += cxBitmap)
               					{
                    			BitBlt (hdc, x, y, cxBitmap, cyBitmap, 
                            	hdcMem, 0, 0, SRCCOPY) ;
               						}
               						break ;
          			}

          			EndPaint (hwnd, &ps) ;
          			return 0 ;

     	case 	WM_DESTROY:
          			DeleteDC (hdcMem) ;
          			DeleteObject (hBitmap) ;
          			PostQuitMessage (0) ;
          			return 0 ;
     	}
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}
 HELLOBIT.RC ��ժ¼��
//Microsoft Developer Studio generated resource script.
#include "resource.h"
#include "afxres.h"

/////////////////////////////////////////////////////////////////////////////
// Menu
HELLOBIT MENU DISCARDABLE 
BEGIN
    	POPUP "&Size"
    	BEGIN
        			MENUITEM "&Big",   		IDM_BIG, CHECKED
        			MENUITEM "&Small",  		IDM_SMALL
    	END
END
 RESOURCE.H ��ժ¼��
// Microsoft Developer Studio generated include file.
// Used by HelloBit.rc

#define IDM_BIG            40001
#define IDM_SMALL          40002

��ʽ�Ӻ���GetTextExtentPoint32ȷ���ִ���ͼ�سߴ翪ʼ����Щ�ߴ罫��Ϊ����Ѷ��ʾ���ݵĵ���ͼ�ߴ硣���˵���ͼ��ѡ��������װ�����ݣ�Ҳ����Ѷ��ʾ���ݣ��ᣬ�ٺ���TextOut��������ʾ�ڵ���ͼ�ϡ�������װ�������ڳ�ʽִ���ڼ䱣�����ڴ���WM_DESTROY��Ѷ�ڼ䣬HELLOBITɾ���˵���ͼ�ͼ�����װ�����ݡ�

HELLOBIT�е�һ�����ܱ�ѡ����������ʾ����ͼ�ߴ磬�˳ߴ��������ʾ������ˮƽ�ʹ�ֱ����ƽ�̵�ʵ�ʳߴ磬���������ų���ʾ�����С�ijߴ磬��ͼ14-4��ʾ����������������һ�����ⲻ����ʾ��ߴ���Ԫ�ĺ÷�������ֻ��С����ķŴ�棬�����зŴ�ʱ�����ľ���ߡ�


��

ͼ14-4 HELLOBIT��өĻ��ʾ

��������֪��һ����ʽ������HELLOBIT���Ƿ���Ҫ����WM_DISPLAYCHANGEѶϢ��ֻҪʹ���ߣ���������Ӧ�ó�ʽ���޸�����Ѷ��ʾ��С������ɫ��ȣ�Ӧ�ó�ʽ�ͽ��յ���ѶϢ��������ɫ��ȵĸı�ᵼ�¼�����װ�����ݺ���Ѷװ�����ݲ����ݡ����Ⲣ���ᷢ������Ϊ����ʾģʽ�޸��ᣬWindows�Զ��޸��˼�����װ�����ݵ���ɫ�����ȡ�ѡ��������װ�����ݵĵ���ͼ��Ȼ����ԭ��������������κ����⡣

��Ӱ����ͼ
��

�ڼ�����װ�����ݻ�ͼ��Ҳ���ǵ���ͼ���ļ�����ִ�С���Ӱ����ͼ��shadow bitmap�����Ĺؼ����˵���ͼ�����Ӵ���ʾ��������ʾ���������ݡ���������WM_PAINTѶϢ�Ĵ����ͼ򻯵��򵥵�BitBlt��

��Ӱ����ͼ�ڻ滭��ʽ�������á���ʽ14-7��ʾ��SKETCH��ʽ������һ���������Ļ滭��ʽ��������һ����ʼ��

 ï¿½ï¿½Ê½14-7  SKETCH
SKETCH.C
/*-------------------------------------------------------------------------
   	SKETCH.C -- Shadow Bitmap Demonstration
               						(c) Charles Petzold, 1998
---------------------------------------------------------------------------*/

#include <windows.h>
LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
     	static TCHAR 		szAppName [] = TEXT ("Sketch") ;
     	HWND         				hwnd ;
     	MSG          				msg ;
     	WNDCLASS     				wndclass ;

     	wndclass.style         			= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         			= LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       			= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= (HBRUSH) GetStockObject (WHITE_BRUSH) ;
     	wndclass.lpszMenuName  		= NULL ;
     	wndclass.lpszClassName 		= szAppName ;
     
     	if (!RegisterClass (&wndclass))
     	{
          		MessageBox (	NULL, TEXT ("This program requires Windows NT!"),
                szAppName, MB_ICONERROR) ;
          		return 0 ;
     	}
     
     	hwnd = CreateWindow (szAppName, TEXT ("Sketch"), 
                             WS_OVERLAPPEDWINDOW, 
                             CW_USEDEFAULT, CW_USEDEFAULT,
                             CW_USEDEFAULT, CW_USEDEFAULT,
                             NULL, NULL, hInstance, NULL) ;

     	if (hwnd == NULL)
     	{
          		MessageBox (	NULL, TEXT ("Not enough memory to create bitmap!"),
                      		szAppName, MB_ICONERROR) ;
          		return 0 ;
     }

     	ShowWindow (hwnd, iCmdShow) ;
     	UpdateWindow (hwnd) ;

     	while (GetMessage (&msg, NULL, 0, 0))
     {
          				TranslateMessage (&msg) ;
          				DispatchMessage (&msg) ;
     }
 	return msg.wParam ;
}

void GetLargestDisplayMode (int * pcxBitmap, int * pcyBitmap)
{
     	DEVMODE 	devmode ;
     	int  		iModeNum = 0 ;

     	* pcxBitmap = * pcyBitmap = 0 ;

     	ZeroMemory (&devmode, sizeof (DEVMODE)) ;
     	devmode.dmSize = sizeof (DEVMODE) ;
     
     	while (EnumDisplaySettings (NULL, iModeNum++, &devmode))
     	{
          		* pcxBitmap = max (* pcxBitmap, (int) devmode.dmPelsWidth) ;
          		* pcyBitmap = max (* pcyBitmap, (int) devmode.dmPelsHeight) ;
     	}
}
LRESULT CALLBACK WndProc (	HWND hwnd, UINT message, WPARAM wParam,LPARAM lParam)
{
     	static BOOL   	fLeftButtonDown, fRightButtonDown ;
     	static HBITMAP hBitmap ;
     	static HDC     		hdcMem ;
     	static int     		cxBitmap, cyBitmap, cxClient, cyClient, xMouse, yMouse ;
     	HDC            				hdc ;
     	PAINTSTRUCT    		ps ;
     
     	switch (message)
     	{
     	case 	WM_CREATE:
          			GetLargestDisplayMode (&cxBitmap, &cyBitmap) ;

          			hdc = GetDC (hwnd) ;
          			hBitmap = CreateCompatibleBitmap (hdc, cxBitmap, cyBitmap) ;
          			hdcMem  = CreateCompatibleDC (hdc) ;
          			ReleaseDC (hwnd, hdc) ;

          		if (!hBitmap)       				// no memory for bitmap
          		{
               			DeleteDC (hdcMem) ;
               			return -1 ;
          		}

          			SelectObject (hdcMem, hBitmap) ;
          			PatBlt (hdcMem, 0, 0, cxBitmap, cyBitmap, WHITENESS) ;
          			return 0 ;

     	case 	WM_SIZE:
          			cxClient = LOWORD (lParam) ;
          			cyClient = HIWORD (lParam) ;
          			return 0 ;

     	case 	WM_LBUTTONDOWN:
          			if (!fRightButtonDown)
               					SetCapture (hwnd) ;

          			xMouse = LOWORD (lParam) ;
          			yMouse = HIWORD (lParam) ;
          			fLeftButtonDown = TRUE ;
          			return 0 ;

     	case 	WM_LBUTTONUP:
          			if (fLeftButtonDown)
               					SetCapture (NULL) ;
          
          			fLeftButtonDown = FALSE ;
          			return 0 ;
          
     	case 	WM_RBUTTONDOWN:
          			if (!fLeftButtonDown)
               					SetCapture (hwnd) ;
          
          			xMouse = LOWORD (lParam) ;
          			yMouse = HIWORD (lParam) ;
          			fRightButtonDown = TRUE ;
          			return 0 ;
          
     	case 	WM_RBUTTONUP:
          			if (fRightButtonDown) 
               			SetCapture (NULL) ;
          
          			fRightButtonDown = FALSE ;
          			return 0 ;

     	case 	WM_MOUSEMOVE:
          			if (!fLeftButtonDown && !fRightButtonDown)
               			return 0 ;

          			hdc = GetDC (hwnd) ;

          			SelectObject (hdc, 
              	 		GetStockObject (fLeftButtonDown ? BLACK_PEN : WHITE_PEN)) ;

          			SelectObject (hdcMem,
               			GetStockObject (fLeftButtonDown ? BLACK_PEN : WHITE_PEN)) ;

          			MoveToEx (hdc,    xMouse, yMouse, NULL) ;
          			MoveToEx (hdcMem, xMouse, yMouse, NULL) ;

          			xMouse = (short) LOWORD (lParam) ;
          			yMouse = (short) HIWORD (lParam) ;

          			LineTo (hdc,    xMouse, yMouse) ;
          			LineTo (hdcMem, xMouse, yMouse) ;

          			ReleaseDC (hwnd, hdc) ;
          			return 0 ;

     	case 	WM_PAINT:
          			hdc = BeginPaint (hwnd, &ps) ;
          			BitBlt (hdc, 0, 0, cxClient, cyClient, hdcMem, 0, 0, SRCCOPY) ;

          			EndPaint (hwnd, &ps) ;
          			return 0 ;

     	case 	WM_DESTROY:
          			DeleteDC (hdcMem) ;
          			DeleteObject (hBitmap) ;
          			PostQuitMessage (0) ;
          			return 0 ;
     	}
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}

Ҫ����SKETCH�л��ߣ��밴�»���������϶�����Ҫ���������Ķ�������ȷ�е�˵���ǻ����ߣ����밴�»����Ҽ����϶�����Ҫ��������Ӵ����롭������ʽ��Ȼ���������룬һ�д�ͷ������ͼ14-5����ʾ��SKETCH��ʽͼ�������˶�Ƶ����˾��������������ڹ��ľ��⡣


��

ͼ14-5 SKETCH��өĻ��ʾ

����Ӱ����ͼӦ����ڱ���ʽ�У���Ӧ�ô��ܰ�������Ӵ���������ʾ������һ��������׸���GetSystemMetrics��Ѷ����ó��������ʹ�����޸�����ʾ�趨������ʾ���������������ʱ�Ӵ��ijߴ磬��ʱ������ʲô�أ�SKETCH��ʽ��EnumDisplaySettings��ʽ�İ����½���˴����⡣�˺�ʽʹ��DEVMODE�ṹ������ȫ����Ч��Ѷ��ʾģʽ����Ѷ����һ�κ��д˺�ʽʱ��Ӧ��EnumDisplaySettings�ĵڶ�������Ϊ0������ÿ�κ��д�ֵ�����ӡ�EnumDisplaySettings����FALSEʱ��ɡ�

���ͬʱ��SKETCH������һ����Ӱ����ͼ������Ŀǰ��Ѷ��ʾģʽ�ı��滹���ı���������Ҫ������λԪ��ļ����塣�����ˣ�SKETCH��������ͼ�Ƿ����ɹ��ˣ����û�н������ʹ�WM_CREATE����-1���Ա�ʾ����

��WM_MOUSEMOVEѶϢ�����ڼ䣬���»�����������Ҽ������ڼ�����װ�����ݺ���ʾ����װ�������л���ʱ��SKETCH���ػ���������߷�ʽ�����ӵĻ�������������һ����ʽ��ʵ������ʽ�����д˺�ʽ���Σ�һ�λ�����Ѷװ�������ϣ�һ�λ��ڼ�����װ�������ϡ�

������һ����Ȥ��ʵ�飺ʹSKETCH�Ӵ�С�ȫ����ߴ硣������������İ��£��������ϳ��Ӵ������½ǡ���ΪSKETCH���ػ����������������ղ�����WM_MOUSEMOVEѶϢ�����������Ӵ�������������Ӱ����ͼ��������SKETCH�Ӵ������������ݡ�

�ڹ��ܱ���ʹ�õ���ͼ
��

��Ҳ�����õ���ͼ�ڹ��ܱ�����ʾѡ�������������ܱ��е����С�����������Դ����Ͳ��ͼƬ����ô��Ҫ������ЩͼƬ�ˡ���Ӧ�ÿ���һ�£����ܱ�����ʾ����ͼ�Ի�ͼ��ʽ��;�ж������һ���ڹ��ܱ���ʹ�ò�ͬ����������С���߿�����Ӱͼ���Լ���ɫ��

GRAFMENU��չʾͼ�ι��ܱ�ѡ��ķ�����ʽ���˳�ʽ���㹦�ܱ���ͼ14-6��ʾ���Ŵ����ĸ�����40��16ͼ�صĵ�ɫ����ͼ�������õ�����Visual C++ Developer Studio�������ӹ��ܱ���ѡ��FONT������������ѡ�����Courier New������ Arial���͡�Times New Roman���������DZ�׼��Windows TrueType���壬����ÿһ����������ص�������ʾ����ͼ14-7��ʾ����Щ����ͼ�ڳ�ʽ���ü�����װ�����ݽ�����


��

ͼ14-6 GRAFMENU��ʽ�Ķ��㹦�ܱ�


��

ͼ14-7 GRAFMENU��ʽ�����ġ�FONT�����ܱ�

���ᣬ������ϵͳ���ܱ�ʱ���������һЩ����������Ѷ���á�HELP����ʾ����ʹ���ߵ�����������Ŀ���μ�ͼ14-8������64��64ͼ�صĵ�ɫ����ͼ����Developer Studio�н����ġ�


��

ͼ14-8 GRAFMENU��ʽϵͳ���ܱ�

GRAFMENU��ʽ�������ĸ�Developer Studio�н����ĵ���ͼ�����ʽ14-8��ʾ��

 ï¿½ï¿½Ê½14-8  GRAFMENU
GRAFMENU.C
/*----------------------------------------------------------------------------
   	GRAFMENU.C -- 		Demonstrates Bitmap Menu Items
                 							(c) Charles Petzold, 1998
-----------------------------------------------------------------------------*/

#include <windows.h>
#include "resource.h"

LRESULT 		CALLBACK WndProc 		(HWND, UINT, WPARAM, LPARAM) ;
void    		AddHelpToSys     		(HINSTANCE, HWND) ;
HMENU   		CreateMyMenu     		(HINSTANCE) ;
HBITMAP 		StretchBitmap    	    (HBITMAP) ;
HBITMAP 		GetBitmapFont    		(int) ;
void    		DeleteAllBitmaps 	    (HWND) ;
TCHAR szAppName[] = TEXT ("GrafMenu") ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    PSTR szCmdLine, int iCmdShow)
{
     	HWND  			hwnd ;
     	MSG   			msg ;
     	WNDCLASS 		wndclass ;
     
     	wndclass.style         			= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         			= LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       			= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= (HBRUSH) GetStockObject (WHITE_BRUSH) ;
     	wndclass.lpszMenuName  		= NULL ;
     	wndclass.lpszClassName 		= szAppName ;
     
     	if (!RegisterClass (&wndclass))
     	{
          		MessageBox (	NULL, TEXT ("This program requires Windows NT!"),
                      		szAppName, MB_ICONERROR) ;
          		return 0 ;
     }
     
     	hwnd = CreateWindow (szAppName,TEXT ("Bitmap Menu Demonstration"),
                          	WS_OVERLAPPEDWINDOW,
                          	CW_USEDEFAULT, CW_USEDEFAULT,
                          	CW_USEDEFAULT, CW_USEDEFAULT,
                          	NULL, NULL, hInstance, NULL) ;
     
     	ShowWindow (hwnd, iCmdShow) ;
     	UpdateWindow (hwnd) ;
     
     	while (GetMessage (&msg, NULL, 0, 0))
     	{
          		TranslateMessage (&msg) ;
          		DispatchMessage (&msg) ;
     	}
     	return msg.wParam ;
}

LRESULT CALLBACK WndProc (	HWND hwnd, UINT iMsg, WPARAM wParam,LPARAM lParam)
{
     	HMENU      				hMenu ;
     	static int 		iCurrentFont = IDM_FONT_COUR ;
     
     	switch (iMsg)
     	{
     	case WM_CREATE:
          			AddHelpToSys (((LPCREATESTRUCT) lParam)->hInstance, hwnd) ;
          			hMenu = CreateMyMenu (((LPCREATESTRUCT) lParam)->hInstance) ;
          			SetMenu (hwnd, hMenu) ;
          			CheckMenuItem (hMenu, iCurrentFont, MF_CHECKED) ;
          			return 0 ;
          
     	case 	WM_SYSCOMMAND:
          			switch (LOWORD (wParam))
          			{
          			case 	IDM_HELP:
               					MessageBox (hwnd, TEXT ("Help not yet implemented!"),
                           		szAppName, MB_OK | MB_ICONEXCLAMATION) ;
               					return 0 ;
          			}
          			break ;
          
     	case 	WM_COMMAND:
          			switch (LOWORD (wParam))
          			{
          			case 	IDM_FILE_NEW:
          			case 	IDM_FILE_OPEN:
          			case 	IDM_FILE_SAVE:
          			case 	IDM_FILE_SAVE_AS:
          			case 	IDM_EDIT_UNDO:
          			case 	IDM_EDIT_CUT:
          			case 	IDM_EDIT_COPY:
          			case 	IDM_EDIT_PASTE:
          			case 	IDM_EDIT_CLEAR:
               					MessageBeep (0) ;
               					return 0 ;
                    
          			case 	IDM_FONT_COUR:
          			case 	IDM_FONT_ARIAL:
          			case 	IDM_FONT_TIMES:
               				hMenu = GetMenu (hwnd) ;
               		CheckMenuItem (hMenu, iCurrentFont, MF_UNCHECKED) ;
               					iCurrentFont = LOWORD (wParam) ;
               					CheckMenuItem (hMenu, iCurrentFont, MF_CHECKED) ;
               					return 0 ;
          			}
          			break ;
               
     		case 	WM_DESTROY:
          				DeleteAllBitmaps (hwnd) ;
          				PostQuitMessage (0) ;
          				return 0 ;
     	}
     	return DefWindowProc (hwnd, iMsg, wParam, lParam) ;
}

/*--------------------------------------------------------------------------
   	AddHelpToSys: Adds bitmap Help item to system menu
  ------------------------------------------------------------------------*/

void AddHelpToSys (HINSTANCE hInstance, HWND hwnd)
{
     	HBITMAP 		hBitmap ;
     	HMENU   		hMenu ;

     	hMenu = GetSystemMenu (hwnd, FALSE);
     	hBitmap = StretchBitmap (LoadBitmap (hInstance, TEXT ("BitmapHelp"))) ;
     	AppendMenu (hMenu, MF_SEPARATOR, 0, NULL) ;
     	AppendMenu (hMenu, MF_BITMAP, IDM_HELP, (PTSTR) (LONG) hBitmap) ;
}

/*------------------------------------------------------------------------
   CreateMyMenu: Assembles menu from components
--------------------------------------------------------------------------*/

HMENU CreateMyMenu (HINSTANCE hInstance)
{
     	HBITMAP 		hBitmap ;
     	HMENU   		hMenu, hMenuPopup ;
     	int     		i ;

     	hMenu = CreateMenu () ;
     	hMenuPopup = LoadMenu (hInstance, TEXT ("MenuFile")) ;
     	hBitmap = StretchBitmap (LoadBitmap (hInstance, TEXT ("BitmapFile"))) ;
     	AppendMenu (hMenu, MF_BITMAP | MF_POPUP, (int) hMenuPopup,
                        						(PTSTR) (LONG) hBitmap) ;
     	hMenuPopup = LoadMenu (hInstance, TEXT ("MenuEdit")) ;
     	hBitmap = StretchBitmap (LoadBitmap (hInstance, TEXT ("BitmapEdit"))) ;
     	AppendMenu (hMenu, MF_BITMAP | MF_POPUP, (int) hMenuPopup,
                         (PTSTR) (LONG) hBitmap) ;
     	hMenuPopup = CreateMenu () ;
     	for (i = 0 ; i < 3 ; i++)
     {
          		hBitmap = GetBitmapFont (i) ;
          		AppendMenu (hMenuPopup, MF_BITMAP, IDM_FONT_COUR + i, 
                         (PTSTR) (LONG) hBitmap) ;
     	}

     	hBitmap = StretchBitmap (LoadBitmap (hInstance, TEXT ("BitmapFont"))) ;
     	AppendMenu (hMenu, MF_BITMAP | MF_POPUP, (int) hMenuPopup,
                        (PTSTR) (LONG) hBitmap) ;
     	return hMenu ;
}

/*-------------------------------------------------------------------------
   StretchBitmap: Scales bitmap to display resolution
---------------------------------------------------------------------------*/

HBITMAP StretchBitmap (HBITMAP hBitmap1)
{
     	BITMAP     			bm1, bm2 ;
     	HBITMAP    			hBitmap2 ;
     	HDC        			hdc, hdcMem1, hdcMem2 ;
     	int        			cxChar, cyChar ;

          		// Get the width and height of a system font character

     	cxChar = LOWORD (GetDialogBaseUnits ()) ;
     	cyChar = HIWORD (GetDialogBaseUnits ()) ;

          		// Create 2 memory DCs compatible with the display
     	hdc = CreateIC (TEXT ("DISPLAY"), NULL, NULL, NULL) ;
     	hdcMem1 = CreateCompatibleDC (hdc) ;
     	hdcMem2 = CreateCompatibleDC (hdc) ;
     	DeleteDC (hdc) ;

          		// Get the dimensions of the bitmap to be stretched
     	GetObject (hBitmap1, sizeof (BITMAP), (PTSTR) &bm1) ;
          		// Scale these dimensions based on the system font size
     	bm2 = bm1 ;
     	bm2.bmWidth      		= (cxChar * bm2.bmWidth)  / 4 ;
     	bm2.bmHeight     		= (cyChar * bm2.bmHeight) / 8 ;
     	bm2.bmWidthBytes 		= ((bm2.bmWidth + 15) / 16) * 2 ;

          		// Create a new bitmap of larger size
     
     	hBitmap2 = CreateBitmapIndirect (&bm2) ;
          		// Select the bitmaps in the memory DCs and do a StretchBlt
     	SelectObject (hdcMem1, hBitmap1) ;
     	SelectObject (hdcMem2, hBitmap2) ;
     	StretchBlt (hdcMem2, 0, 0, bm2.bmWidth, bm2.bmHeight,
                 	hdcMem1, 0, 0, bm1.bmWidth, bm1.bmHeight, SRCCOPY) ;
          			// Clean up
     	DeleteDC (hdcMem1) ;
     	DeleteDC (hdcMem2) ;
     	DeleteObject (hBitmap1) ;
     
     	return hBitmap2 ;
}

/*---------------------------------------------------------------------------
   GetBitmapFont: Creates bitmaps with font names
-----------------------------------------------------------------------------*/

HBITMAP GetBitmapFont (int i)
{
     	static TCHAR  * szFaceName[3]= {	TEXT ("Courier New"), TEXT ("Arial"), 
        TEXT ("Times New Roman") } ;
     	HBITMAP         			hBitmap ;
     	HDC             			hdc, hdcMem ;
     	HFONT           			hFont ;
     	SIZE            			size ;
     	TEXTMETRIC      			tm ;
     
     	hdc = CreateIC (TEXT ("DISPLAY"), NULL, NULL, NULL) ;
     	GetTextMetrics (hdc, &tm) ;
     
     	hdcMem 	= CreateCompatibleDC (hdc) ;
     	hFont  	= CreateFont (2 * tm.tmHeight, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                          	 szFaceName[i]) ;

     	hFont = (HFONT) SelectObject (hdcMem, hFont) ;
     	GetTextExtentPoint32 (hdcMem, szFaceName[i], 
        lstrlen (szFaceName[i]), &size);
     	hBitmap = CreateBitmap (size.cx, size.cy, 1, 1, NULL) ;
     	SelectObject (hdcMem, hBitmap) ;
     
  	TextOut (hdcMem, 0, 0, szFaceName[i], lstrlen (szFaceName[i])) ;
     	DeleteObject (SelectObject (hdcMem, hFont)) ;
     	DeleteDC (hdcMem) ;
     	DeleteDC (hdc) ;
     
     	return hBitmap ;
}

/*--------------------------------------------------------------------------- 
   DeleteAllBitmaps: Deletes all the bitmaps in the menu
  -------------------------------------------------------------------------*/

void DeleteAllBitmaps (HWND hwnd)
{
     	HMENU        			hMenu ;
     	int          			i ;
     	MENUITEMINFO mii = { sizeof (MENUITEMINFO), MIIM_SUBMENU | MIIM_TYPE } ;
          			// Delete Help bitmap on system menu
     	hMenu = GetSystemMenu (hwnd, FALSE);
     	GetMenuItemInfo (hMenu, IDM_HELP, FALSE, &mii) ;
     	DeleteObject ((HBITMAP) mii.dwTypeData) ;

          			// Delete top-level menu bitmaps
     	hMenu = GetMenu (hwnd) ;
     	for (i = 0 ; i < 3 ; i++)
     	{
          			GetMenuItemInfo (hMenu, i, TRUE, &mii) ;
          			DeleteObject ((HBITMAP) mii.dwTypeData) ;
     	}

          			// Delete bitmap items on Font menu
     	hMenu = mii.hSubMenu ;;
     	for (i = 0 ; i < 3 ; i++)
     	{
          		GetMenuItemInfo (hMenu, i, TRUE, &mii) ;
          		DeleteObject ((HBITMAP) mii.dwTypeData) ;
     	}
}
 GRAFMENU.RC ��ժ¼��
//Microsoft Developer Studio generated resource script.
#include "resource.h"
#include "afxres.h"

/////////////////////////////////////////////////////////////////////////////
// Menu
MENUFILE MENU DISCARDABLE 
BEGIN
    		MENUITEM "&New",  			IDM_FILE_NEW
    		MENUITEM "&Open...",			IDM_FILE_OPEN
    		MENUITEM "&Save",    			IDM_FILE_SAVE
    		MENUITEM "Save &As...",  		IDM_FILE_SAVE_AS
END
MENUEDIT MENU DISCARDABLE 
BEGIN
    		MENUITEM "&Undo",  			IDM_EDIT_UNDO
    		MENUITEM SEPARATOR
    		MENUITEM "Cu&t",   			IDM_EDIT_CUT
    		MENUITEM "&Copy",   			IDM_EDIT_COPY
    		MENUITEM "&Paste",  			IDM_EDIT_PASTE
    		MENUITEM "De&lete",   		IDM_EDIT_CLEAR
END

/////////////////////////////////////////////////////////////////////////////
// Bitmap
BITMAPFONT      BITMAP     DISCARDABLE     "Fontlabl.bmp"
BITMAPHELP      BITMAP     DISCARDABLE     "Bighelp.bmp"
BITMAPEDIT      BITMAP     DISCARDABLE     "Editlabl.bmp"
BITMAPFILE      BITMAP     DISCARDABLE     "Filelabl.bmp"
 RESOURCE.H ��ժ¼��
// Microsoft Developer Studio generated include file.
// Used by GrafMenu.rc

#define IDM_FONT_COUR    101
#define IDM_FONT_ARIAL   102
#define IDM_FONT_TIMES   103
#define IDM_HELP         104
#define IDM_EDIT_UNDO    40005
#define IDM_EDIT_CUT     40006
#define IDM_EDIT_COPY    40007
#define IDM_EDIT_PASTE   40008
#define IDM_EDIT_CLEAR   40009
#define IDM_FILE_NEW     40010
#define IDM_FILE_OPEN    40011
#define IDM_FILE_SAVE    40012
#define IDM_FILE_SAVE_AS 40013
EDITLABL.BMP
��

FILELABL.BMP
��

FONTLABL.BMP
��

BIGHELP.BMP
��

Ҫ������ͼ���빦�ܱ�����������AppendMenu��InsertMenu������ͼ��������Դ��������Visual C++ Developer Studio��������ͼ��������Դ�ű��еĵ���ͼ���������ڳ�ʽʹ��LoadBitmapʱ������ͼ��Դ���뵽�����壬Ȼ�����AppendMenu��InsertMenu������ͼ���ӵ����ܱ��ϡ����������ַ�������һЩ���⣺����ͼ�����������ʾģʽ�Ľ����Ⱥ��ݺ�ȣ���ʱ����Ҫ��������ĵ���ͼ�Խ�������⡣��һ�ַ����ǣ��ڳ�ʽ�ڲ���������ͼ��������ѡ��������װ�����ݣ���������Ȼ���ٸ��ӵ����ܱ��С�

GRAFMENU�е�GetBitmapFont��ʽ�IJ���Ϊ0��1��2������һ������ͼ���š��˵���ͼ�����ִ���Courier New������Arial����Times New Roman�������������Ǹ��Զ�Ӧ�����壬��С������ϵͳ����������������ǿ���GetBitmapFont����ô���ġ�������ij�ʽ����GRAFMENU.C�����е���Щ��ͬ��Ϊ�������������á�Arial��������Ӧ��ֵ����������szFaceName���С���

��һ������TEXTMETRIC�ṹ��ȷ��Ŀǰϵͳ����Ĵ�С��������һ����ĿǰөĻ���ݵļ�����װ�����ݣ�

hdc = CreateIC (TEXT ("DISPLAY"), NULL, NULL, NULL) ;
GetTextMetrics (hdc, &tm) ;
hdcMem = CreateCompatibleDC (hdc) ;

CreateFont��ʽ������һ���߼����壬���������ϵͳ����������������߼�����Ϊ��Arial����

hFont = CreateFont (2 * tm.tmHeight, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                    					TEXT ("Arial")) ;

�Ӽ�����װ��������ѡ������壬Ȼ�ᴢ���ڶ�������ţ�

hFont = (HFONT) SelectObject (hdcMem, hFont) ;

���ڣ��������������װ������дһЩ����ʱ��Windows�ͻ�ʹ��ѡ��װ�����ݵ�TrueType Arial�����ˡ�

�����������װ���������ֻ��һ����ͼ�ص�ɫ�豸ƽ�档���DZ��뽨��һ���㹻��ĵ���ͼ������������Ҫ��ʾ�����֡�ͨ��GetTextExtentPoint32��ʽ������ȡ�����ֵĴ�С������CreateBitmap���Ը�����Щ�ߴ�����������ͼ��

GetTextExtentPoint32 (hdcMem, TEXT ("Arial"), 5, &size) ;
hBitmap = CreateBitmap (size.cx, size.cy, 1, 1, NULL) ;
SelectObject (hdcMem, hBitmap) ;

�������װ��������һ����ɫ����ʾƽ�棬��СҲ���ϸ�����ֳߴ硣��������Ҫ���ľ�����д���֣�

TextOut (hdcMem, 0, 0, TEXT ("Arial"), 5) ;

������������еĹ���������ˡ�Ҫ��������ǿ�����SelectObject��ϵͳ���壨���д���hFont������ѡ��װ�����ݣ�Ȼ��ɾ��SelectObject���ص�ǰһ��������ţ�Ҳ����Arial������ţ�

DeleteObject (SelectObject (hdcMem, hFont)) ;

���ڿ���ɾ������װ�����ݣ�

DeleteDC (hdcMem) ;
DeleteDC (hdc) ;

���������Ǿͻ����һ������ͼ���õ���ͼ����Arial������ִ���Arial����

��������Ҫ������������Ӧ��ͬ��ʾ�����Ȼ��ݺ��ʱ��������װ������Ҳ�ܽ�����⡣��GRAFMENU��ʽ�У��ҽ������ĸ�����ͼ����Щ����ͼֻ�����ϵͳ�����8ͼ�ء���4ͼ�ص���ʾ����������ߴ��ϵͳ���壬ֻ�����ŵ���ͼ��GRAFMENU�е�StretchBitmap��ʽ��ɴ˹��ܡ�

��һ���ǻ����ʾ��װ�����ݣ�Ȼ��ȡ��ϵͳ��������ֹ�񣬽�������������������װ�����ݣ�

hdc = CreateIC (TEXT ("DISPLAY"), NULL, NULL, NULL) ;
GetTextMetrics (hdc, &tm) ;
hdcMem1 = CreateCompatibleDC (hdc) ;
hdcMem2 = CreateCompatibleDC (hdc) ; 
DeleteDC (hdc) ;

���ݸ���ʽ�ĵ���ͼ������hBitmap1����ʽ����GetObject��õ���ͼ�Ĵ�С��

GetObject (hBitmap1, sizeof (BITMAP), (PSTR) &bm1) ;

�˲������ߴ縴�Ƶ�BITMAP��̬�Ľṹbm1�С��ṹbm2��춽ṹbm1��Ȼ�����ϵͳ�����С���޸�ijЩ��λ��

bm2 = bm1 ;
bm2.bmWidth      		= (tm.tmAveCharWidth * bm2.bmWidth)  / 4 ;
bm2.bmHeight     		= (tm.tmHeight       * bm2.bmHeight) / 8 ;
bm2.bmWidthBytes 		= ((bm2.bmWidth + 15) / 16) * 2 ;

��һ������ͼ���д���hBitmap2�����Ը��ݶ�̬�ijߴ罨����

hBitmap2 = CreateBitmapIndirect (&bm2) ;

Ȼ�Ὣ����������ͼѡ������������װ�������У�

SelectObject (hdcMem1, hBitmap1) ;
SelectObject (hdcMem2, hBitmap2) ;

������ѵ�һ������ͼ���Ƹ��ڶ�������ͼ�����ڴ˳����н������졣�����StretchBlt���У�

StretchBlt (	hdcMem2, 0, 0, bm2.bmWidth, bm2.bmHeight,
       				hdcMem1, 0, 0, bm1.bmWidth, bm1.bmHeight, SRCCOPY) ;

���ڵڶ���ͼ�ʵ��������ˣ����ǿɽ����õ����ܱ��С�ʣ�µ���������ܼ򵥣�

DeleteDC (hdcMem1) ;
DeleteDC (hdcMem2) ;
DeleteObject (hBitmap1) ;

�ڽ��칦�ܱ�ʱ��GRAFMENU�е�CreateMyMenu��ʽ������StretchBitmap��GetBitmapFont��ʽ��GRAFMENU����Դ�����ж������������ܱ�����ѡ��File���͡�Edit��ѡ��ʱ�ᵯ�����������ܱ�����ʽ��ʼ��ȡ��һ���չ��ܱ��Ĵ��ţ�

hMenu = CreateMenu () ;

����Դ�������롸File����ͻ��ʽ���ܱ��������ĸ�ѡ���New������Open������Save���͡�Save as������

hMenuPopup = LoadMenu (hInstance, TEXT ("MenuFile")) ;

����Դ�����������˰�����FILE���ĵ���ͼ������StretchBitmap���������죺

hBitmapFile = StretchBitmap (LoadBitmap (hInstance, TEXT ("BitmapFile"))) ;

����ͼ���ź�ͻ��ʽ���ܱ����Ŷ���AppendMenu���еIJ�����

AppendMenu (hMenu, MF_BITMAP | MF_POPUP, hMenuPopup, (PTSTR) (LONG) 
hBitmapFile) ;

��Edit�����ܱ����Ƴ������£�

hMenuPopup 	= LoadMenu (hInstance, TEXT ("MenuEdit")) ;
hBitmapEdit 	= StretchBitmap (LoadBitmap (hInstance, TEXT ("BitmapEdit"))) ;
AppendMenu (hMenu, MF_BITMAP | MF_POPUP, hMenuPopup, (PTSTR)(LONG) hBitmapEdit) ;

����GetBitmapFont��ʽ���Թ��������ֲ�ͬ�����ͻ��ʽ���ܱ���

hMenuPopup = CreateMenu () ;
for (i = 0 ; i < 3 ; i++)
{
     	hBitmapPopFont [i] = GetBitmapFont (i) ;
     	AppendMenu (hMenuPopup, MF_BITMAP, IDM_FONT_COUR + i,
                         (PTSTR) (LONG) hMenuPopupFont [i]) ;
}

Ȼ�Ὣͻ��ʽ���ܱ����ӵ����ܱ��У�

hBitmapFont = StretchBitmap (LoadBitmap (hInstance, "BitmapFont")) ;
AppendMenu (	hMenu, MF_BITMAP | MF_POPUP, hMenuPopup, (PTSTR) (LONG) 						hBitmapFont) ;

WndProcͨ������SetMenu��������Ӵ����ܱ��Ľ���������

GRAFMENU���ı���AddHelpToSys��ʽ�е�ϵͳ���ܱ����˺�ʽ���Ȼ��һ��ϵͳ���ܱ����ţ�

hMenu = GetSystemMenu (hwnd, FALSE) ;

�⽫���롸HELP������ͼ�����������쵽�ʵ��ߴ磺

hBitmapHelp = StretchBitmap (LoadBitmap (hInstance, TEXT ("BitmapHelp"))) ;

�⽫��ϵͳ���ܱ�����һ���ָ��ߺ�����ĵ���ͼ��

AppendMenu (hMenu, MF_SEPARATOR, 0, NULL) ;
AppendMenu (hMenu, MF_BITMAP, IDM_HELP, (PTSTR)(LONG) hBitmapHelp) ;

GRAFMENU���˳�֮ǰ����һ����ʽ�������ɾ�����е���ͼ��

�������ڹ��ܱ���ʹ�õ���ͼ��һЩע�����

�ڶ��㹦�ܱ��У�Windows�������ܱ��еĸ߶�����Ӧ��ߵĵ���ͼ����������ͼ(���ִ�)�Ǹ��ݹ��ܱ��еĶ��˶���ġ�����ڶ��㹦�ܱ���ʹ���˵���ͼ����ô��ʹ�ó���SM_CYMENU��GetSystemMetrics�õ��Ĺ��ܱ��д�С��������Ч��

ִ��GRAFMENU�ڼ���Կ�������ͻ��ʽ���ܱ��У�����ʹ�ô��е���ͼ���ܱ���Ĺ�ѡ��ǣ�����ѡ����������ߴ硣��������⣬�����Խ���һ���Զ��Ĺ�ѡ��ǣ���ʹ��SetMenuItemBitmaps��

�ڹ��ܱ���ʹ�÷����֣�����ʹ�÷�ϵͳ��������֣�����һ�ַ����ǡ�ӵ���߻��ơ����ܱ���

���ܱ��ļ��̽�������һ�����⡣�����ܱ���������ʱ��Windows���Զ����Ӽ��̽��档Ҫѡ��һ�����ܱ������ʹ��Alt���ִ��е�һ����ĸ����ϼ�����һ���ڹ��ܱ��з����˵���ͼ����ɾ���˼��̽��档��ʹ����ͼ������һ���ĺ��壬��Windows����֪����

Ŀǰ���ǿ���ʹ��WM_MENUCHARѶϢ����������Alt���빦�ܱ�������һ����Ԫ������ϼ�ʱ��Windows���������Ӵ�ѶϢ������ʽ����һ��WM_MENUCHARѶϢ��GRAFMENU��Ҫ��ȡWM_MENUCHARѶϢ�����wParam��ֵ����������ASCII�룩��������ֵ��Ӧһ�����ܱ����ô��Windows����˫���飺���и�����Ϊ2������������ü���صĹ��ܱ�������ֵ��Ȼ����Windows�������µ��¡�

�Ǿ��ε���ͼͼ��
��

����ͼ���Ǿ��Σ�������Ҫ����ʾ�ɾ��Ρ����磬�ٶ�����һ�����ε���ͼͼ�񣬵���ȴ�뽫����ʾ����Բ�Ρ�

���ȣ����������ܼ򵥡���ֻ�轫ͼ������Visual C++ Developer Studio����Windows�ġ���ͼ����ʽ�����߸������Ӧ�ó�ʽ����Ȼ���ð�ɫ�Ļ��ʽ�ͼ�����ܻ��ϰ�ɫ����ʱ�����һ����Բ�ε�ͼ�񣬶���Բ������ͳ��˰�ɫ��ֻ�е�����ɫΪ��ɫʱ�˵���ͼ������ȷ��ʾ���������������ɫ����ʾ�����ͻᷢ����Բ�ε�ͼ��ͱ���֮����һ����ɫ�ľ��Ρ�����Ч�����á�

��һ�ַdz�ͨ�õļ����ɽ���������⡣���ּ������������֣�mask��������ͼ��һЩλԪӳ�������������һ�ֵ�ɫ����ͼ��������Ҫ��ʾ�ľ��ε���ͼͼ��ߴ���ͬ��ÿ�����ֵ�ͼ�ض���Ӧ����ͼͼ���һ��ͼ�ء�����ͼ����1(��ɫ)����Ӧ������ͼͼ����ʾ����0(��ɫ)������ʾ����ɫ�����������ֵ���ͼ����෴���������ʹ�õ�λԪӳ���������һЩ���Ӧ�ı仯����

�����ǿ���BITMASK��ʽ�����ʵ����һ�����ġ����ʽ14-9��ʾ��

 ï¿½ï¿½Ê½14-9  BITMASK
BITMASK.C
/*---------------------------------------------------------------------------
   	BITMASK.C -- 	Bitmap Masking Demonstration
         			(c) Charles Petzold, 1998
----------------------------------------------------------------------------*/

#include <windows.h>
LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    	PSTR szCmdLine, int iCmdShow)
{
     	static TCHAR 		szAppName [] = TEXT ("BitMask") ;
     	HWND         				hwnd ;
     	MSG          				msg ;
     	WNDCLASS     				wndclass ;

     	wndclass.style         			= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         			= LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       			= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= (HBRUSH) GetStockObject (LTGRAY_BRUSH) ;
     	wndclass.lpszMenuName  		= NULL ;
     	wndclass.lpszClassName 		= szAppName ;
     
     	if (!RegisterClass (&wndclass))
     	{
          		MessageBox (NULL, TEXT ("This program requires Windows NT!"),
                      		szAppName, MB_ICONERROR) ;
          		return 0 ;
     }
     
     	hwnd = CreateWindow (szAppName, TEXT ("Bitmap Masking Demo"), 
                          	WS_OVERLAPPEDWINDOW, 
                          	CW_USEDEFAULT, CW_USEDEFAULT,
                          	CW_USEDEFAULT, CW_USEDEFAULT,
                          	NULL, NULL, hInstance, NULL) ;

     	ShowWindow (hwnd, iCmdShow) ;
     	UpdateWindow (hwnd) ;

     	while (GetMessage (&msg, NULL, 0, 0))
     	{
          			TranslateMessage (&msg) ;
          			DispatchMessage (&msg) ;
     	}
     	return msg.wParam ;
}

LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam,LPARAM lParam)
{
     	static HBITMAP   		hBitmapImag, hBitmapMask ;
     	static HINSTANCE 		hInstance ;
     	static int       		cxClient, cyClient, cxBitmap, cyBitmap ;
     	BITMAP           		bitmap ;
     	HDC              		hdc, hdcMemImag, hdcMemMask ;
     	int              		x, y ;
     	PAINTSTRUCT      		ps ;
     
     	switch (message)
     {
     	case WM_CREATE:
          			hInstance = ((LPCREATESTRUCT) lParam)->hInstance ;
               				// Load the original image and get its size
          			hBitmapImag = LoadBitmap (hInstance, TEXT ("Matthew")) ;
          			GetObject (hBitmapImag, sizeof (BITMAP), &bitmap) ;
          			cxBitmap = bitmap.bmWidth ;
          			cyBitmap = bitmap.bmHeight ;

               				// Select the original image into a memory DC
          			hdcMemImag  = CreateCompatibleDC (NULL) ;
          			SelectObject (hdcMemImag, hBitmapImag) ;
               				// Create the monochrome mask bitmap and memory DC
          			hBitmapMask = CreateBitmap (cxBitmap, cyBitmap, 1, 1, NULL) ;
          			hdcMemMask = CreateCompatibleDC (NULL) ;
          			SelectObject (hdcMemMask, hBitmapMask) ;

               				// Color the mask bitmap black with a white ellipse
          			SelectObject (hdcMemMask, GetStockObject (BLACK_BRUSH)) ;
          			Rectangle (hdcMemMask, 0, 0, cxBitmap, cyBitmap) ;
          			SelectObject (hdcMemMask, GetStockObject (WHITE_BRUSH)) ;
          			Ellipse (hdcMemMask, 0, 0, cxBitmap, cyBitmap) ;

               				// Mask the original image
          			BitBlt (hdcMemImag, 0, 0, cxBitmap, cyBitmap, 
                  			hdcMemMask, 0, 0, SRCAND) ;
          			DeleteDC (hdcMemImag) ;
          			DeleteDC (hdcMemMask) ;
          			return 0 ;

     	case 	WM_SIZE:
          			cxClient = LOWORD (lParam) ;
          			cyClient = HIWORD (lParam) ;
          			return 0 ;

     	case 	WM_PAINT:
          			hdc = BeginPaint (hwnd, &ps) ;

              	 			// Select bitmaps into memory DCs

          			hdcMemImag = CreateCompatibleDC (hdc) ;
          			SelectObject (hdcMemImag, hBitmapImag) ;

          			hdcMemMask = CreateCompatibleDC (hdc) ;
          			SelectObject (hdcMemMask, hBitmapMask) ;

               				// Center image

          			x = (cxClient - cxBitmap) / 2 ;
          			y = (cyClient - cyBitmap) / 2 ;
               
               				// Do the bitblts

          			BitBlt (hdc, x, y, cxBitmap, cyBitmap, hdcMemMask, 0, 0, 0x220326) ;
          			BitBlt (hdc, x, y, cxBitmap, cyBitmap, hdcMemImag, 0, 0, SRCPAINT) ;

          			DeleteDC (hdcMemImag) ;
          			DeleteDC (hdcMemMask) ;
          			EndPaint (hwnd, &ps) ;
          			return 0 ;

     	case 	WM_DESTROY:
          			DeleteObject (hBitmapImag) ;
          			DeleteObject (hBitmapMask) ;
          			PostQuitMessage (0) ;
          			return 0 ;
     }
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}
 BITMASK.RC
// Microsoft Developer Studio generated resource script.
#include "resource.h"
#include "afxres.h"

/////////////////////////////////////////////////////////////////////////////
// Bitmap
MATTHEW                 BITMAP  	DISCARDABLE     "matthew.bmp"

��Դ�����е�MATTHEW.BMP��������ֶ�ӵ�һ���ڰ���λ��Ƭ����200ͼ�أ���320ͼ�أ�ÿͼ��8λԪ������������������BITMASKֻ����Ϊ�˵������������κζ��������ԡ�

ע�⣬BITMASK���Ӵ�������Ϊ����ɫ��������ȷ����������ȷ�����ֵ���ͼ������ֻ�ǽ���Ϳ�ɰ�ɫ��

���������ǿ�һ��WM_CREATE�Ĵ�������BITMASK��LoadBitmap��ʽ���hBitmapImag������ԭʼͼ��Ĵ��š���GetObject��ʽ��ȡ�õ���ͼ�Ŀ��ȸ߶ȡ�Ȼ�Ὣ����ͼ����ѡ������ΪhdcMemImag�ļ�����װ�������С�

��ʽ��������һ����ɫ����ͼ��ԭ����ͼ��С��ͬ������Ŵ�����hBitmapMask����ѡ������ΪhdcMemMask�ļ�����װ�������С��ڼ�����װ�������У�ʹ��GDI��ʽ�����ֵ���ͼ��Ϳ���˺�ɫ������һ����ɫ����Բ��

SelectObject (hdcMemMask, GetStockObject (BLACK_BRUSH)) ;
Rectangle (hdcMemMask, 0, 0, cxBitmap, cyBitmap) ;
SelectObject (hdcMemMask, GetStockObject (WHITE_BRUSH)) ;
Ellipse (hdcMemMask, 0, 0, cxBitmap, cyBitmap) ;

��Ϊ����һ����ɫ�ĵ���ͼ�����Ժ�ɫ�����λԪ��0������ɫ�����λԪ��1��

Ȼ��BitBlt���оͰ��������޸���ԭͼ��

BitBlt (hdcMemImag, 0, 0, cxBitmap, cyBitmap, 
        			hdcMemMask, 0, 0, SRCAND) ;

SRCANDλԪӳ���������ԴλԪ�����ֵ���ͼ����Ŀ��λԪ��ԭͼ��֮��ִ����λԪAND������ֻҪ���ֵ���ͼ�ǰ�ɫ������ʾĿ�ģ�ֻҪ�����Ǻ�ɫ����Ŀ�ľ�Ҳ�Ǻ�ɫ������ԭͼ���о��γ���һ����ɫ��Χ����Բ����

���������ǿ�һ��WM_PAINT�������򡣴˳���ͬʱ�ı���ѡ��������װ�������е�ͼ�����ͼ�����ֵ���ͼ������BitBlt������������ħ������һ�����Ӵ���ִ�����ֵ���ͼ��BitBlt��

BitBlt (hdc, x, y, cxBitmap, cyBitmap, hdcMemMask, 0, 0, 0x220326) ;

����ʹ����һ��û�����Ƶ�λԪӳ��������߼���������D & ~S��������Դ�������ֵ���ͼ���Ǻ�ɫ��λԪֵ0����Χ��һ����ɫ��λԪֵ1����Բ��λԪӳ��������Ƚ���Դ��ɫ��Ҳ���Ǹijɰ�ɫ��Χ�ĺ�ɫ��Բ��Ȼ��λԪ�����������ת������Դ��Ŀ�ģ����Ӵ��ϣ�֮��ִ��λԪAND��������Ŀ�ĺ�λԪֵ1��AND��ʱ���ֲ��䣻��λԪֵ0��AND��ʱ��Ŀ�Ľ���ڡ���ˣ�BitBlt���������Ӵ��ϻ�һ����ɫ����Բ��

�ڶ��ε�BitBlt���������Ӵ��л���ͼ�����ͼ��

BitBlt (hdc, x, y, cxBitmap, cyBitmap, hdcMemImag, 0, 0, SRCPAINT) ;

λԪӳ���������Դ��Ŀ��֮��ִ��λԪ��OR�������������Դ����ͼ�������Ǻ�ɫ����˱���Ŀ�IJ��䣻������Բ�����ڣ�Ŀ���Ǻ�ɫ�����ͼ���ԭ�ⲻ���ظ����˹�����ִ�н����ͼ14-9��ʾ��

ע�����

��ʱ����Ҫһ���ܸ��ӵ����֣����磬Ĩȥԭʼͼ�������������������Ҫ�ڻ�ͼ��ʽ���ֹ�����Ȼ�Ὣ�䴢�浽�ɵ�����


��

ͼ14-9 BITMASK��өĻ��ʾ

�������ΪWindows NT��д���Ƶ�Ӧ�ó�ʽ����ô������ʹ����MASKBIT��ʽ���Ƶ�MaskBlt��ʽ����ֻ��Ҫ���ٵĺ�ʽ���С�Windows NT��������һ������BitBlt�ĺ�ʽ��Windows 98��֧Ԯ�ú�ʽ���˺�ʽ��PlgBlt����ƽ���ı���λԪ���ƶ���parallelogram blt�����������ʽ���Զ�ͼ�������ת������б����ͼͼ��

���ᣬ��������Ļ�����ִ��BITMASK��ʽ������ֻ�ῴ����ɫ����ɫ��������ɫ����Ӱ��������Ϊ��ִ�е���ʾģʽ��16ɫ��256ɫ�����16ɫģʽ����ʾЧ���޷��Ľ�������256ɫģʽ�¿��Ըı��ɫ������ʾ�ҽס������ڵ�ʮ����ѧ������趨��ɫ�̡�

�򵥵Ķ���
��

С�ŵĵ���ͼ��ʾ�����dz��죬��˿��Խ�����ͼ��Windows��ʱ������ʹ�ã������һЩ�����Ķ�����

���ڿ�ʼ��������ʽ��

BOUNCE��ʽ�����ʽ14-10��ʾ��������һ�����Ӵ���ʾ��������ȥ��С�򡣸ó�ʽ���ü�ʱ��������С����н��ٶȡ�С������һ������ͼ����ʽ����ͨ����������ͼ������С�򣬽���ѡ��������װ�����ݣ�Ȼ�����һЩ�򵥵�GDI��ʽ����ʽ��BitBlt��һ��������װ�����ݽ��������ͼС�򻭵���ʾ���ϡ�

 ï¿½ï¿½Ê½14-10  BOUNCE
BOUNCE.C
/*---------------------------------------------------------------------------
   	BOUNCE.C -- 	Bouncing Ball Program
               						(c) Charles Petzold, 1998
----------------------------------------------------------------------------*/

#include <windows.h>
#define ID_TIMER    1

LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
     	static TCHAR szAppName[] = TEXT ("Bounce") ;
     	HWND         				hwnd ;
     	MSG          				msg ;
     	WNDCLASS     				wndclass ;

     	wndclass.style         			= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         			= LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       			= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= (HBRUSH) GetStockObject (WHITE_BRUSH) ;
     	wndclass.lpszMenuName  		= NULL ;
     	wndclass.lpszClassName 		= szAppName ;
     
     	if (!RegisterClass (&wndclass))
     	{
          		MessageBox (	NULL, TEXT ("This program requires Windows NT!"),
                      							szAppName, MB_ICONERROR) ;
          		return 0 ;
     	}
     
     	hwnd = CreateWindow (	szAppName, TEXT ("Bouncing Ball"),
                          		WS_OVERLAPPEDWINDOW,
                          		CW_USEDEFAULT, CW_USEDEFAULT,
                          		CW_USEDEFAULT, CW_USEDEFAULT,
                          		NULL, NULL, hInstance, NULL) ;
     
     	ShowWindow (hwnd, iCmdShow) ;
     	UpdateWindow (hwnd) ;
     	while (GetMessage (&msg, NULL, 0, 0))
     	{
          		TranslateMessage (&msg) ;
          		DispatchMessage (&msg) ;
     	}
     	return msg.wParam ;
}

LRESULT CALLBACK WndProc (HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
{
     	static HBITMAP 	hBitmap ;
     	static int	 		cxClient, cyClient, xCenter, yCenter, cxTotal, cyTotal,
                    	cxRadius, 			cyRadius, cxMove, cyMove, xPixel, yPixel ;
     	HBRUSH         				hBrush ;
     	HDC            				hdc, hdcMem ;
     	int            				iScale ;
     
     	switch (iMsg)
     	{
     	case 	WM_CREATE:
          			hdc = GetDC (hwnd) ;
          			xPixel = GetDeviceCaps (hdc, ASPECTX) ;
          			yPixel = GetDeviceCaps (hdc, ASPECTY) ;
          			ReleaseDC (hwnd, hdc) ;
          
          			SetTimer (hwnd, ID_TIMER, 50, NULL) ;
          			return 0 ;
          
     	case 	WM_SIZE:
          			xCenter = (cxClient = LOWORD (lParam)) / 2 ;
          			yCenter = (cyClient = HIWORD (lParam)) / 2 ;
          
          			iScale = min (cxClient * xPixel, cyClient * yPixel) / 16 ;
          
          			cxRadius = iScale / xPixel ;
          			cyRadius = iScale / yPixel ;
          
          			cxMove = max (1, cxRadius / 2) ;
          			cyMove = max (1, cyRadius / 2) ;
          
          			cxTotal = 2 * (cxRadius + cxMove) ;
          			cyTotal = 2 * (cyRadius + cyMove) ;
          
          			if (hBitmap)
               					DeleteObject (hBitmap) ;
          			hdc = GetDC (hwnd) ;
          			hdcMem = CreateCompatibleDC (hdc) ;
          			hBitmap = CreateCompatibleBitmap (hdc, cxTotal, cyTotal) ;
          			ReleaseDC (hwnd, hdc) ;
          
          			SelectObject (hdcMem, hBitmap) ;
          			Rectangle (hdcMem, -1, -1, cxTotal + 1, cyTotal + 1) ;
          
          			hBrush = CreateHatchBrush (HS_DIAGCROSS, 0L) ;
          			SelectObject (hdcMem, hBrush) ;
          			SetBkColor (hdcMem, RGB (255, 0, 255)) ;
          			Ellipse (hdcMem, cxMove, cyMove, cxTotal - cxMove, cyTotal - cyMove) ;
          			DeleteDC (hdcMem) ;
          			DeleteObject (hBrush) ;
          			return 0 ;
          
     	case 	WM_TIMER:
          			if (!hBitmap)
               					break ;
          
          			hdc = GetDC (hwnd) ;
          			hdcMem = CreateCompatibleDC (hdc) ;
          			SelectObject (hdcMem, hBitmap) ;
          
          			BitBlt (hdc, xCenter - cxTotal / 2,
                       					yCenter - cyTotal / 2, cxTotal, cyTotal,
                  						hdcMem, 0, 0, SRCCOPY) ;
          
          			ReleaseDC (hwnd, hdc) ;
          			DeleteDC (hdcMem) ;
          
          			xCenter += cxMove ;
          			yCenter += cyMove ;
          
          			if ((xCenter + cxRadius >= cxClient) || (xCenter - cxRadius <= 0))
               					cxMove = -cxMove ;
          
          			if ((yCenter + cyRadius >= cyClient) || (yCenter - cyRadius <= 0))
               					cyMove = -cyMove ;
          
          			return 0 ;
          
     	case 	WM_DESTROY:
          			if (hBitmap)
               					DeleteObject (hBitmap) ;
          
          			KillTimer (hwnd, ID_TIMER) ;
          			PostQuitMessage (0) ;
          			return 0 ;
     }
     	return DefWindowProc (hwnd, iMsg, wParam, lParam) ;
}

BOUNCEÿ���յ�һ��WM_SIZEѶϢʱ���ػ�С�������Ҫ����Ѷ��ʾ�����ݵļ�����װ�����ݣ�

hdcMem = CreateCompatibleDC (hdc) ;

С���ֱ����Ϊ�Ӵ���ʾ����߶Ȼ�����н϶��ߵ�ʮ����֮һ����������ʽ����ĵ���ͼȴ��С��󣺴ӵ���ͼ���ĵ�����ͼ�ĸ��ߵľ�����С��뾶��1.5����

hBitmap = CreateCompatibleBitmap (hdc, cxTotal, cyTotal) ;

������ͼѡ��������װ�������ᣬ��������ͼ������ɰ�ɫ��

Rectangle (hdcMem, -1, -1, xTotal + 1, yTotal + 1) ;

��Щ���̶�������ʹ���α߿��ڵ���ͼ֮����ɫ��һ���Խ��߿��ڵĻ�ˢѡ��������װ�����ݣ�����С���ڵ���ͼ�����룺

Ellipse (hdcMem, xMove, yMove, xTotal - xMove, yTotal - yMove) ;

��С���ƶ�ʱ��С��߽�Ŀհ׻���Ч��ɾ��ǰһʱ�̵�С��ͼ������һ��λ���ػ�С��ֻ����BitBlt������ʹ��SRCCOPY��ROP���룺

BitBlt (hdc, xCenter - cxTotal / 2, yCenter - cyTotal / 2, cxTotal, cyTotal,
        		hdcMem, 0, 0, SRCCOPY) ;

BOUNCE��ʽֻ��չʾ������ʾ�����ƶ�ͼ�����򵥵ķ�������һ������£����ַ����������������⡣������Զ�������Ȥ����ô��������Դ��Ŀ��֮��ִ�л�������⣬����Ӧ���о�������ROP���루����SRCINVERT��������������������Windows��ɫ�̣��Լ�AnimatePalette��ʽ����CreateDIBSection��ʽ����춸��߼��Ķ�����ֻ�÷���GDI��ʹ��DirectX�����ˡ�

�Ӵ���ĵ���ͼ
��

SCRAMBLE��ʽ�����ʽ14-11��ʾ����д�dz��ֲڣ��ұ�����Ӧ��չʾ�����ʽ������ʾ����һЩ��Ȥ�ļ����������ڽ���������ʾ�������ݵ�BitBlt�����ij����У��ü�����װ��������Ϊ��ʱ����ռ䡣

 ï¿½ï¿½Ê½14-11  SCRAMBLE
SCRAMBLE.C
/*---------------------------------------------------------------------------
   SCRAMBLE.C --	Scramble (and Unscramble) Screen
         							(c) Charles Petzold, 1998
-----------------------------------------------------------------------------*/

#include <windows.h>

#define NUM 300

LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
     	static int 		iKeep [NUM][4] ;
     	HDC        				hdcScr, hdcMem ;
     	int        				cx, cy ;
     	HBITMAP    			hBitmap ;
     	HWND       				hwnd ;
     	int        				i, j, x1, y1, x2, y2 ;

     	if (LockWindowUpdate (hwnd = GetDesktopWindow ()))
     	{
          		hdcScr	= GetDCEx (hwnd, NULL, DCX_CACHE | DCX_LOCKWINDOWUPDATE) ;
          		hdcMem 	= CreateCompatibleDC (hdcScr) ;
          		cx      = GetSystemMetrics (SM_CXSCREEN) / 10 ;
          		cy      = GetSystemMetrics (SM_CYSCREEN) / 10 ;
          		hBitmap = CreateCompatibleBitmap (hdcScr, cx, cy) ;
         
          		SelectObject (hdcMem, hBitmap) ;
		srand ((int) GetCurrentTime ()) ;
          
          		for (i = 0 ; i < 2   ; i++)
          		for (j = 0 ; j < NUM ; j++)
          		{
               			if (i == 0)
               			{
                    			iKeep [j] [0] = x1 = cx * (rand () % 10) ;
                    			iKeep [j] [1] = y1 = cy * (rand () % 10) ;
                    			iKeep [j] [2] = x2 = cx * (rand () % 10) ;
                    			iKeep [j] [3] = y2 = cy * (rand () % 10) ;
               			}
               			else
         			{
                    				x1 = iKeep [NUM - 1 - j] [0] ;
                    				y1 = iKeep [NUM - 1 - j] [1] ;
                    				x2 = iKeep [NUM - 1 - j] [2] ;
                    				y2 = iKeep [NUM - 1 - j] [3] ;
               			}
               			BitBlt (hdcMem,  0,  0, cx, cy, hdcScr, x1, y1, SRCCOPY) ;
               			BitBlt (hdcScr, x1, y1, cx, cy, hdcScr, x2, y2, SRCCOPY) ;
               			BitBlt (hdcScr, x2, y2, cx, cy, hdcMem,  0,  0, SRCCOPY) ;
                    
               		Sleep (10) ;
          		}
               
          		DeleteDC (hdcMem) ;
          		ReleaseDC (hwnd, hdcScr) ;
          		DeleteObject (hBitmap) ;
             
          		LockWindowUpdate (NULL) ;
     	}
     	return FALSE ;
}

SCRAMBLEû���Ӵ�ѶϢ������ʽ����WinMain�У������Ⱥ��д��������Ӵ����ŵ�LockWindowUpdate���˺�ʽ��ʱ��ֹ������ʽ����өĻ��Ȼ��SCRAMBLEͨ�����д��в���DCX_LOCKWINDOWUPDATE��GetDCEx���������өĻ��װ�����ݡ�������ֻ��SCRAMBLE���Ը���өĻ�ˡ�

Ȼ��SCRAMBLEȷ��ȫөĻ�ijߴ磬���������ֱ����10����ʽ������ߴ磨������cx��cy��������һ������ͼ�������õ���ͼѡ��������װ�����ݡ�

ʹ��C���Ե�rand��ʽ��SCRAMBLE������ĸ����ֵ����������㣩��Ϊcx��cy�ı�������ʽ͸�����κ���BitBlt��ʽ�������������ο�����ʾ�����ݡ���һ�ν��ӵ�һ������㿪ʼ�ľ��θ��Ƶ�������װ�����ݡ��ڶ���BitBlt���ӵڶ�����㿪ʼ�ľ��θ��Ƶ���һ�㿪ʼ��λ�á������ν�������װ�������еľ��θ��Ƶ��ڶ�������㿪ʼ������

�˳�����Ч�ؽ�����ʾ�������������е����ݡ�SCRAMBLEִ��300�ν�������ʱ��өĻ��ʾ�϶���һ���㡣�����õ��ģ���ΪSCRAMBLE�ǵ�����ô����ʾŪ������һ����ģ��������˳�ǰ���ᰴ�෴�Ĵ���ָ�ԭ����������ʾ������өĻǰ�Ļ��棩!

��Ҳ�����ü�����װ�����ݽ�һ������ͼ���Ƹ���һ������ͼ�����磬�ٶ���Ҫ����һ������ͼ���õ���ͼֻ������һ������ͼ���Ͻǵ�ͼ�Ρ����ԭ����ͼ�����ΪhBitmap����ô�����Խ���ߴ縴�Ƶ�һ��BITMAP��̬�Ľṹ�У�

GetObject (hBitmap, sizeof (BITMAP), &bm) ;

Ȼ�Ὠ��һ��δ��ʼ�����µ���ͼ���õ���ͼ�ijߴ���ԭ��ͼ��1/4��

hBitmap2 = CreateBitmap (	bm.bmWidth / 2, bm.bmHeight / 2,
                         	bm.bmPlanes, bm.bmBitsPixel, NULL) ;

���ڽ�������������װ�����ݣ�����ԭ������ͼ���µ���ͼѡ�ֱ��������������װ�����ݣ�

hdcMem1 = CreateCompatibleDC (hdc) ;
hdcMem2 = CreateCompatibleDC (hdc) ;

SelectObject (hdcMem1, hBitmap) ;
SelectObject (hdcMem2, hBitmap2) ;

���ᣬ����һ������ͼ�����ϽǸ��Ƹ��ڶ�����

BitBlt (	hdcMem2, 0, 0, bm.bmWidth / 2, bm.bmHeight / 2,
        			hdcMem1, 0, 0, SRCCOPY) ;

ʣ�µ�ֻ�����������

DeleteDC (hdcMem1) ;
DeleteDC (hdcMem2) ;
DeleteObject (hBitmap) ;

BLOWUP.C��ʽ����ͼ14-21��ʾ��Ҳ���Ӵ������������ڳ�ʽ�Ӵ�֮����ʾһ����׽�ľ��Ρ��˳�ʽ����ʹ�����û���ȦѡөĻ�ϵľ�������Ȼ��BLOWUP������������ݸ��Ƶ�����ͼ����WM_PAINTѶϢ�����ڼ䣬����ͼ���Ƶ���ʽ����ʾ���򣬱�Ҫʱ�������ѹ�������μ���ʽ14-12����

 ï¿½ï¿½Ê½14-12  BLOWUP
BLOWUP.C
/*--------------------------------------------------------------------------
   	BLOWUP.C -- 	Video Magnifier Program
               						(c) Charles Petzold, 1998
----------------------------------------------------------------------------*/

#include <windows.h>	
#include <stdlib.h>      					// for abs definition
#include "resource.h"	
LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;

int WINAPI WinMain (HINSTANCE hI