home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / x / volume10 / xv / part03 < prev    next >
Text File  |  1990-12-08  |  66KB  |  1,617 lines
  1. Path: uunet!fernwood!apple!sun-barr!newstop!exodus!appserv!halibut.cis.upenn.edu
  2. From: bradley@halibut.cis.upenn.edu (John Bradley)
  3. Newsgroups: comp.sources.x
  4. Subject: v10i081: xv - display and manipulate images, Part03/10
  5. Message-ID: <319@appserv.Eng.Sun.COM>
  6. Date: 27 Nov 90 20:08:15 GMT
  7. References: <csx-10i079:xv@uunet.UU.NET>
  8. Sender: news@exodus.Eng.Sun.COM
  9. Lines: 1600
  10. Approved: argv@sun.com
  11.  
  12. Submitted-by: bradley@halibut.cis.upenn.edu (John Bradley)
  13. Posting-number: Volume 10, Issue 81
  14. Archive-name: xv/part03
  15.  
  16. #!/bin/sh
  17. # to extract, remove the header and type "sh filename"
  18. if `test ! -d ./bitmaps`
  19. then
  20.   mkdir ./bitmaps
  21.   echo "mkdir ./bitmaps"
  22. fi
  23. if `test ! -s ./bitmaps/down`
  24. then
  25. echo "writting ./bitmaps/down"
  26. cat > ./bitmaps/down << '\BARFOO\'
  27. #define down_width 16
  28. #define down_height 16
  29. static char down_bits[] = {
  30.    0xff, 0xff, 0x01, 0x80, 0x01, 0x80, 0xf1, 0x87, 0x11, 0x84, 0x11, 0x84,
  31.    0x11, 0x84, 0x1f, 0xbc, 0x05, 0x90, 0x09, 0x88, 0x11, 0x84, 0x21, 0x82,
  32.    0x41, 0x81, 0x81, 0x80, 0x01, 0x80, 0xff, 0xff};
  33. \BARFOO\
  34. else
  35.   echo "will not over write ./bitmaps/down"
  36. fi
  37. if `test ! -s ./bitmaps/down1`
  38. then
  39. echo "writting ./bitmaps/down1"
  40. cat > ./bitmaps/down1 << '\BARFOO\'
  41. #define down1_width 16
  42. #define down1_height 16
  43. static char down1_bits[] = {
  44.    0xff, 0xff, 0x01, 0x80, 0x01, 0x80, 0xf1, 0x87, 0xf1, 0x87, 0xf1, 0x87,
  45.    0xf1, 0x87, 0xff, 0xbf, 0xfd, 0x9f, 0xf9, 0x8f, 0xf1, 0x87, 0xe1, 0x83,
  46.    0xc1, 0x81, 0x81, 0x80, 0x01, 0x80, 0xff, 0xff};
  47. \BARFOO\
  48. else
  49.   echo "will not over write ./bitmaps/down1"
  50. fi
  51. if `test ! -s ./bitmaps/grasp`
  52. then
  53. echo "writting ./bitmaps/grasp"
  54. cat > ./bitmaps/grasp << '\BARFOO\'
  55. #define grasp_width 64
  56. #define grasp_height 64
  57. static char grasp_bits[] = {
  58.    0x00, 0x00, 0x00, 0xbf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff,
  59.    0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff, 0xff, 0x05, 0x00, 0x00,
  60.    0x00, 0x00, 0xfc, 0xff, 0xff, 0xbf, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff,
  61.    0xff, 0xff, 0x01, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0x03, 0x00,
  62.    0x00, 0xe0, 0xff, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0xf0, 0xff, 0xff,
  63.    0xff, 0xff, 0x0f, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00,
  64.    0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0xc0, 0xff, 0xff, 0xff,
  65.    0xff, 0xff, 0x7f, 0x00, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
  66.    0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0xfe, 0xff, 0xff, 0x07,
  67.    0x54, 0xff, 0xff, 0x03, 0xff, 0xff, 0xff, 0x03, 0x00, 0xc0, 0xff, 0x07,
  68.    0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0xff, 0x0f, 0xff, 0xff, 0xff, 0x00,
  69.    0x00, 0x00, 0xfe, 0x1f, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0xf8, 0x3f,
  70.    0xff, 0xff, 0x3f, 0x00, 0x00, 0x00, 0xe0, 0x7f, 0xff, 0xff, 0x1f, 0x00,
  71.    0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00,
  72.    0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x03, 0x00,
  73.    0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf9, 0xf8, 0x01, 0x03, 0x8f, 0x3f,
  74.    0xff, 0xff, 0xfc, 0xf9, 0x83, 0x83, 0x9f, 0x7f, 0xff, 0x7f, 0xfe, 0xfb,
  75.    0x87, 0xc7, 0xbf, 0x7f, 0xff, 0x3f, 0x8e, 0x3b, 0xc7, 0xc7, 0xb9, 0x73,
  76.    0x00, 0x00, 0x0e, 0x38, 0xc7, 0xce, 0x83, 0x73, 0x00, 0x00, 0xee, 0xbb,
  77.    0xc7, 0x8e, 0x8f, 0x7b, 0x00, 0x00, 0xee, 0xfb, 0xe3, 0x0f, 0x9f, 0x3f,
  78.    0x00, 0x00, 0x8e, 0xfb, 0xe1, 0x1f, 0xb8, 0x1f, 0x00, 0x00, 0x9e, 0xbb,
  79.    0xe3, 0xde, 0xb9, 0x03, 0x00, 0x00, 0xfc, 0xbb, 0x73, 0xdc, 0xbf, 0x03,
  80.    0x00, 0x00, 0xfc, 0x39, 0x77, 0xb8, 0x9f, 0x03, 0x00, 0x00, 0xf0, 0x38,
  81.    0x77, 0x38, 0x8f, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  82.    0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x3f, 0x10, 0x20,
  83.    0x00, 0x40, 0x00, 0x00, 0xff, 0x7f, 0x10, 0xec, 0xee, 0xec, 0xee, 0x0a,
  84.    0xff, 0xff, 0x10, 0xaa, 0x2a, 0x4a, 0x2a, 0x0a, 0xff, 0xff, 0xf1, 0xfe,
  85.    0x2e, 0xde, 0x2e, 0x0e, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x08,
  86.    0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x06, 0xff, 0xff, 0x0f, 0x00,
  87.    0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00,
  88.    0xff, 0xff, 0x3f, 0x00, 0x00, 0x00, 0xe0, 0x7f, 0xff, 0xff, 0x7f, 0x00,
  89.    0x00, 0x00, 0xf8, 0x3f, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xfe, 0x1f,
  90.    0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0xff, 0x0f, 0xff, 0xff, 0xff, 0x03,
  91.    0x00, 0xc0, 0xff, 0x07, 0xfe, 0xff, 0xff, 0x07, 0x54, 0xff, 0xff, 0x03,
  92.    0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0xe0, 0xff, 0xff, 0xff,
  93.    0xff, 0xff, 0xff, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x00,
  94.    0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x00, 0xfc, 0xff, 0xff,
  95.    0xff, 0xff, 0x1f, 0x00, 0x00, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x0f, 0x00,
  96.    0x00, 0xe0, 0xff, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x80, 0xff, 0xff,
  97.    0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xff, 0xff, 0x01, 0x00,
  98.    0x00, 0x00, 0xf8, 0xff, 0xff, 0xbf, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xff,
  99.    0xff, 0x05, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0x17, 0x00, 0x00, 0x00,
  100.    0x00, 0x00, 0x00, 0xbf, 0x00, 0x00, 0x00, 0x00};
  101. \BARFOO\
  102. else
  103.   echo "will not over write ./bitmaps/grasp"
  104. fi
  105. if `test ! -s ./bitmaps/penn`
  106. then
  107. echo "writting ./bitmaps/penn"
  108. cat > ./bitmaps/penn << '\BARFOO\'
  109. #define penn_width 64
  110. #define penn_height 64
  111. static char penn_bits[] = {
  112.    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  113.    0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00,
  114.    0x00, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x00, 0x18, 0x00, 0x00,
  115.    0x00, 0x00, 0x18, 0x00, 0x00, 0xd8, 0xff, 0xff, 0xff, 0xff, 0x1b, 0x00,
  116.    0x00, 0xd8, 0xff, 0xff, 0xff, 0xff, 0x1b, 0x00, 0x00, 0xd8, 0xab, 0xff,
  117.    0xff, 0xd5, 0x1b, 0x00, 0x00, 0x58, 0x7d, 0xfd, 0xbf, 0xbe, 0x1a, 0x00,
  118.    0x00, 0xd8, 0x93, 0x1f, 0xf7, 0xc9, 0x1b, 0x00, 0x00, 0x58, 0x01, 0x0d,
  119.    0xb2, 0x80, 0x1a, 0x00, 0x00, 0xd8, 0x11, 0xef, 0xee, 0x88, 0x1b, 0x00,
  120.    0x00, 0x58, 0x01, 0x15, 0xad, 0x80, 0x1a, 0x00, 0x00, 0xd8, 0x11, 0x67,
  121.    0xe2, 0x88, 0x1b, 0x00, 0x00, 0x58, 0x01, 0xf5, 0xb1, 0x80, 0x1a, 0x00,
  122.    0x00, 0xd8, 0x39, 0xff, 0xff, 0x9c, 0x1b, 0x00, 0x00, 0x58, 0xff, 0xfd,
  123.    0xbf, 0xff, 0x1a, 0x00, 0x00, 0xd8, 0xaa, 0xfe, 0x7f, 0x55, 0x1b, 0x00,
  124.    0x00, 0xd8, 0xff, 0xff, 0xff, 0xff, 0x1b, 0x00, 0x00, 0xd8, 0xff, 0xff,
  125.    0xff, 0xff, 0x1b, 0x00, 0x00, 0xd8, 0xff, 0xff, 0xff, 0xff, 0x1b, 0x00,
  126.    0x00, 0x58, 0x00, 0x80, 0x01, 0x00, 0x1a, 0x00, 0x00, 0x58, 0x00, 0xc0,
  127.    0x03, 0x00, 0x1a, 0x00, 0x00, 0x58, 0x00, 0xe0, 0x07, 0x00, 0x1a, 0x00,
  128.    0x00, 0x58, 0x00, 0xf0, 0x0f, 0x00, 0x1a, 0x00, 0x00, 0x58, 0x00, 0xf8,
  129.    0x1f, 0x00, 0x1a, 0x00, 0x00, 0x58, 0x00, 0x7c, 0x3e, 0x00, 0x1a, 0x00,
  130.    0x00, 0x58, 0x00, 0x1e, 0x78, 0x00, 0x1a, 0x00, 0x00, 0x98, 0x00, 0x1f,
  131.    0xf8, 0x00, 0x19, 0x00, 0x00, 0xb8, 0x80, 0x0f, 0xf0, 0x01, 0x1d, 0x00,
  132.    0x00, 0xb0, 0xc0, 0x0f, 0xf0, 0x03, 0x0d, 0x00, 0x00, 0xb0, 0xe0, 0x1f,
  133.    0xf8, 0x07, 0x0d, 0x00, 0x00, 0xb0, 0xf0, 0x1f, 0xf8, 0x0f, 0x0d, 0x00,
  134.    0x00, 0x30, 0x79, 0x7e, 0x7e, 0x9e, 0x0c, 0x00, 0x00, 0x60, 0x1d, 0xf8,
  135.    0x1f, 0xb8, 0x06, 0x00, 0x00, 0x60, 0x1f, 0xf8, 0x1f, 0xf8, 0x06, 0x00,
  136.    0x00, 0x60, 0x0e, 0xf0, 0x0f, 0x70, 0x06, 0x00, 0x00, 0xc0, 0x0e, 0xf0,
  137.    0x0f, 0x70, 0x03, 0x00, 0x00, 0xc0, 0x1c, 0x78, 0x1e, 0x38, 0x03, 0x00,
  138.    0x00, 0x80, 0x1d, 0x38, 0x1c, 0xb8, 0x01, 0x00, 0x00, 0x80, 0x79, 0x1e,
  139.    0x78, 0x9e, 0x01, 0x00, 0x00, 0x00, 0xfb, 0x0f, 0xf0, 0xdf, 0x00, 0x00,
  140.    0x00, 0x00, 0xf3, 0x07, 0xe0, 0xcf, 0x00, 0x00, 0x00, 0x00, 0xe6, 0x03,
  141.    0xc0, 0x67, 0x00, 0x00, 0x00, 0x00, 0xec, 0x01, 0x80, 0x37, 0x00, 0x00,
  142.    0x00, 0x00, 0xcc, 0x00, 0x00, 0x33, 0x00, 0x00, 0x3c, 0x00, 0x98, 0x00,
  143.    0x00, 0x19, 0x00, 0x3c, 0x6e, 0x78, 0x30, 0x01, 0x80, 0x0c, 0x1e, 0x76,
  144.    0xda, 0x87, 0x60, 0x06, 0x60, 0x06, 0xe1, 0x5b, 0xfa, 0x88, 0xc1, 0x08,
  145.    0x10, 0x83, 0x19, 0x5f, 0x1a, 0x46, 0x81, 0x33, 0xcc, 0x81, 0x72, 0x59,
  146.    0xda, 0x70, 0x01, 0xc7, 0xe3, 0x80, 0x0e, 0x59, 0x96, 0xbf, 0x01, 0x1c,
  147.    0x38, 0x80, 0xfd, 0x69, 0x60, 0x8a, 0x07, 0x78, 0x1e, 0xe0, 0x59, 0x06,
  148.    0xc0, 0xcb, 0x1d, 0xe0, 0x07, 0xb8, 0xd3, 0x03, 0xc0, 0x69, 0xf0, 0x80,
  149.    0x01, 0x0f, 0x96, 0x03, 0x00, 0x08, 0x09, 0x1f, 0xf8, 0x60, 0x10, 0x00,
  150.    0x00, 0x90, 0x5d, 0xe0, 0x07, 0xf6, 0x08, 0x00, 0x00, 0x60, 0x48, 0x0b,
  151.    0xd0, 0x16, 0x06, 0x00, 0x00, 0x80, 0x25, 0xe3, 0xdc, 0x87, 0x01, 0x00,
  152.    0x00, 0x00, 0x8e, 0xe4, 0x94, 0x70, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x01,
  153.    0x80, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x7f, 0x00, 0x00, 0x00,
  154.    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
  155. \BARFOO\
  156. else
  157.   echo "will not over write ./bitmaps/penn"
  158. fi
  159. if `test ! -s ./bitmaps/scrlgray`
  160. then
  161. echo "writting ./bitmaps/scrlgray"
  162. cat > ./bitmaps/scrlgray << '\BARFOO\'
  163. #define scrlgray_width 8
  164. #define scrlgray_height 8
  165. static char scrlgray_bits[] = {
  166.    0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44};
  167. \BARFOO\
  168. else
  169.   echo "will not over write ./bitmaps/scrlgray"
  170. fi
  171. if `test ! -s ./bitmaps/up`
  172. then
  173. echo "writting ./bitmaps/up"
  174. cat > ./bitmaps/up << '\BARFOO\'
  175. #define up_width 16
  176. #define up_height 16
  177. static char up_bits[] = {
  178.    0xff, 0xff, 0x01, 0x80, 0x81, 0x80, 0x41, 0x81, 0x21, 0x82, 0x11, 0x84,
  179.    0x09, 0x88, 0x05, 0x90, 0x1f, 0xbc, 0x11, 0x84, 0x11, 0x84, 0x11, 0x84,
  180.    0xf1, 0x87, 0x01, 0x80, 0x01, 0x80, 0xff, 0xff};
  181. \BARFOO\
  182. else
  183.   echo "will not over write ./bitmaps/up"
  184. fi
  185. if `test ! -s ./bitmaps/up1`
  186. then
  187. echo "writting ./bitmaps/up1"
  188. cat > ./bitmaps/up1 << '\BARFOO\'
  189. #define up1_width 16
  190. #define up1_height 16
  191. static char up1_bits[] = {
  192.    0xff, 0xff, 0x01, 0x80, 0x81, 0x80, 0xc1, 0x81, 0xe1, 0x83, 0xf1, 0x87,
  193.    0xf9, 0x8f, 0xfd, 0x9f, 0xff, 0xbf, 0xf1, 0x87, 0xf1, 0x87, 0xf1, 0x87,
  194.    0xf1, 0x87, 0x01, 0x80, 0x01, 0x80, 0xff, 0xff};
  195. \BARFOO\
  196. else
  197.   echo "will not over write ./bitmaps/up1"
  198. fi
  199. if `test ! -s ./bitmaps/gray50`
  200. then
  201. echo "writting ./bitmaps/gray50"
  202. cat > ./bitmaps/gray50 << '\BARFOO\'
  203. #define gray50_width 8
  204. #define gray50_height 8
  205. static char gray50_bits[] = {
  206.    0x33, 0xcc, 0x33, 0xcc, 0x33, 0xcc, 0x33, 0xcc};
  207. \BARFOO\
  208. else
  209.   echo "will not over write ./bitmaps/gray50"
  210. fi
  211. if `test ! -s ./bitmaps/gray25`
  212. then
  213. echo "writting ./bitmaps/gray25"
  214. cat > ./bitmaps/gray25 << '\BARFOO\'
  215. #define gray25_width 8
  216. #define gray25_height 8
  217. static char gray25_bits[] = {
  218.    0x88, 0x22, 0x88, 0x22, 0x88, 0x22, 0x88, 0x22};
  219. \BARFOO\
  220. else
  221.   echo "will not over write ./bitmaps/gray25"
  222. fi
  223. if `test ! -s ./bitmaps/i_chr`
  224. then
  225. echo "writting ./bitmaps/i_chr"
  226. cat > ./bitmaps/i_chr << '\BARFOO\'
  227. #define i_chr_width 20
  228. #define i_chr_height 13
  229. static char i_chr_bits[] = {
  230.    0xe0, 0x7f, 0x00, 0x20, 0x40, 0x00, 0x20, 0x40, 0x00, 0x20, 0x40, 0x00,
  231.    0x20, 0x40, 0x00, 0x20, 0x40, 0x00, 0x20, 0x40, 0x00, 0xe0, 0x7f, 0x00,
  232.    0x00, 0x09, 0x00, 0xf0, 0xff, 0x00, 0x50, 0xd5, 0x00, 0xb0, 0xaa, 0x00,
  233.    0xf0, 0xff, 0x00};
  234. \BARFOO\
  235. else
  236.   echo "will not over write ./bitmaps/i_chr"
  237. fi
  238. if `test ! -s ./bitmaps/i_blk`
  239. then
  240. echo "writting ./bitmaps/i_blk"
  241. cat > ./bitmaps/i_blk << '\BARFOO\'
  242. #define i_blk_width 20
  243. #define i_blk_height 13
  244. static char i_blk_bits[] = {
  245.    0x40, 0x00, 0x00, 0xb0, 0x01, 0x00, 0x0c, 0x02, 0x00, 0x03, 0xcc, 0x01,
  246.    0x0d, 0x3a, 0x06, 0xb1, 0x19, 0x06, 0x41, 0xe8, 0x05, 0x41, 0x88, 0x04,
  247.    0x41, 0x88, 0x04, 0x41, 0x88, 0x04, 0x43, 0x9c, 0x06, 0x4c, 0xb2, 0x01,
  248.    0xf0, 0xc1, 0x00};
  249. \BARFOO\
  250. else
  251.   echo "will not over write ./bitmaps/i_blk"
  252. fi
  253. if `test ! -s ./bitmaps/i_fifo`
  254. then
  255. echo "writting ./bitmaps/i_fifo"
  256. cat > ./bitmaps/i_fifo << '\BARFOO\'
  257. #define i_fifo_width 20
  258. #define i_fifo_height 13
  259. static char i_fifo_bits[] = {
  260.    0x80, 0x0f, 0xf0, 0x80, 0x0f, 0xf0, 0xff, 0xff, 0xff, 0x80, 0x0f, 0xf0,
  261.    0xff, 0xff, 0xff, 0xf0, 0x7f, 0xf0, 0xff, 0xff, 0xff, 0xc0, 0x1f, 0xf0,
  262.    0xff, 0xff, 0xff, 0x00, 0x07, 0xf0, 0xff, 0xff, 0xff, 0x00, 0x00, 0xf0,
  263.    0xff, 0xff, 0xff};
  264. \BARFOO\
  265. else
  266.   echo "will not over write ./bitmaps/i_fifo"
  267. fi
  268. if `test ! -s ./bitmaps/i_dir`
  269. then
  270. echo "writting ./bitmaps/i_dir"
  271. cat > ./bitmaps/i_dir << '\BARFOO\'
  272. #define i_dir_width 20
  273. #define i_dir_height 13
  274. static char i_dir_bits[] = {
  275.    0xf0, 0x01, 0x00, 0x08, 0x02, 0x00, 0xfe, 0xff, 0x07, 0x02, 0x00, 0x04,
  276.    0x02, 0x00, 0x04, 0x02, 0x00, 0x04, 0x02, 0x00, 0x04, 0x02, 0x00, 0x04,
  277.    0x02, 0x00, 0x04, 0x02, 0x00, 0x04, 0x02, 0x00, 0x04, 0x02, 0x00, 0x04,
  278.    0xfe, 0xff, 0x07};
  279. \BARFOO\
  280. else
  281.   echo "will not over write ./bitmaps/i_dir"
  282. fi
  283. if `test ! -s ./bitmaps/i_lnk`
  284. then
  285. echo "writting ./bitmaps/i_lnk"
  286. cat > ./bitmaps/i_lnk << '\BARFOO\'
  287. #define i_lnk_width 20
  288. #define i_lnk_height 13
  289. static char i_lnk_bits[] = {
  290.    0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0xc0, 0x01, 0xc0, 0xff, 0x07,
  291.    0xe0, 0xff, 0x07, 0x30, 0xc0, 0x01, 0x30, 0x40, 0x00, 0xe0, 0x0f, 0x00,
  292.    0xc0, 0x1f, 0x00, 0x00, 0x30, 0x00, 0x00, 0x30, 0x00, 0xfe, 0x1f, 0x00,
  293.    0xfe, 0x0f, 0x00};
  294. \BARFOO\
  295. else
  296.   echo "will not over write ./bitmaps/i_lnk"
  297. fi
  298. if `test ! -s ./bitmaps/i_sock`
  299. then
  300. echo "writting ./bitmaps/i_sock"
  301. cat > ./bitmaps/i_sock << '\BARFOO\'
  302. #define i_sock_width 20
  303. #define i_sock_height 13
  304. static char i_sock_bits[] = {
  305.    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x1f, 0x00, 0x84, 0xf0, 0x0f,
  306.    0x8c, 0x10, 0x00, 0x9f, 0x5a, 0x05, 0xbf, 0xb5, 0x0a, 0x9f, 0xff, 0x0f,
  307.    0x8c, 0xff, 0x0f, 0x84, 0xff, 0x0f, 0x80, 0x1f, 0x00, 0x00, 0x00, 0x00,
  308.    0x00, 0x00, 0x00};
  309. \BARFOO\
  310. else
  311.   echo "will not over write ./bitmaps/i_sock"
  312. fi
  313. if `test ! -s ./bitmaps/rb_off`
  314. then
  315. echo "writting ./bitmaps/rb_off"
  316. cat > ./bitmaps/rb_off << '\BARFOO\'
  317. #define rb_off_width 15
  318. #define rb_off_height 15
  319. static char rb_off_bits[] = {
  320.    0xe0, 0x03, 0x18, 0x0c, 0x04, 0x10, 0x02, 0x20, 0x02, 0x20, 0x01, 0x40,
  321.    0x01, 0x40, 0x01, 0x40, 0x01, 0x40, 0x01, 0x40, 0x02, 0x20, 0x02, 0x20,
  322.    0x04, 0x10, 0x18, 0x0c, 0xe0, 0x03};
  323. \BARFOO\
  324. else
  325.   echo "will not over write ./bitmaps/rb_off"
  326. fi
  327. if `test ! -s ./bitmaps/i_reg`
  328. then
  329. echo "writting ./bitmaps/i_reg"
  330. cat > ./bitmaps/i_reg << '\BARFOO\'
  331. #define i_reg_width 20
  332. #define i_reg_height 13
  333. static char i_reg_bits[] = {
  334.    0xc0, 0x7f, 0x00, 0xa0, 0x40, 0x00, 0x90, 0x40, 0x00, 0xf0, 0x40, 0x00,
  335.    0x10, 0x40, 0x00, 0x10, 0x40, 0x00, 0x10, 0x40, 0x00, 0x10, 0x40, 0x00,
  336.    0x10, 0x40, 0x00, 0x10, 0x40, 0x00, 0x10, 0x40, 0x00, 0x10, 0x40, 0x00,
  337.    0xf0, 0x7f, 0x00};
  338. \BARFOO\
  339. else
  340.   echo "will not over write ./bitmaps/i_reg"
  341. fi
  342. if `test ! -s ./bitmaps/fc_left`
  343. then
  344. echo "writting ./bitmaps/fc_left"
  345. cat > ./bitmaps/fc_left << '\BARFOO\'
  346. #define fc_left_width 16
  347. #define fc_left_height 16
  348. static char fc_left_bits[] = {
  349.    0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xc0, 0x04, 0x70, 0x82, 0x8c, 0xe2,
  350.    0x22, 0x9c, 0x2d, 0x90, 0x2d, 0x80, 0x21, 0x90, 0x22, 0x9c, 0x1c, 0xe3,
  351.    0x70, 0x82, 0x80, 0x02, 0x00, 0x07, 0x00, 0x00};
  352. \BARFOO\
  353. else
  354.   echo "will not over write ./bitmaps/fc_left"
  355. fi
  356. if `test ! -s ./bitmaps/rb_on`
  357. then
  358. echo "writting ./bitmaps/rb_on"
  359. cat > ./bitmaps/rb_on << '\BARFOO\'
  360. #define rb_on_width 15
  361. #define rb_on_height 15
  362. static char rb_on_bits[] = {
  363.    0xe0, 0x03, 0x18, 0x0c, 0x04, 0x10, 0xc2, 0x21, 0xf2, 0x27, 0xf1, 0x47,
  364.    0xf9, 0x4f, 0xf9, 0x4f, 0xf9, 0x4f, 0xf1, 0x47, 0xf2, 0x27, 0xc2, 0x21,
  365.    0x04, 0x10, 0x18, 0x0c, 0xe0, 0x03};
  366. \BARFOO\
  367. else
  368.   echo "will not over write ./bitmaps/rb_on"
  369. fi
  370. if `test ! -s ./bitmaps/rb_on1`
  371. then
  372. echo "writting ./bitmaps/rb_on1"
  373. cat > ./bitmaps/rb_on1 << '\BARFOO\'
  374. #define rb_on1_width 15
  375. #define rb_on1_height 15
  376. static char rb_on1_bits[] = {
  377.    0xe0, 0x03, 0xf8, 0x0f, 0x1c, 0x1c, 0xc6, 0x31, 0xf6, 0x37, 0xf3, 0x67,
  378.    0xfb, 0x6f, 0xfb, 0x6f, 0xfb, 0x6f, 0xf3, 0x67, 0xf6, 0x37, 0xc6, 0x31,
  379.    0x1c, 0x1c, 0xf8, 0x0f, 0xe0, 0x03};
  380. \BARFOO\
  381. else
  382.   echo "will not over write ./bitmaps/rb_on1"
  383. fi
  384. if `test ! -s ./bitmaps/rb_off1`
  385. then
  386. echo "writting ./bitmaps/rb_off1"
  387. cat > ./bitmaps/rb_off1 << '\BARFOO\'
  388. #define rb_off1_width 15
  389. #define rb_off1_height 15
  390. static char rb_off1_bits[] = {
  391.    0xe0, 0x03, 0xf8, 0x0f, 0x1c, 0x1c, 0x06, 0x30, 0x06, 0x30, 0x03, 0x60,
  392.    0x03, 0x60, 0x03, 0x60, 0x03, 0x60, 0x03, 0x60, 0x06, 0x30, 0x06, 0x30,
  393.    0x1c, 0x1c, 0xf8, 0x0f, 0xe0, 0x03};
  394. \BARFOO\
  395. else
  396.   echo "will not over write ./bitmaps/rb_off1"
  397. fi
  398. if `test ! -s ./bitmaps/grasp.old`
  399. then
  400. echo "writting ./bitmaps/grasp.old"
  401. cat > ./bitmaps/grasp.old << '\BARFOO\'
  402. #define grasp_width 64
  403. #define grasp_height 64
  404. static char grasp_bits[] = {
  405.    0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  406.    0x00, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x7f, 0x00, 0x00,
  407.    0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0,
  408.    0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0xff, 0x03, 0x00,
  409.    0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0xe0, 0xff,
  410.    0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0x1f, 0x00,
  411.    0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x00, 0xf0, 0xff, 0xff,
  412.    0xff, 0xff, 0x7f, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
  413.    0xe0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0xfc, 0xff, 0xff, 0xff,
  414.    0xff, 0xff, 0xff, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x07,
  415.    0xff, 0xff, 0xff, 0xff, 0x01, 0xfe, 0xff, 0x0f, 0xff, 0xff, 0xff, 0x0f,
  416.    0x00, 0xf8, 0xff, 0x1f, 0xff, 0xff, 0xff, 0x01, 0x00, 0xf0, 0xff, 0x3f,
  417.    0xff, 0xff, 0x7f, 0x00, 0x00, 0xf0, 0xff, 0x7f, 0xff, 0xff, 0x1f, 0x00,
  418.    0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00,
  419.    0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x01, 0x00,
  420.    0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf8, 0xf8, 0x01, 0x03, 0x8f, 0x3f,
  421.    0xff, 0x7f, 0xfc, 0xf9, 0x83, 0x83, 0x9f, 0x7f, 0xff, 0x3f, 0xfe, 0xfb,
  422.    0x87, 0xc7, 0xbf, 0x7f, 0xff, 0x3f, 0x8e, 0x3b, 0xc7, 0xc7, 0xb9, 0x73,
  423.    0x00, 0x00, 0x0e, 0x38, 0xc7, 0xce, 0x83, 0x73, 0x00, 0x00, 0xee, 0xbb,
  424.    0xc7, 0x8e, 0x8f, 0x7b, 0x00, 0x00, 0xee, 0xfb, 0xe3, 0x0f, 0x9f, 0x3f,
  425.    0x00, 0x00, 0x8e, 0xfb, 0xe1, 0x1f, 0xb8, 0x1f, 0x00, 0x00, 0x9e, 0xbb,
  426.    0xe3, 0xde, 0xb9, 0x03, 0x00, 0x00, 0xfc, 0xbb, 0x73, 0xdc, 0xbf, 0x03,
  427.    0x00, 0x00, 0xfc, 0x39, 0x77, 0xb8, 0x9f, 0x03, 0x00, 0x00, 0xf0, 0x38,
  428.    0x77, 0x38, 0x8f, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  429.    0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x3f, 0x10, 0x20,
  430.    0x00, 0x40, 0x00, 0x00, 0xff, 0x3f, 0x10, 0xec, 0xee, 0xec, 0xee, 0x0a,
  431.    0xff, 0x7f, 0x10, 0xaa, 0x2a, 0x4a, 0x2a, 0x0a, 0xff, 0xff, 0xf0, 0xfe,
  432.    0x2e, 0xde, 0x2e, 0x0e, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x08,
  433.    0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0x06, 0xff, 0xff, 0x07, 0x00,
  434.    0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00,
  435.    0xff, 0xff, 0x7f, 0x00, 0x00, 0xf0, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x01,
  436.    0x00, 0xf0, 0xff, 0x3f, 0xff, 0xff, 0xff, 0x0f, 0x00, 0xf8, 0xff, 0x1f,
  437.    0xff, 0xff, 0xff, 0xff, 0x01, 0xfe, 0xff, 0x0f, 0xff, 0xff, 0xff, 0xff,
  438.    0xff, 0xff, 0xff, 0x07, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03,
  439.    0xe0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0xff, 0xff, 0xff,
  440.    0xff, 0xff, 0xff, 0x00, 0x00, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x00,
  441.    0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x00, 0xfc, 0xff,
  442.    0xff, 0xff, 0x1f, 0x00, 0x00, 0x00, 0xe0, 0xff, 0xff, 0xff, 0x0f, 0x00,
  443.    0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0xf8,
  444.    0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x01, 0x00,
  445.    0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  446.    0xe0, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00,
  447.    0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00};
  448. \BARFOO\
  449. else
  450.   echo "will not over write ./bitmaps/grasp.old"
  451. fi
  452. if `test ! -s ./bitmaps/fc_right`
  453. then
  454. echo "writting ./bitmaps/fc_right"
  455. cat > ./bitmaps/fc_right << '\BARFOO\'
  456. #define fc_right_width 16
  457. #define fc_right_height 16
  458. static char fc_right_bits[] = {
  459.    0x00, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x20, 0x03, 0x41, 0x0e, 0x47, 0x30,
  460.    0x39, 0x44, 0x09, 0xb4, 0x01, 0xb4, 0x09, 0x84, 0x39, 0x44, 0xc7, 0x38,
  461.    0x41, 0x0e, 0x40, 0x01, 0xe0, 0x00, 0x00, 0x00};
  462. \BARFOO\
  463. else
  464.   echo "will not over write ./bitmaps/fc_right"
  465. fi
  466. if `test ! -s ./bitmaps/fc_mid`
  467. then
  468. echo "writting ./bitmaps/fc_mid"
  469. cat > ./bitmaps/fc_mid << '\BARFOO\'
  470. #define fc_mid_width 16
  471. #define fc_mid_height 16
  472. static char fc_mid_bits[] = {
  473.    0x00, 0x00, 0x00, 0x00, 0x80, 0x03, 0x80, 0x03, 0x40, 0x04, 0x20, 0x08,
  474.    0xe0, 0x0e, 0xe0, 0x0e, 0x20, 0x08, 0xa0, 0x0b, 0xe0, 0x0f, 0xa0, 0x0b,
  475.    0x40, 0x04, 0x80, 0x03, 0x80, 0x03, 0x00, 0x00};
  476. \BARFOO\
  477. else
  478.   echo "will not over write ./bitmaps/fc_mid"
  479. fi
  480. if `test ! -s ./bitmaps/fc_leftm`
  481. then
  482. echo "writting ./bitmaps/fc_leftm"
  483. cat > ./bitmaps/fc_leftm << '\BARFOO\'
  484. #define fc_leftm_width 16
  485. #define fc_leftm_height 16
  486. static char fc_leftm_bits[] = {
  487.    0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xc0, 0x07, 0xf0, 0x83, 0xfc, 0xe3,
  488.    0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xfc, 0xe3,
  489.    0xf0, 0x83, 0x80, 0x03, 0x00, 0x07, 0x00, 0x00};
  490. \BARFOO\
  491. else
  492.   echo "will not over write ./bitmaps/fc_leftm"
  493. fi
  494. if `test ! -s ./bitmaps/fc_midm`
  495. then
  496. echo "writting ./bitmaps/fc_midm"
  497. cat > ./bitmaps/fc_midm << '\BARFOO\'
  498. #define fc_midm_width 16
  499. #define fc_midm_height 16
  500. static char fc_midm_bits[] = {
  501.    0x00, 0x00, 0x00, 0x00, 0x80, 0x03, 0x80, 0x03, 0xc0, 0x07, 0xe0, 0x0f,
  502.    0xe0, 0x0f, 0xe0, 0x0f, 0xe0, 0x0f, 0xe0, 0x0f, 0xe0, 0x0f, 0xe0, 0x0f,
  503.    0xc0, 0x07, 0x80, 0x03, 0x80, 0x03, 0x00, 0x00};
  504. \BARFOO\
  505. else
  506.   echo "will not over write ./bitmaps/fc_midm"
  507. fi
  508. if `test ! -s ./bitmaps/fc_rightm`
  509. then
  510. echo "writting ./bitmaps/fc_rightm"
  511. cat > ./bitmaps/fc_rightm << '\BARFOO\'
  512. #define fc_rightm_width 16
  513. #define fc_rightm_height 16
  514. static char fc_rightm_bits[] = {
  515.    0x00, 0x00, 0x00, 0x00, 0xf0, 0x00, 0xe0, 0x03, 0xc1, 0x0f, 0xc7, 0x3f,
  516.    0xff, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xc7, 0x3f,
  517.    0xc1, 0x0f, 0xc0, 0x01, 0xe0, 0x00, 0x00, 0x00};
  518. \BARFOO\
  519. else
  520.   echo "will not over write ./bitmaps/fc_rightm"
  521. fi
  522. if `test ! -s ./bitmaps/fc_left1`
  523. then
  524. echo "writting ./bitmaps/fc_left1"
  525. cat > ./bitmaps/fc_left1 << '\BARFOO\'
  526. #define fc_left1_width 16
  527. #define fc_left1_height 16
  528. static char fc_left1_bits[] = {
  529.    0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xc0, 0x02, 0xe0, 0x14, 0x10, 0x1f,
  530.    0xd8, 0x14, 0xd8, 0x14, 0x08, 0x10, 0x08, 0x14, 0xd0, 0x14, 0x70, 0x1e,
  531.    0x60, 0x13, 0x80, 0x01, 0x00, 0x01, 0x00, 0x00};
  532. \BARFOO\
  533. else
  534.   echo "will not over write ./bitmaps/fc_left1"
  535. fi
  536. if `test ! -s ./bitmaps/fc_right1`
  537. then
  538. echo "writting ./bitmaps/fc_right1"
  539. cat > ./bitmaps/fc_right1 << '\BARFOO\'
  540. #define fc_right1_width 16
  541. #define fc_right1_height 16
  542. static char fc_right1_bits[] = {
  543.    0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x40, 0x03, 0x28, 0x07, 0xf8, 0x08,
  544.    0x28, 0x1b, 0x28, 0x1b, 0x08, 0x10, 0x28, 0x10, 0x28, 0x0b, 0x38, 0x0e,
  545.    0xc8, 0x06, 0x80, 0x01, 0x80, 0x00, 0x00, 0x00};
  546. \BARFOO\
  547. else
  548.   echo "will not over write ./bitmaps/fc_right1"
  549. fi
  550. if `test ! -s ./bitmaps/fc_right1m`
  551. then
  552. echo "writting ./bitmaps/fc_right1m"
  553. cat > ./bitmaps/fc_right1m << '\BARFOO\'
  554. #define fc_right1m_width 16
  555. #define fc_right1m_height 16
  556. static char fc_right1m_bits[] = {
  557.    0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0xc0, 0x03, 0xe8, 0x07, 0xf8, 0x0f,
  558.    0xf8, 0x1f, 0xf8, 0x1f, 0xf8, 0x1f, 0xf8, 0x1f, 0xf8, 0x0f, 0xf8, 0x0f,
  559.    0xc8, 0x07, 0x80, 0x01, 0x80, 0x00, 0x00, 0x00};
  560. \BARFOO\
  561. else
  562.   echo "will not over write ./bitmaps/fc_right1m"
  563. fi
  564. if `test ! -s ./bitmaps/fc_left1m`
  565. then
  566. echo "writting ./bitmaps/fc_left1m"
  567. cat > ./bitmaps/fc_left1m << '\BARFOO\'
  568. #define fc_left1m_width 16
  569. #define fc_left1m_height 16
  570. static char fc_left1m_bits[] = {
  571.    0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xc0, 0x03, 0xe0, 0x17, 0xf0, 0x1f,
  572.    0xf8, 0x1f, 0xf8, 0x1f, 0xf8, 0x1f, 0xf8, 0x1f, 0xf0, 0x1f, 0xf0, 0x1f,
  573.    0xe0, 0x13, 0x80, 0x01, 0x00, 0x01, 0x00, 0x00};
  574. \BARFOO\
  575. else
  576.   echo "will not over write ./bitmaps/fc_left1m"
  577. fi
  578. if `test ! -s ./bitmaps/icon`
  579. then
  580. echo "writting ./bitmaps/icon"
  581. cat > ./bitmaps/icon << '\BARFOO\'
  582. #define icon_width 48
  583. #define icon_height 29
  584. static char icon_bits[] = {
  585.    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  586.    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  587.    0x3e, 0x00, 0x7c, 0x7c, 0x00, 0x7c, 0x5c, 0x00, 0x2e, 0x5c, 0x00, 0x5c,
  588.    0xb8, 0x00, 0x17, 0xb8, 0x00, 0x2e, 0x70, 0x81, 0x0b, 0xb8, 0x00, 0x2e,
  589.    0x70, 0x81, 0x0b, 0x70, 0x01, 0x17, 0xe0, 0xc2, 0x05, 0x70, 0x01, 0x17,
  590.    0xc0, 0xe5, 0x02, 0xe0, 0x82, 0x0b, 0x80, 0x7b, 0x01, 0xe0, 0x82, 0x0b,
  591.    0x00, 0xb7, 0x00, 0xc0, 0xc5, 0x05, 0x00, 0x56, 0x00, 0xc0, 0xc5, 0x05,
  592.    0x00, 0x2e, 0x00, 0x80, 0xeb, 0x02, 0x00, 0x56, 0x00, 0x80, 0xeb, 0x02,
  593.    0x00, 0xb7, 0x00, 0x00, 0x77, 0x01, 0x80, 0x7b, 0x01, 0x00, 0x77, 0x01,
  594.    0xc0, 0xe5, 0x02, 0x00, 0xae, 0x00, 0xe0, 0xc2, 0x05, 0x00, 0xae, 0x00,
  595.    0x70, 0x81, 0x0b, 0x00, 0x5c, 0x00, 0x70, 0x81, 0x0b, 0x00, 0x5c, 0x00,
  596.    0xb8, 0x00, 0x17, 0x00, 0x38, 0x00, 0x5c, 0x00, 0x2e, 0x00, 0x38, 0x00,
  597.    0x3e, 0x00, 0x7c, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  598.    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  599.    0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
  600. \BARFOO\
  601. else
  602.   echo "will not over write ./bitmaps/icon"
  603. fi
  604. if `test ! -d ./docs`
  605. then
  606.   mkdir ./docs
  607.   echo "mkdir ./docs"
  608. fi
  609. if `test ! -s ./docs/pbm.5`
  610. then
  611. echo "writting ./docs/pbm.5"
  612. cat > ./docs/pbm.5 << '\BARFOO\'
  613. .TH pbm 5 "21 September 1989"
  614. .SH NAME
  615. pbm - portable bitmap file format
  616. .SH DESCRIPTION
  617. The portable bitmap format is a lowest common denominator monochrome
  618. file format.
  619. It was originally designed to make it reasonable to mail bitmaps
  620. between different types of machines using the typical stupid network
  621. mailers we have today.
  622. Now it serves as the common language of a large family of bitmap
  623. conversion filters.
  624. The definition is as follows:
  625. .IP - 2
  626. A "magic number" for identifying the file type.
  627. A pbm file's magic number is the two characters "P1".
  628. .IP - 2
  629. Whitespace (blanks, TABs, CRs, LFs).
  630. .IP - 2
  631. A width, formatted as ASCII characters in decimal.
  632. .IP - 2
  633. Whitespace.
  634. .IP - 2
  635. A height, again in ASCII decimal.
  636. .IP - 2
  637. Whitespace.
  638. .IP - 2
  639. Width * height bits, each either '1' or '0', starting at the top-left
  640. corner of the bitmap, proceding in normal English reading order.
  641. .IP - 2
  642. The character '1' means black, '0' means white.
  643. .IP - 2
  644. Whitespace in the bits section is ignored.
  645. .IP - 2
  646. Characters from a "#" to the next end-of-line are ignored (comments).
  647. .IP - 2
  648. No line should be longer than 70 characters.
  649. .PP
  650. Here is an example of a small bitmap in this format:
  651. .PP
  652. .nf
  653. P1
  654. # feep.pbm
  655. 24 7
  656. 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  657. 0 1 1 1 1 0 0 1 1 1 1 0 0 1 1 1 1 0 0 1 1 1 1 0
  658. 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 1 0
  659. 0 1 1 1 0 0 0 1 1 1 0 0 0 1 1 1 0 0 0 1 1 1 1 0
  660. 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0
  661. 0 1 0 0 0 0 0 1 1 1 1 0 0 1 1 1 1 0 0 1 0 0 0 0
  662. 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  663. .fi
  664. .PP
  665. Programs that read this format should be as lenient as possible,
  666. accepting anything that looks remotely like a bitmap.
  667. .PP
  668. There is also a variant on the format, available
  669. by setting the RAWBITS option at compile time.  This variant is
  670. different in the following ways:
  671. .IP - 2
  672. The "magic number" is "P4" instead of "P1".
  673. .IP - 2
  674. The bits are stored eight per byte, high bit first low bit last.
  675. .IP - 2
  676. No whitespace is allowed in the bits section.
  677. .IP - 2
  678. The files are eight times smaller and many times faster to read and write.
  679. .SH "SEE ALSO"
  680. brushtopbm(1), cmuwmtopbm(1), g3topbm(1), icontopbm(1), gemtopbm(1),
  681. macptopbm(1), mgrtopbm(1), pbmlife(1),
  682. pbmmake(1), pbmmask(1), pbmpaste(1), pbmreduce(1), pbmtoascii(1),
  683. pbmtobbnbg(1), pbmtocmuwm(1), pbmtog3(1), pbmtogo(1), pbmtoicon(1), pbmtolj(1),
  684. pbmtomacp(1), pbmtomgr(1), pbmtoptx(1), pbmtorast(1), pbmtox10bm(1),
  685. pbmtoxbm(1), pbmtoxwd(1), pbmupc(1), pcxtopbm(1), picttopbm(1), rasttopbm(1),
  686. xbmtopbm(1), xwdtopbm(1),
  687. pnm(5), pgm(5), ppm(5)
  688. .SH AUTHOR
  689. Copyright (C) 1989 by Jef Poskanzer.
  690.  
  691. Permission to use, copy, modify, and distribute this software and its
  692. documentation for any purpose and without fee is hereby granted, provided
  693. that the above copyright notice appear in all copies and that both that
  694. copyright notice and this permission notice appear in supporting
  695. documentation.  This software is provided "as is" without express or
  696. implied warranty.
  697. \BARFOO\
  698. else
  699.   echo "will not over write ./docs/pbm.5"
  700. fi
  701. if `test ! -s ./docs/pgm.5`
  702. then
  703. echo "writting ./docs/pgm.5"
  704. cat > ./docs/pgm.5 << '\BARFOO\'
  705. .TH pgm 5 "01 August 1989"
  706. .SH NAME
  707. pgm - portable graymap file format
  708. .SH DESCRIPTION
  709. The portable graymap format is a lowest common denominator grayscale
  710. file format.
  711. The definition is as follows:
  712. .IP - 2
  713. A "magic number" for identifying the file type.
  714. A pgm file's magic number is the two characters "P2".
  715. .IP - 2
  716. Whitespace (blanks, TABs, CRs, LFs).
  717. .IP - 2
  718. A width, formatted as ASCII characters in decimal.
  719. .IP - 2
  720. Whitespace.
  721. .IP - 2
  722. A height, again in ASCII decimal.
  723. .IP - 2
  724. Whitespace.
  725. .IP - 2
  726. The maximum gray value, again in ASCII decimal.
  727. .IP - 2
  728. Whitespace.
  729. .IP - 2
  730. Width * height gray values, each in ASCII decimal, between 0 and the specified
  731. maximum value, separated by whitespace, starting at the top-left
  732. corner of the graymap, proceding in normal English reading order.
  733. A value of 0 means black, and the maximum value means white.
  734. .IP - 2
  735. Characters from a "#" to the next end-of-line are ignored (comments).
  736. .IP - 2
  737. No line should be longer than 70 characters.
  738. .PP
  739. Here is an example of a small graymap in this format:
  740. .PP
  741. .nf
  742. P2
  743. # feep.pgm
  744. 24 7
  745. 15
  746. 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
  747. 0  3  3  3  3  0  0  7  7  7  7  0  0 11 11 11 11  0  0 15 15 15 15  0
  748. 0  3  0  0  0  0  0  7  0  0  0  0  0 11  0  0  0  0  0 15  0  0 15  0
  749. 0  3  3  3  0  0  0  7  7  7  0  0  0 11 11 11  0  0  0 15 15 15 15  0
  750. 0  3  0  0  0  0  0  7  0  0  0  0  0 11  0  0  0  0  0 15  0  0  0  0
  751. 0  3  0  0  0  0  0  7  7  7  7  0  0 11 11 11 11  0  0 15  0  0  0  0
  752. 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
  753. .fi
  754. .PP
  755. Programs that read this format should be as lenient as possible,
  756. accepting anything that looks remotely like a graymap.
  757. .PP
  758. There is also a variant on the format, available
  759. by setting the RAWBITS option at compile time.  This variant is
  760. different in the following ways:
  761. .IP - 2
  762. The "magic number" is "P5" instead of "P2".
  763. .IP - 2
  764. The gray values are stored as plain bytes, instead of ASCII decimal.
  765. .IP - 2
  766. No whitespace is allowed in the grays section.
  767. .IP - 2
  768. The files are smaller and many times faster to read and write.
  769. .PP
  770. Note that this raw format can only be used for maxvals less than
  771. or equal to 255.
  772. If you use the PGM library and try to write a file with a larger maxval,
  773. it will automatically fall back on the slower but more general ASCII
  774. format.
  775. .SH "SEE ALSO"
  776. fitstopgm(1), fstopgm(1), hipstopgm(1), psidtopgm(1), rawtopgm(1), tifftopgm(1),
  777. pgmenhance(1), pgmhist(1), pgmnorm(1),
  778. pgmtofits(1), pgmtopbm(1), pgmtops(1),
  779. pnm(5), pbm(5), ppm(5)
  780. .SH AUTHOR
  781. Copyright (C) 1989 by Jef Poskanzer.
  782.  
  783. Permission to use, copy, modify, and distribute this software and its
  784. documentation for any purpose and without fee is hereby granted, provided
  785. that the above copyright notice appear in all copies and that both that
  786. copyright notice and this permission notice appear in supporting
  787. documentation.  This software is provided "as is" without express or
  788. implied warranty.
  789. \BARFOO\
  790. else
  791.   echo "will not over write ./docs/pgm.5"
  792. fi
  793. if `test ! -s ./docs/ppm.5`
  794. then
  795. echo "writting ./docs/ppm.5"
  796. cat > ./docs/ppm.5 << '\BARFOO\'
  797. .TH ppm 5 "05 September 1989"
  798. .SH NAME
  799. ppm - portable pixmap file format
  800. .SH DESCRIPTION
  801. The portable pixmap format is a lowest common denominator color image
  802. file format.
  803. The definition is as follows:
  804. .IP - 2
  805. A "magic number" for identifying the file type.
  806. A ppm file's magic number is the two characters "P3".
  807. .IP - 2
  808. Whitespace (blanks, TABs, CRs, LFs).
  809. .IP - 2
  810. A width, formatted as ASCII characters in decimal.
  811. .IP - 2
  812. Whitespace.
  813. .IP - 2
  814. A height, again in ASCII decimal.
  815. .IP - 2
  816. Whitespace.
  817. .IP - 2
  818. The maximum color-component value, again in ASCII decimal.
  819. .IP - 2
  820. Whitespace.
  821. .IP - 2
  822. Width * height pixels, each three ASCII decimal values between 0 and the
  823. specified maximum value, starting at the top-left
  824. corner of the pixmap, proceding in normal English reading order.
  825. The three values for each pixel represent red, green, and blue, respectively;
  826. a value of 0 means that color is off, and the maximum value means that color
  827. is maxxed out.
  828. .IP - 2
  829. Characters from a "#" to the next end-of-line are ignored (comments).
  830. .IP - 2
  831. No line should be longer than 70 characters.
  832. .PP
  833. Here is an example of a small pixmap in this format:
  834. .PP
  835. .nf
  836. P3
  837. # feep.ppm
  838. 4 4
  839. 15
  840.  0  0  0    0  0  0    0  0  0   15  0 15
  841.  0  0  0    0 15  7    0  0  0    0  0  0
  842.  0  0  0    0  0  0    0 15  7    0  0  0
  843. 15  0 15    0  0  0    0  0  0    0  0  0
  844. .fi
  845. .PP
  846. Programs that read this format should be as lenient as possible,
  847. accepting anything that looks remotely like a pixmap.
  848. .PP
  849. There is also a variant on the format, available
  850. by setting the RAWBITS option at compile time.  This variant is
  851. different in the following ways:
  852. .IP - 2
  853. The "magic number" is "P6" instead of "P3".
  854. .IP - 2
  855. The pixel values are stored as plain bytes, instead of ASCII decimal.
  856. .IP - 2
  857. Whitespace is not allowed in the pixels area.
  858. .IP - 2
  859. The files are smaller and many times faster to read and write.
  860. .PP
  861. Note that this raw format can only be used for maxvals less than
  862. or equal to 255.
  863. If you use the PPM library and try to write a file with a larger maxval,
  864. it will automatically fall back on the slower but more general ASCII
  865. format.
  866. .SH "SEE ALSO"
  867. giftoppm(1), ilbmtoppm(1), imgtoppm(1), mtvtoppm(1), qrttoppm(1), rasttoppm(1),
  868. tgatoppm(1), xwdtoppm(1),
  869. ppmtogif(1), ppmtoilbm(1), ppmtopgm(1), ppmtops(1), ppmtorast(1), ppmtoxwd(1),
  870. ppmarith(1), ppmconvol(1), ppmcscale(1), ppmhist(1), ppmquant(1), ppmrotate(1),
  871. ppmscale(1), ppmshear(1),
  872. pnm(5), pgm(5), pbm(5)
  873. .SH AUTHOR
  874. Copyright (C) 1989 by Jef Poskanzer.
  875.  
  876. Permission to use, copy, modify, and distribute this software and its
  877. documentation for any purpose and without fee is hereby granted, provided
  878. that the above copyright notice appear in all copies and that both that
  879. copyright notice and this permission notice appear in supporting
  880. documentation.  This software is provided "as is" without express or
  881. implied warranty.
  882. \BARFOO\
  883. else
  884.   echo "will not over write ./docs/ppm.5"
  885. fi
  886. if `test ! -s ./docs/gif.doc`
  887. then
  888. echo "writting ./docs/gif.doc"
  889. cat > ./docs/gif.doc << '\BARFOO\'
  890.  
  891.  
  892.  
  893.                                 G I F (tm)
  894.  
  895.                      Graphics Interchange Format (tm)
  896.  
  897.  
  898.  
  899.  
  900.                       A standard defining a mechanism
  901.                      for the storage and transmission
  902.                    of raster-based graphics information
  903.  
  904.  
  905.  
  906.  
  907.  
  908.  
  909.  
  910.  
  911.  
  912.  
  913.                                June 15, 1987
  914.  
  915.  
  916.  
  917.  
  918.  
  919.  
  920.  
  921.  
  922.  
  923.  
  924.  
  925.  
  926.                      (c) CompuServe Incorporated, 1987
  927.                             All rights reserved
  928.  
  929.             While this document is copyrighted, the information
  930.           contained within is made available for use in computer
  931.           software without royalties, or licensing restrictions.
  932.  
  933.  
  934.  
  935.  
  936.  
  937.  
  938.           GIF and 'Graphics Interchange Format' are trademarks of
  939.                          CompuServe, Incorporated.
  940.                            an H&R Block Company
  941.  
  942.                         5000 Arlington Centre Blvd.
  943.                            Columbus, Ohio 43220
  944.                               (614) 457-8600
  945.                                                                      Page 2
  946.  
  947.  
  948.               Graphics Interchange Format (GIF) Specification
  949.  
  950.  
  951.                              Table of Contents
  952.  
  953.         INTRODUCTION . . . . . . . . . . . . . . . . . page 3
  954.  
  955.         GENERAL FILE FORMAT  . . . . . . . . . . . . . page 3
  956.  
  957.         GIF SIGNATURE  . . . . . . . . . . . . . . . . page 4
  958.  
  959.         SCREEN DESCRIPTOR  . . . . . . . . . . . . . . page 4
  960.  
  961.         GLOBAL COLOR MAP . . . . . . . . . . . . . . . page 5
  962.  
  963.         IMAGE DESCRIPTOR . . . . . . . . . . . . . . . page 6
  964.  
  965.         LOCAL COLOR MAP  . . . . . . . . . . . . . . . page 7
  966.  
  967.         RASTER DATA  . . . . . . . . . . . . . . . . . page 7
  968.  
  969.         GIF TERMINATOR . . . . . . . . . . . . . . . . page 8
  970.  
  971.         GIF EXTENSION BLOCKS . . . . . . . . . . . . . page 8
  972.  
  973.         APPENDIX A - GLOSSARY  . . . . . . . . . . . . page 9
  974.  
  975.         APPENDIX B - INTERACTIVE SEQUENCES . . . . . . page 10
  976.  
  977.         APPENDIX C - IMAGE PACKAGING & COMPRESSION . . page 12
  978.  
  979.         APPENDIX D - MULTIPLE IMAGE PROCESSING . . . . page 15
  980. Graphics Interchange Format (GIF)                                    Page 3
  981. Specification
  982.  
  983.  
  984. INTRODUCTION
  985.  
  986.         'GIF' (tm) is CompuServe's standard for defining generalized  color
  987.    raster   images.    This   'Graphics  Interchange  Format'  (tm)  allows
  988.    high-quality, high-resolution graphics to be displayed on a  variety  of
  989.    graphics  hardware  and is intended as an exchange and display mechanism
  990.    for graphics images.  The image format described  in  this  document  is
  991.    designed  to  support  current  and  future image technology and will in
  992.    addition serve as a basis for future CompuServe graphics products.
  993.  
  994.         The main focus  of  this  document  is  to  provide  the  technical
  995.    information  necessary  for  a  programmer to implement GIF encoders and
  996.    decoders.  As such, some assumptions are made as to terminology relavent
  997.    to graphics and programming in general.
  998.  
  999.         The first section of this document describes the  GIF  data  format
  1000.    and its components and applies to all GIF decoders, either as standalone
  1001.    programs or as part of  a  communications  package.   Appendix  B  is  a
  1002.    section  relavent to decoders that are part of a communications software
  1003.    package and describes the protocol requirements for entering and exiting
  1004.    GIF mode, and responding to host interrogations.  A glossary in Appendix
  1005.    A defines some of the terminology used in  this  document.   Appendix  C
  1006.    gives  a  detailed  explanation  of  how  the  graphics  image itself is
  1007.    packaged as a series of data bytes.
  1008.  
  1009.  
  1010.                 Graphics Interchange Format Data Definition
  1011.  
  1012.  
  1013.  GENERAL FILE FORMAT
  1014.  
  1015.         +-----------------------+
  1016.         | +-------------------+ |
  1017.         | |   GIF Signature   | |
  1018.         | +-------------------+ |
  1019.         | +-------------------+ |
  1020.         | | Screen Descriptor | |
  1021.         | +-------------------+ |
  1022.         | +-------------------+ |
  1023.         | | Global Color Map  | |
  1024.         | +-------------------+ |
  1025.         . . .               . . .
  1026.         | +-------------------+ |    ---+   
  1027.         | |  Image Descriptor | |       |   
  1028.         | +-------------------+ |       |   
  1029.         | +-------------------+ |       |  
  1030.         | |  Local Color Map  | |       |-   Repeated 1 to n times
  1031.         | +-------------------+ |       |   
  1032.         | +-------------------+ |       |   
  1033.         | |    Raster Data    | |       |   
  1034.         | +-------------------+ |    ---+   
  1035.         . . .               . . .   
  1036.         |-    GIF Terminator   -|   
  1037.         +-----------------------+
  1038. Graphics Interchange Format (GIF)                                    Page 4
  1039. Specification
  1040.  
  1041.  
  1042.  GIF SIGNATURE
  1043.  
  1044.         The following GIF Signature identifies  the  data  following  as  a
  1045.    valid GIF image stream.  It consists of the following six characters:
  1046.  
  1047.              G I F 8 7 a
  1048.  
  1049.         The last three characters '87a' may be viewed as a  version  number
  1050.    for  this  particular  GIF  definition  and will be used in general as a
  1051.    reference  in  documents  regarding  GIF  that   address   any   version
  1052.    dependencies.
  1053.  
  1054.  SCREEN DESCRIPTOR
  1055.  
  1056.         The Screen Descriptor describes the overall parameters for all  GIF
  1057.    images  following.  It defines the overall dimensions of the image space
  1058.    or logical screen required, the existance of color mapping  information,
  1059.    background  screen color, and color depth information.  This information
  1060.    is stored in a series of 8-bit bytes as described below.
  1061.  
  1062.               bits
  1063.          7 6 5 4 3 2 1 0  Byte #
  1064.         +---------------+
  1065.         |               |  1
  1066.         +-Screen Width -+      Raster width in pixels (LSB first)
  1067.         |               |  2
  1068.         +---------------+
  1069.         |               |  3
  1070.         +-Screen Height-+      Raster height in pixels (LSB first)
  1071.         |               |  4
  1072.         +-+-----+-+-----+      M = 1, Global color map follows Descriptor
  1073.         |M|  cr |0|pixel|  5   cr+1 = # bits of color resolution
  1074.         +-+-----+-+-----+      pixel+1 = # bits/pixel in image
  1075.         |   background  |  6   background=Color index of screen background
  1076.         +---------------+          (color is defined from the Global color
  1077.         |0 0 0 0 0 0 0 0|  7        map or default map if none specified)
  1078.         +---------------+
  1079.  
  1080.  
  1081.         The logical screen width and height can both  be  larger  than  the
  1082.    physical  display.   How  images  larger  than  the physical display are
  1083.    handled is implementation dependent and can take advantage  of  hardware
  1084.    characteristics  (e.g.   Macintosh scrolling windows).  Otherwise images
  1085.    can be clipped to the edges of the display.
  1086.  
  1087.         The value of 'pixel' also defines  the  maximum  number  of  colors
  1088.    within  an  image.   The  range  of  values  for 'pixel' is 0 to 7 which
  1089.    represents 1 to 8 bits.  This translates to a range of 2 (B & W) to  256
  1090.    colors.   Bit  3 of word 5 is reserved for future definition and must be
  1091.    zero.
  1092. Graphics Interchange Format (GIF)                                    Page 5
  1093. Specification
  1094.  
  1095.  
  1096.  GLOBAL COLOR MAP
  1097.  
  1098.         The Global Color Map is optional but recommended for  images  where
  1099.    accurate color rendition is desired.  The existence of this color map is
  1100.    indicated in the 'M' field of byte 5 of the Screen Descriptor.  A  color
  1101.    map  can  also  be associated with each image in a GIF file as described
  1102.    later.  However this  global  map  will  normally  be  used  because  of
  1103.    hardware  restrictions  in equipment available today.  In the individual
  1104.    Image Descriptors the 'M' flag will normally be  zero.   If  the  Global
  1105.    Color  Map  is  present,  it's definition immediately follows the Screen
  1106.    Descriptor.   The  number  of  color  map  entries  following  a  Screen
  1107.    Descriptor  is equal to 2**(# bits per pixel), where each entry consists
  1108.    of three byte values representing the relative intensities of red, green
  1109.    and blue respectively.  The structure of the Color Map block is:
  1110.  
  1111.               bits
  1112.          7 6 5 4 3 2 1 0  Byte #
  1113.         +---------------+
  1114.         | red intensity |  1    Red value for color index 0
  1115.         +---------------+
  1116.         |green intensity|  2    Green value for color index 0
  1117.         +---------------+
  1118.         | blue intensity|  3    Blue value for color index 0
  1119.         +---------------+
  1120.         | red intensity |  4    Red value for color index 1
  1121.         +---------------+
  1122.         |green intensity|  5    Green value for color index 1
  1123.         +---------------+
  1124.         | blue intensity|  6    Blue value for color index 1
  1125.         +---------------+
  1126.         :               :       (Continues for remaining colors)
  1127.  
  1128.         Each image pixel value received will be displayed according to  its
  1129.    closest match with an available color of the display based on this color
  1130.    map.  The color components represent a fractional intensity  value  from
  1131.    none  (0)  to  full (255).  White would be represented as (255,255,255),
  1132.    black as (0,0,0) and medium yellow as (180,180,0).  For display, if  the
  1133.    device  supports fewer than 8 bits per color component, the higher order
  1134.    bits of each component are used.  In the creation of  a  GIF  color  map
  1135.    entry  with  hardware  supporting  fewer  than 8 bits per component, the
  1136.    component values for the hardware  should  be  converted  to  the  8-bit
  1137.    format with the following calculation:
  1138.  
  1139.         <map_value> = <component_value>*255/(2**<nbits> -1)
  1140.  
  1141.         This assures accurate translation of colors for all  displays.   In
  1142.    the  cases  of  creating  GIF images from hardware without color palette
  1143.    capability, a fixed palette should be created  based  on  the  available
  1144.    display  colors for that hardware.  If no Global Color Map is indicated,
  1145.    a default color map is generated internally  which  maps  each  possible
  1146.    incoming  color  index to the same hardware color index modulo <n> where
  1147.    <n> is the number of available hardware colors.
  1148. Graphics Interchange Format (GIF)                                    Page 6
  1149. Specification
  1150.  
  1151.  
  1152.  IMAGE DESCRIPTOR
  1153.  
  1154.         The Image Descriptor defines the actual placement  and  extents  of
  1155.    the  following  image within the space defined in the Screen Descriptor.
  1156.    Also defined are flags to indicate the presence of a local color  lookup
  1157.    map, and to define the pixel display sequence.  Each Image Descriptor is
  1158.    introduced by an image separator  character.   The  role  of  the  Image
  1159.    Separator  is simply to provide a synchronization character to introduce
  1160.    an Image Descriptor.  This is desirable if a GIF file happens to contain
  1161.    more  than  one  image.   This  character  is defined as 0x2C hex or ','
  1162.    (comma).  When this character is encountered between images,  the  Image
  1163.    Descriptor will follow immediately.
  1164.  
  1165.         Any characters encountered between the end of a previous image  and
  1166.    the image separator character are to be ignored.  This allows future GIF
  1167.    enhancements to be present in newer image formats and yet ignored safely
  1168.    by older software decoders.
  1169.  
  1170.  
  1171.               bits
  1172.          7 6 5 4 3 2 1 0  Byte #
  1173.         +---------------+
  1174.         |0 0 1 0 1 1 0 0|  1    ',' - Image separator character
  1175.         +---------------+
  1176.         |               |  2    Start of image in pixels from the
  1177.         +-  Image Left -+       left side of the screen (LSB first)
  1178.         |               |  3
  1179.         +---------------+
  1180.         |               |  4
  1181.         +-  Image Top  -+       Start of image in pixels from the
  1182.         |               |  5    top of the screen (LSB first)
  1183.         +---------------+
  1184.         |               |  6
  1185.         +- Image Width -+       Width of the image in pixels (LSB first)
  1186.         |               |  7
  1187.         +---------------+
  1188.         |               |  8
  1189.         +- Image Height-+       Height of the image in pixels (LSB first)
  1190.         |               |  9
  1191.         +-+-+-+-+-+-----+       M=0 - Use global color map, ignore 'pixel'
  1192.         |M|I|0|0|0|pixel| 10    M=1 - Local color map follows, use 'pixel'
  1193.         +-+-+-+-+-+-----+       I=0 - Image formatted in Sequential order
  1194.                                 I=1 - Image formatted in Interlaced order
  1195.                                 pixel+1 - # bits per pixel for this image
  1196.  
  1197.         The specifications for the image position and size must be confined
  1198.    to  the  dimensions defined by the Screen Descriptor.  On the other hand
  1199.    it is not necessary that the image fill the entire screen defined.
  1200.  
  1201.  
  1202.  LOCAL COLOR MAP
  1203. Graphics Interchange Format (GIF)                                    Page 7
  1204. Specification
  1205.  
  1206.  
  1207.         A Local Color Map is optional and defined here for future use.   If
  1208.    the  'M' bit of byte 10 of the Image Descriptor is set, then a color map
  1209.    follows the Image Descriptor that applies only to the  following  image.
  1210.    At the end of the image, the color map will revert to that defined after
  1211.    the Screen Descriptor.  Note that the 'pixel' field of byte  10  of  the
  1212.    Image  Descriptor  is used only if a Local Color Map is indicated.  This
  1213.    defines the parameters not only for the image pixel size, but determines
  1214.    the  number  of color map entries that follow.  The bits per pixel value
  1215.    will also revert to the value specified in the  Screen  Descriptor  when
  1216.    processing of the image is complete.
  1217.  
  1218.  RASTER DATA
  1219.  
  1220.         The format of the actual image is defined as the  series  of  pixel
  1221.    color  index  values that make up the image.  The pixels are stored left
  1222.    to right sequentially for an image row.  By default each  image  row  is
  1223.    written  sequentially, top to bottom.  In the case that the Interlace or
  1224.    'I' bit is set in byte 10 of the Image Descriptor then the row order  of
  1225.    the  image  display  follows  a  four-pass process in which the image is
  1226.    filled in by widely spaced rows.  The first pass writes every  8th  row,
  1227.    starting  with  the top row of the image window.  The second pass writes
  1228.    every 8th row starting at the fifth row from the top.   The  third  pass
  1229.    writes every 4th row starting at the third row from the top.  The fourth
  1230.    pass completes the image, writing  every  other  row,  starting  at  the
  1231.    second row from the top.  A graphic description of this process follows:
  1232.  
  1233.  
  1234.    Image
  1235.    Row  Pass 1  Pass 2  Pass 3  Pass 4          Result
  1236.    ---------------------------------------------------
  1237.      0  **1a**                                  **1a**
  1238.      1                          **4a**          **4a**
  1239.      2                  **3a**                  **3a**
  1240.      3                          **4b**          **4b**
  1241.      4          **2a**                          **2a**
  1242.      5                          **4c**          **4c**
  1243.      6                  **3b**                  **3b**
  1244.      7                          **4d**          **4d**
  1245.      8  **1b**                                  **1b**
  1246.      9                          **4e**          **4e**
  1247.     10                  **3c**                  **3c**
  1248.     11                          **4f**          **4f**
  1249.     12          **2b**                          **2b**
  1250.    . . . 
  1251.  
  1252.  
  1253.  
  1254.         The image pixel values are processed as a series of  color  indices
  1255.    which  map  into the existing color map.  The resulting color value from
  1256.    the map is what is actually displayed.  This series  of  pixel  indices,
  1257.    the  number  of  which  is equal to image-width*image-height pixels, are
  1258.    passed to the GIF image data stream one value per pixel, compressed  and
  1259.    packaged  according  to  a  version  of the LZW compression algorithm as
  1260.    defined in Appendix C.
  1261. Graphics Interchange Format (GIF)                                    Page 8
  1262. Specification
  1263.  
  1264.  
  1265.  GIF TERMINATOR
  1266.  
  1267.         In order to provide a synchronization for the termination of a  GIF
  1268.    image  file,  a  GIF  decoder  will process the end of GIF mode when the
  1269.    character 0x3B hex or ';' is found after an image  has  been  processed.
  1270.    By  convention  the  decoding software will pause and wait for an action
  1271.    indicating that the user is ready to continue.  This may be  a  carriage
  1272.    return  entered  at  the  keyboard  or  a  mouse click.  For interactive
  1273.    applications this user action must  be  passed  on  to  the  host  as  a
  1274.    carriage  return  character  so  that the host application can continue.
  1275.    The decoding software will then typically leave graphics mode and resume
  1276.    any previous process.
  1277.  
  1278.  
  1279.  GIF EXTENSION BLOCKS
  1280.  
  1281.         To provide for orderly extension of the GIF definition, a mechanism
  1282.    for  defining  the  packaging  of extensions within a GIF data stream is
  1283.    necessary.  Specific GIF extensions are to be defined and documented  by
  1284.    CompuServe in order to provide a controlled enhancement path.
  1285.  
  1286.         GIF Extension Blocks are packaged in a manner similar to that  used
  1287.    by the raster data though not compressed.  The basic structure is:
  1288.  
  1289.          7 6 5 4 3 2 1 0  Byte #
  1290.         +---------------+
  1291.         |0 0 1 0 0 0 0 1|  1       '!' - GIF Extension Block Introducer
  1292.         +---------------+
  1293.         | function code |  2       Extension function code (0 to 255)
  1294.         +---------------+    ---+
  1295.         |  byte count   |       |
  1296.         +---------------+       |
  1297.         :               :       +-- Repeated as many times as necessary
  1298.         |func data bytes|       |
  1299.         :               :       |
  1300.         +---------------+    ---+
  1301.         . . .       . . .
  1302.         +---------------+
  1303.         |0 0 0 0 0 0 0 0|       zero byte count (terminates block)
  1304.         +---------------+
  1305.  
  1306.         A GIF Extension Block may immediately preceed any Image  Descriptor
  1307.    or occur before the GIF Terminator.
  1308.  
  1309.         All GIF decoders must be able to recognize  the  existence  of  GIF
  1310.    Extension  Blocks  and  read past them if unable to process the function
  1311.    code.  This ensures that older decoders will be able to process extended
  1312.    GIF   image   files   in  the  future,  though  without  the  additional
  1313.    functionality.
  1314. Graphics Interchange Format (GIF)                                    Page 9
  1315. Appendix A - Glossary
  1316.  
  1317.  
  1318.                                  GLOSSARY
  1319.  
  1320. Pixel - The smallest picture element of a  graphics  image.   This  usually
  1321.    corresponds  to  a single dot on a graphics screen.  Image resolution is
  1322.    typically given in units of  pixels.   For  example  a  fairly  standard
  1323.    graphics  screen  format  is  one 320 pixels across and 200 pixels high.
  1324.    Each pixel can  appear  as  one  of  several  colors  depending  on  the
  1325.    capabilities of the graphics hardware.
  1326.  
  1327. Raster - A horizontal row of pixels representing one line of an  image.   A
  1328.    typical method of working with images since most hardware is oriented to
  1329.    work most efficiently in this manner.
  1330.  
  1331. LSB - Least Significant Byte.  Refers to a convention for two byte  numeric
  1332.    values in which the less significant byte of the value preceeds the more
  1333.    significant byte.  This convention is typical on many microcomputers.
  1334.  
  1335. Color Map - The list of definitions of each color  used  in  a  GIF  image.
  1336.    These  desired  colors are converted to available colors through a table
  1337.    which is derived by assigning an incoming color index (from  the  image)
  1338.    to  an  output  color  index  (of  the  hardware).   While the color map
  1339.    definitons are specified in a GIF image, the output  pixel  colors  will
  1340.    vary  based  on  the  hardware used and its ability to match the defined
  1341.    color.
  1342.  
  1343. Interlace - The method of displaying a GIF image in which  multiple  passes
  1344.    are  made,  outputting  raster  lines  spaced  apart to provide a way of
  1345.    visualizing the general content of an entire image  before  all  of  the
  1346.    data has been processed.
  1347.  
  1348. B Protocol - A CompuServe-developed error-correcting file transfer protocol
  1349.    available  in  the  public  domain  and implemented in CompuServe VIDTEX
  1350.    products.  This error checking mechanism will be used  in  transfers  of
  1351.    GIF images for interactive applications.
  1352.  
  1353. LZW - A sophisticated data compression algorithm  based  on  work  done  by
  1354.    Lempel-Ziv  &  Welch  which  has  the feature of very efficient one-pass
  1355.    encoding and decoding.  This allows the image  to  be  decompressed  and
  1356.    displayed  at  the  same  time.   The  original  article from which this
  1357.    technique was adapted is:
  1358.  
  1359.           Terry  A.   Welch,  "A  Technique  for  High   Performance   Data
  1360.           Compression", IEEE Computer, vol 17 no 6 (June 1984)
  1361.  
  1362.         This basic algorithm is also used in the  public  domain  ARC  file
  1363.    compression  utilities.   The  CompuServe  adaptation  of LZW for GIF is
  1364.    described in Appendix C.
  1365. Graphics Interchange Format (GIF)                                   Page 10
  1366. Appendix B - Interactive Sequences
  1367.  
  1368.  
  1369.            GIF Sequence Exchanges for an Interactive Environment
  1370.  
  1371.  
  1372.         The following sequences are defined for use  in  mediating  control
  1373.    between a GIF sender and GIF receiver over an interactive communications
  1374.    line.  These  sequences  do  not  apply  to  applications  that  involve
  1375.    downloading  of  static  GIF  files and are not considered part of a GIF
  1376.    file.
  1377.  
  1378.  GIF CAPABILITIES ENQUIRY
  1379.  
  1380.         The GCE sequence is issued from a host and requests an  interactive
  1381.    GIF  decoder  to  return  a  response  message that defines the graphics
  1382.    parameters for the decoder.  This involves returning  information  about
  1383.    available screen sizes, number of bits/color supported and the amount of
  1384.    color detail supported.  The escape sequence for the GCE is defined as:
  1385.  
  1386.         ESC [ > 0 g     (g is lower case, spaces inserted for clarity)
  1387.                          (0x1B 0x5B 0x3E 0x30 0x67)
  1388.  
  1389.  
  1390.  GIF CAPABILITIES RESPONSE
  1391.  
  1392.         The GIF Capabilities Response message is returned by an interactive
  1393.    GIF  decoder  and  defines  the  decoder's  display capabilities for all
  1394.    graphics modes that are supported by the software.  Note that  this  can
  1395.    also include graphics printers as well as a monitor screen.  The general
  1396.    format of this message is:
  1397.  
  1398.  
  1399.      #version;protocol{;dev, width, height, color-bits, color-res}... <CR>
  1400.  
  1401.    '#'          - GCR identifier character (Number Sign)
  1402.    version      - GIF format version number;  initially '87a'
  1403.    protocol='0' - No end-to-end protocol supported by decoder
  1404.                   Transfer as direct 8-bit data stream.
  1405.    protocol='1' - Can use an error correction protocol to transfer GIF data
  1406.                interactively from the host directly to the display.
  1407.  
  1408.    dev = '0'    - Screen parameter set follows
  1409.    dev = '1'    - Printer parameter set follows
  1410.  
  1411.    width        - Maximum supported display width in pixels
  1412.    height       - Maximum supported display height in pixels
  1413.    color-bits   - Number of  bits  per  pixel  supported.   The  number  of
  1414.                supported colors is therefore 2**color-bits.
  1415.    color-res    - Number of bits  per  color  component  supported  in  the
  1416.                hardware  color  palette.   If  color-res  is  '0'  then  no
  1417.                hardware palette table is available.
  1418.  
  1419.  
  1420.         Note that all values in the  GCR  are  returned  as  ASCII  decimal
  1421.    numbers and the message is terminated by a Carriage Return character.
  1422. Graphics Interchange Format (GIF)                                   Page 11
  1423. Appendix B - Interactive Sequences
  1424.  
  1425.  
  1426.         The  following   GCR   message   describes   three   standard   EGA
  1427.    configurations  with  no  printer;  the GIF data stream can be processed
  1428.    within an error correcting protocol:
  1429.  
  1430.         #87a;1 ;0,320,200,4,0 ;0,640,200,2,2 ;0,640,350,4,2<CR>
  1431.  
  1432.  
  1433.  ENTER GIF GRAPHICS MODE
  1434.  
  1435.         Two sequences are currently defined to invoke  an  interactive  GIF
  1436.    decoder into action.  The only difference between them is that different
  1437.    output media are selected.  These sequences are:
  1438.  
  1439.      ESC [ > 1 g   Display GIF image on screen
  1440.                    (0x1B 0x5B 0x3E 0x31 0x67)
  1441.  
  1442.      ESC [ > 2 g   Display image directly to an attached graphics  printer.
  1443.                    The  image  may optionally be displayed on the screen as
  1444.                    well.
  1445.                    (0x1B 0x5B 0x3E 0x32 0x67)
  1446.  
  1447.         Note that the 'g' character terminating each sequence is  in  lower
  1448.    case.
  1449.  
  1450.  
  1451.  INTERACTIVE ENVIRONMENT
  1452.  
  1453.         The assumed environment for the transmission of GIF image data from
  1454.    an  interactive  application  is  a  full 8-bit data stream from host to
  1455.    micro.  All 256 character codes must be transferrable.  The establishing
  1456.    of  an 8-bit data path for communications will normally be taken care of
  1457.    by the host application programs.  It is however  up  to  the  receiving
  1458.    communications programs supporting GIF to be able to receive and pass on
  1459.    all 256 8-bit codes to the GIF decoder software.
  1460. Graphics Interchange Format (GIF)                                   Page 12
  1461. Appendix C - Image Packaging & Compression
  1462.  
  1463.  
  1464.         The Raster Data stream that represents the actual output image  can
  1465.    be represented as:
  1466.  
  1467.          7 6 5 4 3 2 1 0
  1468.         +---------------+
  1469.         |   code size   | 
  1470.         +---------------+     ---+
  1471.         |blok byte count|        |
  1472.         +---------------+        |
  1473.         :               :        +-- Repeated as many times as necessary
  1474.         |  data bytes   |        |
  1475.         :               :        |
  1476.         +---------------+     ---+
  1477.         . . .       . . .
  1478.         +---------------+
  1479.         |0 0 0 0 0 0 0 0|       zero byte count (terminates data stream)
  1480.         +---------------+
  1481.  
  1482.         The conversion of the image from a series  of  pixel  values  to  a
  1483.    transmitted or stored character stream involves several steps.  In brief
  1484.    these steps are:
  1485.  
  1486.    1.  Establish the Code Size -  Define  the  number  of  bits  needed  to
  1487.        represent the actual data.
  1488.  
  1489.    2.  Compress the Data - Compress the series of image pixels to a  series
  1490.        of compression codes.
  1491.  
  1492.    3.  Build a Series of Bytes - Take the  set  of  compression  codes  and
  1493.        convert to a string of 8-bit bytes.
  1494.  
  1495.    4.  Package the Bytes - Package sets of bytes into blocks  preceeded  by
  1496.        character counts and output.
  1497.  
  1498.  
  1499.  
  1500. ESTABLISH CODE SIZE
  1501.  
  1502.         The first byte of the GIF Raster Data stream is a value  indicating
  1503.    the minimum number of bits required to represent the set of actual pixel
  1504.    values.  Normally this will be the same as the  number  of  color  bits.
  1505.    Because  of  some  algorithmic constraints however, black & white images
  1506.    which have one color bit must be indicated as having a code size  of  2.
  1507.    This  code size value also implies that the compression codes must start
  1508.    out one bit longer.
  1509.  
  1510.  
  1511. COMPRESSION
  1512.  
  1513.         The LZW algorithm converts a series of data values into a series of
  1514.    codes  which may be raw values or a code designating a series of values.
  1515.    Using text characters as an analogy,  the  output  code  consists  of  a
  1516.    character or a code representing a string of characters.
  1517. Graphics Interchange Format (GIF)                                   Page 13
  1518. Appendix C - Image Packaging & Compression
  1519.  
  1520.  
  1521.         The LZW algorithm used in  GIF  matches  algorithmically  with  the
  1522.    standard LZW algorithm with the following differences:
  1523.  
  1524.    1.  A   special   Clear   code   is    defined    which    resets    all
  1525.        compression/decompression parameters and tables to a start-up state.
  1526.        The value of this code is 2**<code size>.  For example if  the  code
  1527.        size  indicated  was 4 (image was 4 bits/pixel) the Clear code value
  1528.        would be 16 (10000 binary).  The Clear code can appear at any  point
  1529.        in the image data stream and therefore requires the LZW algorithm to
  1530.        process succeeding codes as if  a  new  data  stream  was  starting.
  1531.        Encoders  should output a Clear code as the first code of each image
  1532.        data stream.
  1533.  
  1534.    2.  An End of Information code is defined that explicitly indicates  the
  1535.        end  of  the image data stream.  LZW processing terminates when this
  1536.        code is encountered.  It must be the last code output by the encoder
  1537.        for an image.  The value of this code is <Clear code>+1.
  1538.  
  1539.    3.  The first available compression code value is <Clear code>+2.
  1540.  
  1541.    4.  The output codes are of variable length, starting  at  <code size>+1
  1542.        bits  per code, up to 12 bits per code.  This defines a maximum code
  1543.        value of 4095 (hex FFF).  Whenever the LZW code value  would  exceed
  1544.        the  current  code length, the code length is increased by one.  The
  1545.        packing/unpacking of these codes must then be altered to reflect the
  1546.        new code length.
  1547.  
  1548.  
  1549. BUILD 8-BIT BYTES
  1550.  
  1551.         Because the LZW compression  used  for  GIF  creates  a  series  of
  1552.    variable  length  codes, of between 3 and 12 bits each, these codes must
  1553.    be reformed into a series of 8-bit bytes that  will  be  the  characters
  1554.    actually stored or transmitted.  This provides additional compression of
  1555.    the image.  The codes are formed into a stream of bits as if  they  were
  1556.    packed  right to left and then picked off 8 bits at a time to be output.
  1557.    Assuming a character array of 8 bits per character and using 5 bit codes
  1558.    to be packed, an example layout would be similar to:
  1559.  
  1560.          byte n       byte 5   byte 4   byte 3   byte 2   byte 1
  1561.         +-.....-----+--------+--------+--------+--------+--------+
  1562.         | and so on |hhhhhggg|ggfffffe|eeeedddd|dcccccbb|bbbaaaaa|
  1563.         +-.....-----+--------+--------+--------+--------+--------+
  1564.  
  1565.         Note that the physical  packing  arrangement  will  change  as  the
  1566.    number  of  bits per compression code change but the concept remains the
  1567.    same.
  1568.  
  1569. PACKAGE THE BYTES
  1570.  
  1571.         Once the bytes have been created, they are grouped into blocks  for
  1572.    output by preceeding each block of 0 to 255 bytes with a character count
  1573.    byte.  A block with a zero byte count terminates the Raster Data  stream
  1574.    for  a  given  image.  These blocks are what are actually output for the
  1575. Graphics Interchange Format (GIF)                                   Page 14
  1576. Appendix C - Image Packaging & Compression
  1577.  
  1578.  
  1579.    GIF image.  This block format has the side effect of allowing a decoding
  1580.    program  the  ability to read past the actual image data if necessary by
  1581.    reading block counts and then skipping over the data.
  1582. Graphics Interchange Format (GIF)                                   Page 15
  1583. Appendix D - Multiple Image Processing
  1584.  
  1585.  
  1586.         Since a  GIF  data  stream  can  contain  multiple  images,  it  is
  1587.    necessary  to  describe  processing and display of such a file.  Because
  1588.    the image descriptor allows  for  placement  of  the  image  within  the
  1589.    logical  screen,  it is possible to define a sequence of images that may
  1590.    each be a partial screen, but in total  fill  the  entire  screen.   The
  1591.    guidelines for handling the multiple image situation are:
  1592.  
  1593.    1.  There is no pause between images.  Each is processed immediately  as
  1594.        seen by the decoder.
  1595.  
  1596.    2.  Each image explicitly overwrites any image  already  on  the  screen
  1597.        inside  of  its window.  The only screen clears are at the beginning
  1598.        and end of the  GIF  image  process.   See  discussion  on  the  GIF
  1599.        terminator.
  1600.  
  1601. \BARFOO\
  1602. else
  1603.   echo "will not over write ./docs/gif.doc"
  1604. fi
  1605. echo "Finished archive 3 of 10"
  1606. exit
  1607.  
  1608. dan
  1609. ----------------------------------------------------
  1610. O'Reilly && Associates   argv@sun.com / argv@ora.com
  1611. Opinions expressed reflect those of the author only.
  1612. --
  1613. dan
  1614. ----------------------------------------------------
  1615. O'Reilly && Associates   argv@sun.com / argv@ora.com
  1616. Opinions expressed reflect those of the author only.
  1617.