home *** CD-ROM | disk | FTP | other *** search
/ PC Professionell 2006 December / PCpro_2006_12.ISO / ossdvd / server / Perl2 / site / lib / Tk / pTk / tixBitmaps.h < prev    next >
Encoding:
Text File  |  2002-12-01  |  20.0 KB  |  616 lines
  1. {
  2. #define maximize_width 15
  3. #define maximize_height 15
  4. static UNSIGNED_CHAR maximize_bits[] = {
  5.    0x00, 0x00, 0x00, 0x00, 0xfc, 0x1f, 0x04, 0x10, 0x04, 0x70, 0x04, 0x70,
  6.    0x04, 0x70, 0x04, 0x70, 0x04, 0x70, 0x04, 0x70, 0x04, 0x70, 0x04, 0x70,
  7.    0xfc, 0x7f, 0xf0, 0x7f, 0xf0, 0x7f};
  8. Tk_DefineBitmap(Et_Interp, Tk_GetUid("maximize"), (char*)maximize_bits, maximize_width, maximize_height);
  9. }
  10. {
  11. #define act_fold_width 16
  12. #define act_fold_height 10
  13. static UNSIGNED_CHAR act_fold_bits[] = {
  14.    0xfc, 0x00, 0xaa, 0x0f, 0x55, 0x15, 0xeb, 0xff, 0x15, 0x80, 0x0b, 0x40,
  15.    0x05, 0x20, 0x03, 0x10, 0x01, 0x08, 0xff, 0x07};
  16. Tk_DefineBitmap(Et_Interp, Tk_GetUid("act_fold"), (char*)act_fold_bits, act_fold_width, act_fold_height);
  17. }
  18. {
  19. /* XPM */
  20. static char * act_fold_xpm[] = {
  21. /* width height num_colors chars_per_pixel */
  22. "16 12 4 1",
  23. /* colors */
  24. "     s None    c None",
  25. ".    c black",
  26. "X    c yellow",
  27. "o    c #5B5B57574646",
  28. /* pixels */
  29. "   ....         ",
  30. "  .XXXX.        ",
  31. " .XXXXXX.       ",
  32. ".............   ",
  33. ".oXoXoXoXoXo.   ",
  34. ".XoX............",
  35. ".oX.XXXXXXXXXXX.",
  36. ".Xo.XXXXXXXXXX. ",
  37. ".o.XXXXXXXXXXX. ",
  38. ".X.XXXXXXXXXXX. ",
  39. "..XXXXXXXXXX..  ",
  40. ".............   "};
  41. Tix_DefinePixmap(Et_Interp, Tk_GetUid("act_fold"), act_fold_xpm);
  42. }
  43. {
  44. #define balarrow_width 6
  45. #define balarrow_height 6
  46. static UNSIGNED_CHAR balarrow_bits[] = {
  47.    0x1f, 0x07, 0x07, 0x09, 0x11, 0x20};
  48. Tk_DefineBitmap(Et_Interp, Tk_GetUid("balarrow"), (char*)balarrow_bits, balarrow_width, balarrow_height);
  49. }
  50. {
  51. #define cbxarrow_width 11
  52. #define cbxarrow_height 14
  53. static UNSIGNED_CHAR cbxarrow_bits[] = {
  54.    0x00, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00,
  55.    0xfe, 0x03, 0xfc, 0x01, 0xf8, 0x00, 0x70, 0x00, 0x20, 0x00, 0x00, 0x00,
  56.    0xfe, 0x03, 0xfe, 0x03};
  57. Tk_DefineBitmap(Et_Interp, Tk_GetUid("cbxarrow"), (char*)cbxarrow_bits, cbxarrow_width, cbxarrow_height);
  58. }
  59. {
  60. #define ck_def_width 13
  61. #define ck_def_height 13
  62. static UNSIGNED_CHAR ck_def_bits[] = {
  63.    0xff, 0x1f, 0x01, 0x10, 0x55, 0x15, 0x01, 0x10, 0x55, 0x15, 0x01, 0x10,
  64.    0x55, 0x15, 0x01, 0x10, 0x55, 0x15, 0x01, 0x10, 0x55, 0x15, 0x01, 0x10,
  65.    0xff, 0x1f};
  66. Tk_DefineBitmap(Et_Interp, Tk_GetUid("ck_def"), (char*)ck_def_bits, ck_def_width, ck_def_height);
  67. }
  68. {
  69. #define ck_off_width 13
  70. #define ck_off_height 13
  71. static UNSIGNED_CHAR ck_off_bits[] = {
  72.    0xff, 0x1f, 0x01, 0x10, 0x01, 0x10, 0x01, 0x10, 0x01, 0x10, 0x01, 0x10,
  73.    0x01, 0x10, 0x01, 0x10, 0x01, 0x10, 0x01, 0x10, 0x01, 0x10, 0x01, 0x10,
  74.    0xff, 0x1f};
  75. Tk_DefineBitmap(Et_Interp, Tk_GetUid("ck_off"), (char*)ck_off_bits, ck_off_width, ck_off_height);
  76. }
  77. {
  78. #define ck_on_width 13
  79. #define ck_on_height 13
  80. static UNSIGNED_CHAR ck_on_bits[] = {
  81.    0xff, 0x1f, 0x01, 0x10, 0x01, 0x10, 0x01, 0x14, 0x01, 0x16, 0x01, 0x17,
  82.    0x89, 0x13, 0xdd, 0x11, 0xf9, 0x10, 0x71, 0x10, 0x21, 0x10, 0x01, 0x10,
  83.    0xff, 0x1f};
  84. Tk_DefineBitmap(Et_Interp, Tk_GetUid("ck_on"), (char*)ck_on_bits, ck_on_width, ck_on_height);
  85. }
  86. {
  87. #define cross_width 14
  88. #define cross_height 14
  89. static  UNSIGNED_CHAR cross_bits[] = {
  90.    0x00, 0x00, 0x00, 0x00, 0x06, 0x18, 0x0e, 0x1c, 0x1c, 0x0e, 0x38, 0x07,
  91.    0xf0, 0x03, 0xe0, 0x01, 0xe0, 0x01, 0xf0, 0x03, 0x38, 0x07, 0x1c, 0x0e,
  92.    0x0e, 0x1c, 0x06, 0x18};
  93. Tk_DefineBitmap(Et_Interp, Tk_GetUid("cross"), (char*)cross_bits, cross_width, cross_height);
  94. }
  95. {
  96. #define decr_width 7
  97. #define decr_height 4
  98. static UNSIGNED_CHAR decr_bits[] = {
  99.    0x7f, 0x3e, 0x1c, 0x08};
  100. Tk_DefineBitmap(Et_Interp, Tk_GetUid("decr"), (char*)decr_bits, decr_width, decr_height);
  101. }
  102. {
  103. #define drop_width 16
  104. #define drop_height 16
  105. #define drop_x_hot 6
  106. #define drop_y_hot 4
  107. static UNSIGNED_CHAR drop_bits[] = {
  108.    0x00, 0x00, 0xfe, 0x07, 0x02, 0x04, 0x02, 0x04, 0x42, 0x04, 0xc2, 0x04,
  109.    0xc2, 0x05, 0xc2, 0x07, 0xc2, 0x07, 0xc2, 0x0f, 0xfe, 0x1f, 0xc0, 0x07,
  110.    0xc0, 0x06, 0x00, 0x0c, 0x00, 0x1c, 0x00, 0x08};
  111. Tk_DefineBitmap(Et_Interp, Tk_GetUid("drop"), (char*)drop_bits, drop_width, drop_height);
  112. }
  113. {
  114. #define file_width 12
  115. #define file_height 12
  116. static UNSIGNED_CHAR file_bits[] = {
  117.    0xfe, 0x00, 0x02, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
  118.    0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0xfe, 0x03};
  119. Tk_DefineBitmap(Et_Interp, Tk_GetUid("file"), (char*)file_bits, file_width, file_height);
  120. }
  121. {
  122. /* XPM */
  123. static char * file_xpm[] = {
  124. "12 12 3 1",
  125. "     s None    c None",
  126. ".    c black",
  127. "X    c #FFFFFFFFF3CE",
  128. " ........   ",
  129. " .XXXXXX.   ",
  130. " .XXXXXX... ",
  131. " .XXXXXXXX. ",
  132. " .XXXXXXXX. ",
  133. " .XXXXXXXX. ",
  134. " .XXXXXXXX. ",
  135. " .XXXXXXXX. ",
  136. " .XXXXXXXX. ",
  137. " .XXXXXXXX. ",
  138. " .XXXXXXXX. ",
  139. " .......... "};
  140. Tix_DefinePixmap(Et_Interp, Tk_GetUid("file"), file_xpm);
  141. }
  142. {
  143. #define folder_width 16
  144. #define folder_height 10
  145. static UNSIGNED_CHAR folder_bits[] = {
  146.    0xfc, 0x00, 0x02, 0x07, 0x01, 0x08, 0x01, 0x08, 0x01, 0x08, 0x01, 0x08,
  147.    0x01, 0x08, 0x01, 0x08, 0x01, 0x08, 0xff, 0x07};
  148. Tk_DefineBitmap(Et_Interp, Tk_GetUid("folder"), (char*)folder_bits, folder_width, folder_height);
  149. }
  150. {
  151. /* XPM */
  152. static char * folder_foo_xpm[] = {
  153. /* width height num_colors chars_per_pixel */
  154. "16 12 3 1",
  155. /* colors */
  156. "     s None    c None",
  157. ".    c black",
  158. "X    c #f0ff80",
  159. /* pixels */
  160. "   ....         ",
  161. "  .XXXX.        ",
  162. " .XXXXXX.       ",
  163. ".............   ",
  164. ".XXXXXXXXXXX.   ",
  165. ".XXXXXXXXXXX.   ",
  166. ".XXXXXXXXXXX.   ",
  167. ".XXXXXXXXXXX.   ",
  168. ".XXXXXXXXXXX.   ",
  169. ".XXXXXXXXXXX.   ",
  170. ".XXXXXXXXXXX.   ",
  171. ".............   "};
  172. Tix_DefinePixmap(Et_Interp, Tk_GetUid("folder"), folder_foo_xpm);
  173. }
  174. {
  175. #define harddisk_width 32
  176. #define harddisk_height 32
  177. static UNSIGNED_CHAR harddisk_bits[] = {
  178.    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  179.    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  180.    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  181.    0xf8, 0xff, 0xff, 0x1f, 0x08, 0x00, 0x00, 0x18, 0xa8, 0xaa, 0xaa, 0x1a,
  182.    0x48, 0x55, 0xd5, 0x1d, 0xa8, 0xaa, 0xaa, 0x1b, 0x48, 0x55, 0x55, 0x1d,
  183.    0xa8, 0xfa, 0xaf, 0x1a, 0xc8, 0xff, 0xff, 0x1d, 0xa8, 0xfa, 0xaf, 0x1a,
  184.    0x48, 0x55, 0x55, 0x1d, 0xa8, 0xaa, 0xaa, 0x1a, 0x48, 0x55, 0x55, 0x1d,
  185.    0xa8, 0xaa, 0xaa, 0x1a, 0xf8, 0xff, 0xff, 0x1f, 0xf8, 0xff, 0xff, 0x1f,
  186.    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  187.    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  188.    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
  189. Tk_DefineBitmap(Et_Interp, Tk_GetUid("harddisk"), (char*)harddisk_bits, harddisk_width, harddisk_height);
  190. }
  191. {
  192. #define hourglass_width 32
  193. #define hourglas_height 32
  194. #define hourglas_x_hot 16
  195. #define hourglas_y_hot 15
  196. static UNSIGNED_CHAR hourglas_bits[] = {
  197.    0xfe, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff,
  198.    0x7c, 0x00, 0x00, 0x7c, 0x7c, 0x00, 0x00, 0x7c, 0x7c, 0x00, 0x00, 0x7c,
  199.    0xfc, 0x00, 0x00, 0x7e, 0xfc, 0x00, 0x00, 0x7e, 0xfc, 0x00, 0x00, 0x7e,
  200.    0xbc, 0x01, 0x00, 0x7b, 0xbc, 0xfd, 0x7e, 0x7b, 0x3c, 0xfb, 0xbf, 0x79,
  201.    0x3c, 0xe6, 0xcf, 0x78, 0x3c, 0xdc, 0x77, 0x78, 0x3c, 0x38, 0x39, 0x78,
  202.    0x3c, 0x60, 0x0d, 0x78, 0x3c, 0x38, 0x38, 0x78, 0x3c, 0x1c, 0x71, 0x78,
  203.    0x3c, 0x06, 0xc1, 0x78, 0x3c, 0x03, 0x80, 0x79, 0xbc, 0x01, 0x00, 0x7b,
  204.    0xbc, 0x01, 0x00, 0x7b, 0xfc, 0x00, 0x01, 0x7e, 0xfc, 0x00, 0x01, 0x7e,
  205.    0xfc, 0x80, 0x03, 0x7e, 0x7c, 0xc0, 0x07, 0x7c, 0x7c, 0xf0, 0x1f, 0x7c,
  206.    0x7c, 0xfe, 0xff, 0x7c, 0xfe, 0xff, 0xff, 0x7f, 0xfe, 0xff, 0xff, 0xff,
  207.    0xfe, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff};
  208. Tk_DefineBitmap(Et_Interp, Tk_GetUid("hourglas"), (char*)hourglas_bits, hourglass_width, hourglas_height);
  209. }
  210. {
  211. #define incr_width 7
  212. #define incr_height 4
  213. static UNSIGNED_CHAR incr_bits[] = {
  214.    0x08, 0x1c, 0x3e, 0x7f};
  215. Tk_DefineBitmap(Et_Interp, Tk_GetUid("incr"), (char*)incr_bits, incr_width, incr_height);
  216. }
  217. {
  218. /* XPM */
  219. static char * info_xpm[] = {
  220. "32 32 3 1",
  221. "     s None    c None",
  222. ".    c #000000000000",
  223. "X    c white",
  224. "                                ",
  225. "           .........            ",
  226. "        ...XXXXXXXXX...         ",
  227. "       .XXXXXXXXXXXXXXX.        ",
  228. "     ..XXXXXXXXXXXXXXXXX..      ",
  229. "    .XXXXXXXXXXXXXXXXXXXXX.     ",
  230. "   .XXXXXXXXXX...XXXXXXXXXX.    ",
  231. "   .XXXXXXXXX.....XXXXXXXXX.    ",
  232. "  .XXXXXXXXX.......XXXXXXXXX.   ",
  233. " .XXXXXXXXXX.......XXXXXXXXXX.  ",
  234. " .XXXXXXXXXX.......XXXXXXXXXX.  ",
  235. " .XXXXXXXXXXX.....XXXXXXXXXXX.  ",
  236. ".XXXXXXXXXXXXX...XXXXXXXXXXXXX. ",
  237. ".XXXXXXXXXXXXXXXXXXXXXXXXXXXXX. ",
  238. ".XXXXXXXXXXXXXXXXXXXXXXXXXXXXX. ",
  239. ".XXXXXXXXXXX.......XXXXXXXXXXX. ",
  240. ".XXXXXXXXXXX.......XXXXXXXXXXX. ",
  241. ".XXXXXXXXXXX.......XXXXXXXXXXX. ",
  242. ".XXXXXXXXXXX.......XXXXXXXXXXX. ",
  243. ".XXXXXXXXXXX.......XXXXXXXXXXX. ",
  244. ".XXXXXXXXXXX.......XXXXXXXXXXX. ",
  245. " .XXXXXXXXXX.......XXXXXXXXXX.  ",
  246. " .XXXXXXXXXX.......XXXXXXXXXX.  ",
  247. " .XXXXXXXXXX.......XXXXXXXXXX.  ",
  248. "  .XXXXXXXXX.......XXXXXXXXX.   ",
  249. "   .XXXXXXXX.......XXXXXXXX.    ",
  250. "   .XXXXXXXX.......XXXXXXXX.    ",
  251. "    .XXXXXXXXXXXXXXXXXXXXX.     ",
  252. "     ..XXXXXXXXXXXXXXXXX..      ",
  253. "       .XXXXXXXXXXXXXXX.        ",
  254. "        ...XXXXXXXXX...         ",
  255. "           .........            "};
  256. Tix_DefinePixmap(Et_Interp, Tk_GetUid("info"), info_xpm);
  257. }
  258. {
  259. #define minimize_width 15
  260. #define minimize_height 15
  261. static UNSIGNED_CHAR minimize_bits[] = {
  262.    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x01,
  263.    0x20, 0x03, 0x20, 0x03, 0xe0, 0x03, 0xc0, 0x03, 0x00, 0x00, 0x00, 0x00,
  264.    0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
  265. Tk_DefineBitmap(Et_Interp, Tk_GetUid("minimize"), (char*)minimize_bits, minimize_width, minimize_height);
  266. }
  267. {
  268. #define minus_width 9
  269. #define minus_height 9
  270. static UNSIGNED_CHAR minus_bits[] = {
  271.    0xff, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x7d, 0x01, 0x01, 0x01,
  272.    0x01, 0x01, 0x01, 0x01, 0xff, 0x01};
  273. Tk_DefineBitmap(Et_Interp, Tk_GetUid("minus"), (char*)minus_bits, minus_width, minus_height);
  274. }
  275. {
  276. /* XPM */
  277. static char * minus_xpm[] = {
  278. "9 9 2 1",
  279. ".    s None    c None",
  280. "     c black",
  281. "         ",
  282. " ....... ",
  283. " ....... ",
  284. " ....... ",
  285. " .     . ",
  286. " ....... ",
  287. " ....... ",
  288. " ....... ",
  289. "         "};
  290. Tix_DefinePixmap(Et_Interp, Tk_GetUid("minus"), minus_xpm);
  291. }
  292. {
  293. #define minusarm_width 9
  294. #define minusarm_height 9
  295. static UNSIGNED_CHAR minusarm_bits[] = {
  296.    0xff, 0x01, 0x01, 0x01, 0x7d, 0x01, 0x7d, 0x01, 0x01, 0x01, 0x7d, 0x01,
  297.    0x7d, 0x01, 0x01, 0x01, 0xff, 0x01};
  298. Tk_DefineBitmap(Et_Interp, Tk_GetUid("minusarm"), (char*)minusarm_bits, minusarm_width, minusarm_height);
  299. }
  300. {
  301. /* XPM */
  302. static char * minusarm_xpm[] = {
  303. "9 9 3 1",
  304. "     c black",
  305. ".    c yellow",
  306. "X    c #808080808080",
  307. "         ",
  308. " ....... ",
  309. " ....... ",
  310. " .XXXXX. ",
  311. " .X   X. ",
  312. " .XXXXX. ",
  313. " ....... ",
  314. " ....... ",
  315. "         "};
  316. Tix_DefinePixmap(Et_Interp, Tk_GetUid("minusarm"), minusarm_xpm);
  317. }
  318. {
  319. #define network_width 32
  320. #define network_height 32
  321. static UNSIGNED_CHAR network_bits[] = {
  322.    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x7f, 0x00, 0x00, 0x02, 0x40,
  323.    0x00, 0x00, 0xfa, 0x5f, 0x00, 0x00, 0x0a, 0x50, 0x00, 0x00, 0x0a, 0x52,
  324.    0x00, 0x00, 0x0a, 0x52, 0x00, 0x00, 0x8a, 0x51, 0x00, 0x00, 0x0a, 0x50,
  325.    0x00, 0x00, 0x4a, 0x50, 0x00, 0x00, 0x0a, 0x50, 0x00, 0x00, 0x0a, 0x50,
  326.    0x00, 0x00, 0xfa, 0x5f, 0x00, 0x00, 0x02, 0x40, 0xfe, 0x7f, 0x52, 0x55,
  327.    0x02, 0x40, 0xaa, 0x6a, 0xfa, 0x5f, 0xfe, 0x7f, 0x0a, 0x50, 0xfe, 0x7f,
  328.    0x0a, 0x52, 0x80, 0x00, 0x0a, 0x52, 0x80, 0x00, 0x8a, 0x51, 0x80, 0x00,
  329.    0x0a, 0x50, 0x80, 0x00, 0x4a, 0x50, 0x80, 0x00, 0x0a, 0x50, 0xe0, 0x03,
  330.    0x0a, 0x50, 0x20, 0x02, 0xfa, 0xdf, 0x3f, 0x03, 0x02, 0x40, 0xa0, 0x02,
  331.    0x52, 0x55, 0xe0, 0x03, 0xaa, 0x6a, 0x00, 0x00, 0xfe, 0x7f, 0x00, 0x00,
  332.    0xfe, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
  333. Tk_DefineBitmap(Et_Interp, Tk_GetUid("network"), (char*)network_bits, network_width, network_height);
  334. }
  335. {
  336. /* XPM */
  337. static char * no_entry_xpm[] = {
  338. "32 32 4 1",
  339. "     s None    c None",
  340. ".    c #000000000000",
  341. "X    c red",
  342. "o    c yellow",
  343. "                                ",
  344. "           .........            ",
  345. "        ...XXXXXXXXX...         ",
  346. "       .XXXXXXXXXXXXXXX.        ",
  347. "     ..XXXXXXXXXXXXXXXXX..      ",
  348. "    .XXXXXXXXXXXXXXXXXXXXX.     ",
  349. "   .XXXXXXXXXXXXXXXXXXXXXXX.    ",
  350. "   .XXXXXXXXXXXXXXXXXXXXXXX.    ",
  351. "  .XXXXXXXXXXXXXXXXXXXXXXXXX.   ",
  352. " .XXXXXXXXXXXXXXXXXXXXXXXXXXX.  ",
  353. " .XXXXXXXXXXXXXXXXXXXXXXXXXXX.  ",
  354. " .XXXXXXXXXXXXXXXXXXXXXXXXXXX.  ",
  355. ".XXXXXXXXXXXXXXXXXXXXXXXXXXXXX. ",
  356. ".XXX.......................XXX. ",
  357. ".XXX.ooooooooooooooooooooo.XXX. ",
  358. ".XXX.ooooooooooooooooooooo.XXX. ",
  359. ".XXX.ooooooooooooooooooooo.XXX. ",
  360. ".XXX.ooooooooooooooooooooo.XXX. ",
  361. ".XXX.ooooooooooooooooooooo.XXX. ",
  362. ".XXX.ooooooooooooooooooooo.XXX. ",
  363. ".XXX.......................XXX. ",
  364. " .XXXXXXXXXXXXXXXXXXXXXXXXXXX.  ",
  365. " .XXXXXXXXXXXXXXXXXXXXXXXXXXX.  ",
  366. " .XXXXXXXXXXXXXXXXXXXXXXXXXXX.  ",
  367. "  .XXXXXXXXXXXXXXXXXXXXXXXXX.   ",
  368. "   .XXXXXXXXXXXXXXXXXXXXXXX.    ",
  369. "   .XXXXXXXXXXXXXXXXXXXXXXX.    ",
  370. "    .XXXXXXXXXXXXXXXXXXXXX.     ",
  371. "     ..XXXXXXXXXXXXXXXXX..      ",
  372. "       .XXXXXXXXXXXXXXX.        ",
  373. "        ...XXXXXXXXX...         ",
  374. "           .........            "};
  375. Tix_DefinePixmap(Et_Interp, Tk_GetUid("no_entry"), no_entry_xpm);
  376. }
  377. {
  378. #define openfile_width 16
  379. #define openfile_height 10
  380. static UNSIGNED_CHAR openfile_bits[] = {
  381.    0xf8, 0x01, 0x04, 0x06, 0x02, 0x08, 0x02, 0x10, 0xe2, 0xff, 0x52, 0x55,
  382.    0xaa, 0x2a, 0x56, 0x15, 0xaa, 0x0a, 0xfe, 0x07};
  383. Tk_DefineBitmap(Et_Interp, Tk_GetUid("openfile"), (char*)openfile_bits, openfile_width, openfile_height);
  384. }
  385. {
  386. #define openfold_width 16
  387. #define openfold_height 10
  388. static UNSIGNED_CHAR openfold_bits[] = {
  389.    0xfc, 0x00, 0x02, 0x07, 0x01, 0x08, 0xc1, 0xff, 0x21, 0x80, 0x11, 0x40,
  390.    0x09, 0x20, 0x05, 0x10, 0x03, 0x08, 0xff, 0x07};
  391. Tk_DefineBitmap(Et_Interp, Tk_GetUid("openfold"), (char*)openfold_bits, openfold_width, openfold_height);
  392. }
  393. {
  394. /* XPM */
  395. static char * openfolder_xpm[] = {
  396. /* width height num_colors chars_per_pixel */
  397. "16 12 3 1",
  398. /* colors */
  399. "     s None    c None",
  400. ".    c black",
  401. "X    c #f0ff80",
  402. /* pixels */
  403. "   ....         ",
  404. "  .XXXX.        ",
  405. " .XXXXXX.       ",
  406. ".............   ",
  407. ".XXXXXXXXXXX.   ",
  408. ".XXX............",
  409. ".XX.XXXXXXXXXXX.",
  410. ".XX.XXXXXXXXXX. ",
  411. ".X.XXXXXXXXXXX. ",
  412. ".X.XXXXXXXXXXX. ",
  413. "..XXXXXXXXXX..  ",
  414. ".............   "};
  415. Tix_DefinePixmap(Et_Interp, Tk_GetUid("openfold"), openfolder_xpm);
  416. }
  417. {
  418. #define plus_width 9
  419. #define plus_height 9
  420. static UNSIGNED_CHAR plus_bits[] = {
  421.    0xff, 0x01, 0x01, 0x01, 0x11, 0x01, 0x11, 0x01, 0x7d, 0x01, 0x11, 0x01,
  422.    0x11, 0x01, 0x01, 0x01, 0xff, 0x01};
  423. Tk_DefineBitmap(Et_Interp, Tk_GetUid("plus"), (char*)plus_bits, plus_width, plus_height);
  424. }
  425. {
  426. /* XPM */
  427. static char * plus_xpm[] = {
  428. "9 9 2 1",
  429. ".    s None    c None",
  430. "     c black",
  431. "         ",
  432. " ....... ",
  433. " ... ... ",
  434. " ... ... ",
  435. " .     . ",
  436. " ... ... ",
  437. " ... ... ",
  438. " ....... ",
  439. "         "};
  440. Tix_DefinePixmap(Et_Interp, Tk_GetUid("plus"), plus_xpm);
  441. }
  442. {
  443. #define plusarm_width 9
  444. #define plusarm_height 9
  445. static UNSIGNED_CHAR plusarm_bits[] = {
  446.    0xff, 0x01, 0x01, 0x01, 0x6d, 0x01, 0x6d, 0x01, 0x01, 0x01, 0x6d, 0x01,
  447.    0x6d, 0x01, 0x01, 0x01, 0xff, 0x01};
  448. Tk_DefineBitmap(Et_Interp, Tk_GetUid("plusarm"), (char*)plusarm_bits, plusarm_width, plusarm_height);
  449. }
  450. {
  451. /* XPM */
  452. static char * plusarm_xpm[] = {
  453. "9 9 3 1",
  454. "     c black",
  455. ".    c yellow",
  456. "X    c gray40",
  457. "         ",
  458. " ....... ",
  459. " ... ... ",
  460. " ..X X.. ",
  461. " .  X  . ",
  462. " ..X X.. ",
  463. " ... ... ",
  464. " ....... ",
  465. "         "};
  466. Tix_DefinePixmap(Et_Interp, Tk_GetUid("plusarm"), plusarm_xpm);
  467. }
  468. {
  469. #define resize1_width 13
  470. #define resize1_height 13
  471. #define resize1_x_hot 6
  472. #define resize1_y_hot 6
  473. static UNSIGNED_CHAR resize1_bits[] = {
  474.    0x7f, 0x00, 0x21, 0x00, 0x11, 0x00, 0x31, 0x00, 0x6d, 0x00, 0xdb, 0x00,
  475.    0xb1, 0x11, 0x60, 0x1b, 0xc0, 0x16, 0x80, 0x11, 0x00, 0x11, 0x80, 0x10,
  476.    0xc0, 0x1f};
  477. Tk_DefineBitmap(Et_Interp, Tk_GetUid("resize1"),(char*) resize1_bits, resize1_width, resize1_height);
  478. }
  479. {
  480. #define resize2_width 13
  481. #define resize2_height 13
  482. #define resize2_x_hot 6
  483. #define resize2_y_hot 6
  484. static UNSIGNED_CHAR resize2_bits[] = {
  485.    0xc0, 0x1f, 0x80, 0x10, 0x00, 0x11, 0x80, 0x11, 0xc0, 0x16, 0x60, 0x1b,
  486.    0xb1, 0x11, 0xdb, 0x00, 0x6d, 0x00, 0x31, 0x00, 0x11, 0x00, 0x21, 0x00,
  487.    0x7f, 0x00};
  488. Tk_DefineBitmap(Et_Interp, Tk_GetUid("resize2"), (char*)resize2_bits, resize2_width, resize2_height);
  489. }
  490. {
  491. #define restore_width 15
  492. #define restore_height 15
  493. static UNSIGNED_CHAR restore_bits[] = {
  494.    0x00, 0x00, 0x80, 0x00, 0xc0, 0x01, 0xe0, 0x03, 0xf0, 0x07, 0xf8, 0x0f,
  495.    0xfc, 0x1f, 0x00, 0x00, 0xfc, 0x1f, 0xf8, 0x0f, 0xf0, 0x07, 0xe0, 0x03,
  496.    0xc0, 0x01, 0x80, 0x00, 0x00, 0x00};
  497. Tk_DefineBitmap(Et_Interp, Tk_GetUid("restore"), (char*)restore_bits, restore_width, restore_height);
  498. }
  499. {
  500. #define srcfile_width 12
  501. #define srcfile_height 12
  502. static UNSIGNED_CHAR srcfile_bits[] = {
  503.    0xfe, 0x01, 0x02, 0x01, 0x02, 0x07, 0x02, 0x04, 0x72, 0x04, 0x8a, 0x04,
  504.    0x0a, 0x04, 0x0a, 0x04, 0x8a, 0x04, 0x72, 0x04, 0x02, 0x04, 0xfe, 0x07};
  505. Tk_DefineBitmap(Et_Interp, Tk_GetUid("srcfile"), (char*)srcfile_bits, srcfile_width, srcfile_height);
  506. }
  507. {
  508. /* XPM */
  509. static char * srcfile_xpm[] = {
  510. "12 12 3 1",
  511. "     s None    c None",
  512. ".    c black",
  513. "X    c gray91",
  514. " ........   ",
  515. " .XXXXXX.   ",
  516. " .XXXXXX... ",
  517. " .XXXXXXXX. ",
  518. " .XX...XXX. ",
  519. " .X.XXX.XX. ",
  520. " .X.XXXXXX. ",
  521. " .X.XXXXXX. ",
  522. " .X.XXX.XX. ",
  523. " .XX...XXX. ",
  524. " .XXXXXXXX. ",
  525. " .......... "};
  526. Tix_DefinePixmap(Et_Interp, Tk_GetUid("srcfile"), srcfile_xpm);
  527. }
  528. {
  529. #define system_width 15
  530. #define system_height 15
  531. static UNSIGNED_CHAR system_bits[] = {
  532.    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x3f,
  533.    0x02, 0x20, 0x02, 0x20, 0xfe, 0x3f, 0xfe, 0x3f, 0x00, 0x00, 0x00, 0x00,
  534.    0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
  535. Tk_DefineBitmap(Et_Interp, Tk_GetUid("system"), (char*)system_bits, system_width, system_height);
  536. }
  537. {
  538. #define textfile_width 12
  539. #define textfile_height 12
  540. static UNSIGNED_CHAR textfile_bits[] = {
  541.    0xfe, 0x01, 0x02, 0x01, 0x02, 0x07, 0x7a, 0x04, 0x02, 0x04, 0x3a, 0x04,
  542.    0x02, 0x04, 0xfa, 0x04, 0x02, 0x04, 0xfa, 0x04, 0x02, 0x04, 0xfe, 0x07};
  543. Tk_DefineBitmap(Et_Interp, Tk_GetUid("textfile"), (char*)textfile_bits, textfile_width, textfile_height);
  544. }
  545. {
  546. /* XPM */
  547. static char * textfile_xpm[] = {
  548. "12 12 3 1",
  549. "     s None    c None",
  550. ".    c black",
  551. "X    c #FFFFFFFFF3CE",
  552. " ........   ",
  553. " .XXXXXX.   ",
  554. " .XXXXXX... ",
  555. " .X....XXX. ",
  556. " .XXXXXXXX. ",
  557. " .X...XXXX. ",
  558. " .XXXXXXXX. ",
  559. " .X.....XX. ",
  560. " .XXXXXXXX. ",
  561. " .X.....XX. ",
  562. " .XXXXXXXX. ",
  563. " .......... "};
  564. Tix_DefinePixmap(Et_Interp, Tk_GetUid("textfile"), textfile_xpm);
  565. }
  566. {
  567. #define tick_width 14
  568. #define tick_height 14
  569. static UNSIGNED_CHAR tick_bits[] = {
  570.    0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x38, 0x00, 0x1c, 0x00, 0x0e,
  571.    0x00, 0x07, 0x80, 0x03, 0xc2, 0x01, 0xe7, 0x00, 0x7f, 0x00, 0x3e, 0x00,
  572.    0x1c, 0x00, 0x08, 0x00};
  573. Tk_DefineBitmap(Et_Interp, Tk_GetUid("tick"), (char*)tick_bits, tick_width, tick_height);
  574. }
  575. {
  576. /* XPM */
  577. static char * warning_xpm[] = {
  578. "32 32 3 1",
  579. "     s None    c None",
  580. ".    c #000000000000",
  581. "X    c yellow",
  582. "                                ",
  583. "           .........            ",
  584. "        ...XXXXXXXXX...         ",
  585. "       .XXXXXXXXXXXXXXX.        ",
  586. "     ..XXXXXXXXXXXXXXXXX..      ",
  587. "    .XXXXXXXXX...XXXXXXXXX.     ",
  588. "   .XXXXXXXXX.....XXXXXXXXX.    ",
  589. "   .XXXXXXXXX.....XXXXXXXXX.    ",
  590. "  .XXXXXXXXX.......XXXXXXXXX.   ",
  591. " .XXXXXXXXXX.......XXXXXXXXXX.  ",
  592. " .XXXXXXXXXX.......XXXXXXXXXX.  ",
  593. " .XXXXXXXXXX.......XXXXXXXXXX.  ",
  594. ".XXXXXXXXXXX.......XXXXXXXXXXX. ",
  595. ".XXXXXXXXXXX.......XXXXXXXXXXX. ",
  596. ".XXXXXXXXXXX.......XXXXXXXXXXX. ",
  597. ".XXXXXXXXXXX.......XXXXXXXXXXX. ",
  598. ".XXXXXXXXXXX.......XXXXXXXXXXX. ",
  599. ".XXXXXXXXXXXX.....XXXXXXXXXXXX. ",
  600. ".XXXXXXXXXXXX.....XXXXXXXXXXXX. ",
  601. ".XXXXXXXXXXXX.....XXXXXXXXXXXX. ",
  602. ".XXXXXXXXXXXXX...XXXXXXXXXXXXX. ",
  603. " .XXXXXXXXXXXXXXXXXXXXXXXXXXX.  ",
  604. " .XXXXXXXXXXXX...XXXXXXXXXXXX.  ",
  605. " .XXXXXXXXXXX.....XXXXXXXXXXX.  ",
  606. "  .XXXXXXXXX.......XXXXXXXXX.   ",
  607. "   .XXXXXXXX.......XXXXXXXX.    ",
  608. "   .XXXXXXXX.......XXXXXXXX.    ",
  609. "    .XXXXXXXX.....XXXXXXXX.     ",
  610. "     ..XXXXXXX...XXXXXXX..      ",
  611. "       .XXXXXXXXXXXXXXX.        ",
  612. "        ...XXXXXXXXX...         ",
  613. "           .........            "};
  614. Tix_DefinePixmap(Et_Interp, Tk_GetUid("warning"), warning_xpm);
  615. }
  616.