Rahmen.cpp 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372
  1. #include "Rahmen.h"
  2. #include "Bild.h"
  3. #include "Punkt.h"
  4. #include "Scroll.h"
  5. #include "Text.h"
  6. #include "ToolTip.h"
  7. using namespace Framework;
  8. // Inhalt der Rahmen Klasse aus Rahmen.h
  9. // Konstruktor
  10. Rahmen::Rahmen()
  11. : Zeichnung(),
  12. br(1),
  13. farbe(0xFF000000),
  14. alpha(0),
  15. breaks(0)
  16. {}
  17. // Destruktor
  18. Rahmen::~Rahmen() {}
  19. // nicht constant
  20. void Rahmen::setRamenBreite(int br) // setzt die Breite des Rahmens
  21. {
  22. this->br = br;
  23. rend = 1;
  24. }
  25. // wenn dieser Flag gesetzt wird, wird der Rahmen gestrichelt gezeichnet
  26. // br: 1 -> gestrichelt, 0 -> durchgehend
  27. void Rahmen::setBreaks(bool br, int brOff, int brLength, int lineLength)
  28. {
  29. breaks = br;
  30. breakOffset = brOff;
  31. breakLength = brLength;
  32. this->lineLength = lineLength;
  33. rend = 1;
  34. }
  35. void Rahmen::setAlpha(
  36. bool a) // Legt fest, ob der Alphawert der Farbe berücksichtigt werden soll
  37. {
  38. alpha = a;
  39. rend = 1;
  40. }
  41. void Rahmen::setFarbe(int f) // Legt die Farbe des Rahmens fest
  42. {
  43. farbe = f;
  44. rend = 1;
  45. }
  46. int Rahmen::getFarbe() const // Gibt die Farbe des Ramens zurück
  47. {
  48. return farbe;
  49. }
  50. bool Rahmen::hatAlpha()
  51. const // Gibt zurück, ob der Alphawert der Farbe beachtet wird
  52. {
  53. return alpha;
  54. }
  55. int Rahmen::getRBreite() const // Gibt die Breite des Rahmens zurück
  56. {
  57. return br;
  58. }
  59. // Gibt 1 zurück, falls der Rahmen gestrichelt gezeichnet wird
  60. bool Rahmen::hasBreaks() const
  61. {
  62. return breaks;
  63. }
  64. // startpunkt des ersten linienabschnittes
  65. int Rahmen::getBreakOffset() const
  66. {
  67. return breakOffset;
  68. }
  69. // länge einer lücke
  70. int Rahmen::getBreakLength() const
  71. {
  72. return breakLength;
  73. }
  74. // länge einer linie
  75. int Rahmen::getLineLength() const
  76. {
  77. return lineLength;
  78. }
  79. // Inhalt der LRahmen Klasse aus Rahmen.h
  80. // Konstruktor
  81. LRahmen::LRahmen()
  82. : Rahmen()
  83. {}
  84. // Destruktor
  85. LRahmen::~LRahmen() {}
  86. void LRahmen::render(Bild& Obj) // Zeichnet den Rahmen in das RenderZeichnung
  87. {
  88. Zeichnung::render(Obj);
  89. int x = 0;
  90. int y = 0;
  91. int b = gr.x - 1;
  92. int h = gr.y - 1;
  93. if (!Obj.setDrawOptions(pos.x, pos.y, gr.x, gr.y)) return;
  94. if (!breaks)
  95. {
  96. if (alpha)
  97. {
  98. for (int i = 0; i < br; ++i)
  99. {
  100. Obj.drawLinieHAlpha(x + i + 1, y + i, gr.x - i * 2 - 1, farbe);
  101. Obj.drawLinieVAlpha(b - i, y + i + 1, gr.y - i * 2 - 2, farbe);
  102. Obj.drawLinieHAlpha(x + i + 1, h - i, gr.x - i * 2 - 1, farbe);
  103. Obj.drawLinieVAlpha(x + i, y + i, gr.y - i * 2, farbe);
  104. }
  105. }
  106. else
  107. {
  108. for (int i = 0; i < br; ++i)
  109. {
  110. Obj.drawLinieH(x + i + 1, y + i, gr.x - i * 2 - 1, farbe);
  111. Obj.drawLinieV(b - i, y + i + 1, gr.y - i * 2 - 2, farbe);
  112. Obj.drawLinieH(x + i + 1, h - i, gr.x - i * 2 - 1, farbe);
  113. Obj.drawLinieV(x + i, y + i, gr.y - i * 2, farbe);
  114. }
  115. }
  116. }
  117. else
  118. {
  119. if (alpha)
  120. {
  121. for (int i = 0; i < br; ++i)
  122. {
  123. for (int x = breakOffset; x < gr.x;
  124. x += lineLength + breakLength)
  125. Obj.drawLinieHAlpha(x + i + 1,
  126. y + i,
  127. lineLength
  128. - (x + i + 1 + lineLength > gr.x - i - 1
  129. ? gr.x - i - 1 - (x + i + 1 + lineLength)
  130. : 0),
  131. farbe);
  132. for (int x = gr.x - breakOffset - lineLength; x >= 0;
  133. x -= lineLength + breakLength)
  134. Obj.drawLinieHAlpha(MAX(x + i + 1, i + 1),
  135. h - i,
  136. lineLength
  137. - (x + i + 1 < i + 1 ? i + 1 - (x + i + 1) : 0),
  138. farbe);
  139. for (int y = breakOffset; y < gr.y;
  140. y += lineLength + breakLength)
  141. Obj.drawLinieVAlpha(b - i,
  142. y + i + 1,
  143. lineLength
  144. - (y + i + 1 + lineLength > gr.y - i - 1
  145. ? gr.y - i - 1 - (y + i + 1 + lineLength)
  146. : 0),
  147. farbe);
  148. for (int y = gr.y - breakOffset - lineLength; y >= 0;
  149. y -= lineLength + breakLength)
  150. Obj.drawLinieVAlpha(x + i,
  151. MAX(y + i, i),
  152. lineLength - (y + i < i ? i - (y + i) : 0),
  153. farbe);
  154. }
  155. }
  156. else
  157. {
  158. for (int i = 0; i < br; ++i)
  159. {
  160. for (int x = breakOffset; x < gr.x;
  161. x += lineLength + breakLength)
  162. Obj.drawLinieH(x + i + 1,
  163. y + i,
  164. lineLength
  165. - (x + i + 1 + lineLength > gr.x - i - 1
  166. ? gr.x - i - 1 - (x + i + 1 + lineLength)
  167. : 0),
  168. farbe);
  169. for (int x = gr.x - breakOffset - lineLength; x >= 0;
  170. x -= lineLength + breakLength)
  171. Obj.drawLinieH(MAX(x + i + 1, i + 1),
  172. h - i,
  173. lineLength
  174. - (x + i + 1 < i + 1 ? i + 1 - (x + i + 1) : 0),
  175. farbe);
  176. for (int y = breakOffset; y < gr.y;
  177. y += lineLength + breakLength)
  178. Obj.drawLinieV(b - i,
  179. y + i + 1,
  180. lineLength
  181. - (y + i + 1 + lineLength > gr.y - i - 1
  182. ? gr.y - i - 1 - (y + i + 1 + lineLength)
  183. : 0),
  184. farbe);
  185. for (int y = gr.y - breakOffset - lineLength; y >= 0;
  186. y -= lineLength + breakLength)
  187. Obj.drawLinieV(x + i,
  188. MAX(y + i, i),
  189. lineLength - (y + i < i ? i - (y + i) : 0),
  190. farbe);
  191. }
  192. }
  193. }
  194. Obj.releaseDrawOptions();
  195. }
  196. Zeichnung* LRahmen::dublizieren() const // Kopiert das Zeichnung
  197. {
  198. Rahmen* obj = new LRahmen();
  199. obj->setPosition(pos);
  200. obj->setSize(gr);
  201. obj->setMausEreignisParameter(makParam);
  202. obj->setTastaturEreignisParameter(takParam);
  203. obj->setMausEreignis(mak);
  204. obj->setTastaturEreignis(tak);
  205. if (toolTip) obj->setToolTipZ((ToolTip*)toolTip->dublizieren());
  206. obj->setBreaks(breaks);
  207. obj->setAlpha(alpha);
  208. obj->setFarbe(farbe);
  209. obj->setRamenBreite(br);
  210. return obj;
  211. }
  212. // Inhalt der Rahmen3D Klasse aus Rahmen.h
  213. // Konstruktor
  214. Rahmen3D::Rahmen3D()
  215. : Rahmen()
  216. {
  217. alpha = 1;
  218. farbe = 0x70FFFFFF;
  219. br = 5;
  220. }
  221. // Destruktor
  222. Rahmen3D::~Rahmen3D() {}
  223. void Rahmen3D::render(Bild& Obj) // Zeichnet den Rahmen in das RenderZeichnung
  224. {
  225. Zeichnung::render(Obj);
  226. int x = 0;
  227. int y = 0;
  228. int b = gr.x - 1;
  229. int h = gr.y - 1;
  230. int fcomp = (farbe & 0xFF000000) | (~farbe & 0x00FFFFFF);
  231. if (!Obj.setDrawOptions(pos.x, pos.y, gr.x, gr.y)) return;
  232. if (!breaks)
  233. {
  234. if (alpha)
  235. {
  236. for (int i = 0; i < br; ++i)
  237. {
  238. Obj.drawLinieHAlpha(x + i + 1, y + i, gr.x - i * 2 - 1, farbe);
  239. Obj.drawLinieVAlpha(b - i, y + i + 1, gr.y - i * 2 - 2, farbe);
  240. Obj.drawLinieHAlpha(x + i + 1, h - i, gr.x - i * 2 - 1, fcomp);
  241. Obj.drawLinieVAlpha(x + i, y + i, gr.y - i * 2, fcomp);
  242. }
  243. }
  244. else
  245. {
  246. for (int i = 0; i < br; ++i)
  247. {
  248. Obj.drawLinieH(x + i + 1, y + i, gr.x - i * 2 - 1, farbe);
  249. Obj.drawLinieV(b - i, y + i + 1, gr.y - i * 2 - 2, farbe);
  250. Obj.drawLinieH(x + i + 1, h - i, gr.x - i * 2 - 1, fcomp);
  251. Obj.drawLinieV(x + i, y + i, gr.y - i * 2, fcomp);
  252. }
  253. }
  254. }
  255. else
  256. {
  257. if (alpha)
  258. {
  259. for (int i = 0; i < br; ++i)
  260. {
  261. for (int x = breakOffset; x < gr.x;
  262. x += lineLength + breakLength)
  263. Obj.drawLinieHAlpha(x + i + 1,
  264. y + i,
  265. lineLength
  266. - (x + i + 1 + lineLength > gr.x - i - 1
  267. ? gr.x - i - 1 - (x + i + 1 + lineLength)
  268. : 0),
  269. farbe);
  270. for (int x = gr.x - breakOffset - lineLength; x >= 0;
  271. x -= lineLength + breakLength)
  272. Obj.drawLinieHAlpha(MAX(x + i + 1, i + 1),
  273. h - i,
  274. lineLength
  275. - (x + i + 1 < i + 1 ? i + 1 - (x + i + 1) : 0),
  276. fcomp);
  277. for (int y = breakOffset; y < gr.y;
  278. y += lineLength + breakLength)
  279. Obj.drawLinieVAlpha(b - i,
  280. y + i + 1,
  281. lineLength
  282. - (y + i + 1 + lineLength > gr.y - i - 1
  283. ? gr.y - i - 1 - (y + i + 1 + lineLength)
  284. : 0),
  285. farbe);
  286. for (int y = gr.y - breakOffset - lineLength; y >= 0;
  287. y -= lineLength + breakLength)
  288. Obj.drawLinieVAlpha(x + i,
  289. MAX(y + i, i),
  290. lineLength - (y + i < i ? i - (y + i) : 0),
  291. fcomp);
  292. }
  293. }
  294. else
  295. {
  296. for (int i = 0; i < br; ++i)
  297. {
  298. for (int x = breakOffset; x < gr.x;
  299. x += lineLength + breakLength)
  300. Obj.drawLinieH(x + i + 1,
  301. y + i,
  302. lineLength
  303. - (x + i + 1 + lineLength > gr.x - i - 1
  304. ? gr.x - i - 1 - (x + i + 1 + lineLength)
  305. : 0),
  306. farbe);
  307. for (int x = gr.x - breakOffset - lineLength; x >= 0;
  308. x -= lineLength + breakLength)
  309. Obj.drawLinieH(MAX(x + i + 1, i + 1),
  310. h - i,
  311. lineLength
  312. - (x + i + 1 < i + 1 ? i + 1 - (x + i + 1) : 0),
  313. fcomp);
  314. for (int y = breakOffset; y < gr.y;
  315. y += lineLength + breakLength)
  316. Obj.drawLinieV(b - i,
  317. y + i + 1,
  318. lineLength
  319. - (y + i + 1 + lineLength > gr.y - i - 1
  320. ? gr.y - i - 1 - (y + i + 1 + lineLength)
  321. : 0),
  322. farbe);
  323. for (int y = gr.y - breakOffset - lineLength; y >= 0;
  324. y -= lineLength + breakLength)
  325. Obj.drawLinieV(x + i,
  326. MAX(y + i, i),
  327. lineLength - (y + i < i ? i - (y + i) : 0),
  328. fcomp);
  329. }
  330. }
  331. }
  332. Obj.releaseDrawOptions();
  333. }
  334. Zeichnung* Rahmen3D::dublizieren() const // Kopiert das Zeichnung
  335. {
  336. Rahmen* obj = new Rahmen3D();
  337. obj->setPosition(pos);
  338. obj->setSize(gr);
  339. obj->setMausEreignisParameter(makParam);
  340. obj->setTastaturEreignisParameter(takParam);
  341. obj->setMausEreignis(mak);
  342. obj->setTastaturEreignis(tak);
  343. if (toolTip) obj->setToolTipZ((ToolTip*)toolTip->dublizieren());
  344. obj->setBreaks(breaks);
  345. obj->setAlpha(alpha);
  346. obj->setFarbe(farbe);
  347. obj->setRamenBreite(br);
  348. return obj;
  349. }