Posted to tcl by patthoyts at Sun Apr 19 23:46:58 GMT 2009view raw

  1. Index: generic/tkSquare.c
  2. ===================================================================
  3. RCS file: /cvsroot/tktoolkit/tk/generic/tkSquare.c,v
  4. retrieving revision 1.5
  5. diff -u -u -r1.5 tkSquare.c
  6. --- generic/tkSquare.c 17 Jan 2002 23:33:53 -0000 1.5
  7. +++ generic/tkSquare.c 13 Aug 2003 23:37:42 -0000
  8. @@ -34,6 +34,7 @@
  9. Tcl_Command widgetCmd; /* Token for square's widget command. */
  10. Tk_OptionTable optionTable; /* Token representing the configuration
  11. * specifications. */
  12. + Tk_Style style; /* Style currently applied. */
  13. Tcl_Obj *xPtr, *yPtr; /* Position of square's upper-left corner
  14. * within widget. */
  15. int x, y;
  16. @@ -85,6 +86,8 @@
  17. "raised", Tk_Offset(Square, reliefPtr), -1},
  18. {TK_OPTION_PIXELS, "-size", "size", "Size", "20",
  19. Tk_Offset(Square, sizeObjPtr), -1},
  20. + {TK_OPTION_STYLE, "-style", "style", "Style",
  21. + "", -1, Tk_Offset(Square, style)},
  22. {TK_OPTION_END}
  23. };
  24.  
  25. @@ -106,6 +109,95 @@
  26. XEvent *eventPtr));
  27. static int SquareWidgetObjCmd _ANSI_ARGS_((ClientData clientData,
  28. Tcl_Interp *, int objc, Tcl_Obj * CONST objv[]));
  29. +
  30. +/*
  31. + * Square element.
  32. + */
  33. +
  34. +Tk_GetElementSizeProc SquareElementGetSize;
  35. +Tk_GetElementBoxProc SquareElementGetBox;
  36. +Tk_GetElementBorderWidthProc SquareElementGetBorderWidth;
  37. +Tk_DrawElementProc SquareElementDraw;
  38. +
  39. +enum {
  40. + SQUARE_ELEMENT_FOREGROUND,
  41. + SQUARE_ELEMENT_BORDERWIDTH,
  42. + SQUARE_ELEMENT_POSX,
  43. + SQUARE_ELEMENT_POSY,
  44. + SQUARE_ELEMENT_SIZE
  45. +} squareElementOption;
  46. +
  47. +Tk_ElementOptionSpec squareElementOptions[] = {
  48. + {"-foreground", TK_OPTION_BORDER},
  49. + {"-borderwidth", TK_OPTION_PIXELS},
  50. + {"-posx", TK_OPTION_PIXELS},
  51. + {"-posy", TK_OPTION_PIXELS},
  52. + {"-size", TK_OPTION_PIXELS},
  53. + {NULL}
  54. +};
  55. +Tk_ElementSpec squareElementSpec = {
  56. + /* Version */
  57. + TK_STYLE_VERSION_1,
  58. +
  59. + /* Name of the element */
  60. + "Square.square",
  61. +
  62. + /* Options. */
  63. + squareElementOptions,
  64. +
  65. + /* Hooks. */
  66. + SquareElementGetSize, /* getSize */
  67. + SquareElementGetBox, /* getBox */
  68. + SquareElementGetBorderWidth, /* getBorderWidth */
  69. + SquareElementDraw /* draw */
  70. +};
  71. +
  72. +int squareElementId;
  73. +
  74. +
  75. +/*
  76. + * Variant of square element with fixed border width (used by instances of the
  77. + * "fixedborder" engine).
  78. + */
  79. +
  80. +Tk_GetElementSizeProc FSquareElementGetSize;
  81. +Tk_GetElementBoxProc FSquareElementGetBox;
  82. +Tk_GetElementBorderWidthProc FSquareElementGetBorderWidth;
  83. +Tk_DrawElementProc FSquareElementDraw;
  84. +
  85. +enum {
  86. + FIXED_SQUARE_ELEMENT_FOREGROUND,
  87. + FIXED_SQUARE_ELEMENT_POSX,
  88. + FIXED_SQUARE_ELEMENT_POSY,
  89. + FIXED_SQUARE_ELEMENT_SIZE
  90. +} fSquareElementOption;
  91. +
  92. +Tk_ElementOptionSpec fSquareElementOptions[] = {
  93. + {"-foreground", TK_OPTION_BORDER},
  94. + {"-posx", TK_OPTION_PIXELS},
  95. + {"-posy", TK_OPTION_PIXELS},
  96. + {"-size", TK_OPTION_PIXELS},
  97. + {NULL}
  98. +};
  99. +Tk_ElementSpec fSquareElementSpec = {
  100. + /* Version */
  101. + TK_STYLE_VERSION_1,
  102. +
  103. + /* Name of the element */
  104. + "Square.square",
  105. +
  106. + /* Options. */
  107. + fSquareElementOptions,
  108. +
  109. + /* Hooks. */
  110. + FSquareElementGetSize, /* getSize */
  111. + FSquareElementGetBox, /* getBox */
  112. + FSquareElementGetBorderWidth, /* getBorderWidth */
  113. + FSquareElementDraw /* draw */
  114. +};
  115. +
  116. +
  117. +
  118.  
  119. /*
  120. *--------------------------------------------------------------
  121. @@ -173,6 +265,7 @@
  122. (ClientData) squarePtr, SquareDeletedProc);
  123. squarePtr->gc = None;
  124. squarePtr->optionTable = optionTable;
  125. + squarePtr->style = NULL;
  126.  
  127. if (Tk_InitOptions(interp, (char *) squarePtr, optionTable, tkwin)
  128. != TCL_OK) {
  129. @@ -484,8 +577,9 @@
  130. Pixmap pm = None;
  131. Drawable d;
  132. int borderWidth, size, relief;
  133. - Tk_3DBorder bgBorder, fgBorder;
  134. + Tk_3DBorder bgBorder;
  135. int doubleBuffer;
  136. + Tk_StyledElement squareElement;
  137.  
  138. squarePtr->updatePending = 0;
  139. if (!Tk_IsMapped(tkwin)) {
  140. @@ -523,10 +617,10 @@
  141. */
  142.  
  143. Tk_GetPixelsFromObj(NULL, squarePtr->tkwin, squarePtr->sizeObjPtr, &size);
  144. - fgBorder = Tk_Get3DBorderFromObj(squarePtr->tkwin,
  145. - squarePtr->fgBorderPtr);
  146. - Tk_Fill3DRectangle(tkwin, d, fgBorder, squarePtr->x, squarePtr->y, size,
  147. - size, borderWidth, TK_RELIEF_RAISED);
  148. + squareElement = Tk_GetStyledElement(squarePtr->style, squareElementId,
  149. + squarePtr->optionTable);
  150. + Tk_DrawElement(squarePtr->style, squareElement, (char *) squarePtr,
  151. + squarePtr->tkwin, d, squarePtr->x, squarePtr->y, size, size, 0);
  152.  
  153. /*
  154. * If double-buffered, copy to the screen and release the pixmap.
  155. @@ -618,4 +712,236 @@
  156. if (squarePtr->y < bd) {
  157. squarePtr->y = bd;
  158. }
  159. +}
  160. +
  161. +int
  162. +GetPixelsFromWidget(tkwin, recordPtr, specPtr, intPtr)
  163. + Tk_Window tkwin;
  164. + char *recordPtr;
  165. + CONST Tk_OptionSpec *specPtr;
  166. + int *intPtr;
  167. +{
  168. + if (specPtr) {
  169. + if (specPtr->internalOffset != -1) {
  170. + *intPtr = *(int *) (recordPtr+specPtr->internalOffset);
  171. + return TCL_OK;
  172. + } else if (specPtr->objOffset != -1) {
  173. + return Tk_GetPixelsFromObj(NULL, tkwin,
  174. + *(Tcl_Obj **) (recordPtr+specPtr->objOffset),
  175. + intPtr);
  176. + }
  177. + }
  178. + return TCL_ERROR;
  179. +}
  180. +
  181. +int
  182. +Get3DBorderFromWidget(tkwin, recordPtr, specPtr, borderPtr)
  183. + Tk_Window tkwin;
  184. + char *recordPtr;
  185. + CONST Tk_OptionSpec *specPtr;
  186. + Tk_3DBorder *borderPtr;
  187. +{
  188. + if (specPtr) {
  189. + if (specPtr->internalOffset != -1) {
  190. + *borderPtr = *(Tk_3DBorder *) (recordPtr+specPtr->internalOffset);
  191. + return TCL_OK;
  192. + } else if (specPtr->objOffset != -1) {
  193. + *borderPtr = Tk_Get3DBorderFromObj(tkwin,
  194. + *(Tcl_Obj **) (recordPtr+specPtr->objOffset));
  195. + return TCL_OK;
  196. + }
  197. + }
  198. + return TCL_ERROR;
  199. +}
  200. +
  201. +
  202. +
  203. +void
  204. +SquareInit(interp)
  205. + Tcl_Interp *interp;
  206. +{
  207. + Tk_StyleEngine engine;
  208. +
  209. + /*
  210. + * Register the default square element implementation.
  211. + */
  212. +
  213. + squareElementId = Tk_RegisterStyledElement(NULL, &squareElementSpec);
  214. +
  215. + /*
  216. + * Create a new "flat" style engine derived from the default engine, and
  217. + * register a new square element implementation.
  218. + */
  219. +
  220. + engine = Tk_RegisterStyleEngine("fixedborder", NULL);
  221. + Tk_RegisterStyledElement(engine, &fSquareElementSpec);
  222. +
  223. + /*
  224. + * Create various instances of the "fixedborder" engine. The client data
  225. + * gives the fixed border width in pixels.
  226. + */
  227. +
  228. + Tk_CreateStyle("flat", engine, (ClientData) 0);
  229. + Tk_CreateStyle("border2", engine, (ClientData) 2);
  230. + Tk_CreateStyle("border4", engine, (ClientData) 4);
  231. + Tk_CreateStyle("border8", engine, (ClientData) 8);
  232. +}
  233. +
  234. +void
  235. +SquareElementGetSize(clientData, recordPtr, optionsPtr, tkwin, width, height,
  236. + inner, widthPtr, heightPtr)
  237. + ClientData clientData;
  238. + char *recordPtr;
  239. + CONST Tk_OptionSpec **optionsPtr;
  240. + Tk_Window tkwin;
  241. + int width, height;
  242. + int inner;
  243. + int *widthPtr, *heightPtr;
  244. +{
  245. +}
  246. +
  247. +void
  248. +SquareElementGetBox(clientData, recordPtr, optionsPtr, tkwin, x, y, width,
  249. + height, inner, xPtr, yPtr, widthPtr, heightPtr)
  250. + ClientData clientData;
  251. + char *recordPtr;
  252. + CONST Tk_OptionSpec **optionsPtr;
  253. + Tk_Window tkwin;
  254. + int x, y;
  255. + int width, height;
  256. + int inner;
  257. + int *xPtr, *yPtr;
  258. + int *widthPtr, *heightPtr;
  259. +{
  260. +}
  261. +
  262. +int
  263. +SquareElementGetBorderWidth(clientData, recordPtr, optionsPtr, tkwin)
  264. + ClientData clientData;
  265. + char *recordPtr;
  266. + CONST Tk_OptionSpec **optionsPtr;
  267. + Tk_Window tkwin;
  268. +{
  269. + int borderWidth = 0;
  270. +
  271. + /* TODO: quick shortcut % optionTable. */
  272. + GetPixelsFromWidget(tkwin, recordPtr,
  273. + optionsPtr[SQUARE_ELEMENT_BORDERWIDTH], &borderWidth);
  274. + return borderWidth;
  275. +}
  276. +
  277. +void
  278. +SquareElementDraw(clientData, recordPtr, optionsPtr, tkwin, d, x, y, width,
  279. + height, state)
  280. + ClientData clientData;
  281. + char *recordPtr;
  282. + CONST Tk_OptionSpec **optionsPtr;
  283. + Tk_Window tkwin;
  284. + Drawable d;
  285. + int x, y;
  286. + int width, height;
  287. + int state;
  288. +{
  289. + int borderWidth = 0;
  290. + Tk_3DBorder fgBorder = NULL;
  291. +
  292. + /* TODO: quick shortcut % optionTable. */
  293. +
  294. + /*
  295. + * Get option values.
  296. + */
  297. +
  298. + /* Foreground border. */
  299. + Get3DBorderFromWidget(tkwin, recordPtr,
  300. + optionsPtr[SQUARE_ELEMENT_FOREGROUND], &fgBorder);
  301. + if (!fgBorder) {
  302. + /*
  303. + * No border to draw.
  304. + */
  305. +
  306. + return;
  307. + }
  308. +
  309. + /* Border width. */
  310. + GetPixelsFromWidget(tkwin, recordPtr,
  311. + optionsPtr[SQUARE_ELEMENT_BORDERWIDTH], &borderWidth);
  312. +
  313. + Tk_Fill3DRectangle(tkwin, d, fgBorder, x, y, width, height, borderWidth,
  314. + TK_RELIEF_RAISED);
  315. +}
  316. +
  317. +void
  318. +FSquareElementGetSize(clientData, recordPtr, optionsPtr, tkwin, width, height,
  319. + inner, widthPtr, heightPtr)
  320. + ClientData clientData;
  321. + char *recordPtr;
  322. + CONST Tk_OptionSpec **optionsPtr;
  323. + Tk_Window tkwin;
  324. + int width, height;
  325. + int inner;
  326. + int *widthPtr, *heightPtr;
  327. +{
  328. +}
  329. +
  330. +void
  331. +FSquareElementGetBox(clientData, recordPtr, optionsPtr, tkwin, x, y, width,
  332. + height, inner, xPtr, yPtr, widthPtr, heightPtr)
  333. + ClientData clientData;
  334. + char *recordPtr;
  335. + CONST Tk_OptionSpec **optionsPtr;
  336. + Tk_Window tkwin;
  337. + int x, y;
  338. + int width, height;
  339. + int inner;
  340. + int *xPtr, *yPtr;
  341. + int *widthPtr, *heightPtr;
  342. +{
  343. +}
  344. +
  345. +int
  346. +FSquareElementGetBorderWidth(clientData, recordPtr, optionsPtr, tkwin)
  347. + ClientData clientData;
  348. + char *recordPtr;
  349. + CONST Tk_OptionSpec **optionsPtr;
  350. + Tk_Window tkwin;
  351. +{
  352. + int borderWidth = (int) clientData;
  353. +
  354. + return borderWidth;
  355. +}
  356. +
  357. +void
  358. +FSquareElementDraw(clientData, recordPtr, optionsPtr, tkwin, d, x, y, width,
  359. + height, state)
  360. + ClientData clientData;
  361. + char *recordPtr;
  362. + CONST Tk_OptionSpec **optionsPtr;
  363. + Tk_Window tkwin;
  364. + Drawable d;
  365. + int x, y;
  366. + int width, height;
  367. + int state;
  368. +{
  369. + int borderWidth = (int) clientData;
  370. + Tk_3DBorder fgBorder = NULL;
  371. +
  372. + /* TODO: quick shortcut % optionTable. */
  373. +
  374. + /*
  375. + * Get option values.
  376. + */
  377. +
  378. + /* Foreground border. */
  379. + Get3DBorderFromWidget(tkwin, recordPtr,
  380. + optionsPtr[FIXED_SQUARE_ELEMENT_FOREGROUND], &fgBorder);
  381. + if (!fgBorder) {
  382. + /*
  383. + * No border to draw.
  384. + */
  385. +
  386. + return;
  387. + }
  388. +
  389. + Tk_Fill3DRectangle(tkwin, d, fgBorder, x, y, width, height, borderWidth,
  390. + TK_RELIEF_RAISED);
  391. }